Code cleanup

Bolje definirao header
Promijenio iz big endian u little endian
Smanjio broj globalnih varijabli

Author: Mive82

.gitignore

@@ -2,6 +2,7 @@
 badapple
 halfframes
 video
+prezentacija
 *.txt
 *.img
 *.bin

arduino/Makefile

@@ -4,7 +4,7 @@ PROGRAMMER = arduino
 PORT	   = /dev/ttyUSB0
 BAUD       = 57600
 FILENAME   = main
-COMPILE    = avr-gcc -Wall -Wpedantic -Wshadow -Os -mmcu=$(DEVICE)
+COMPILE    = avr-gcc -pipe -Wall -Wpedantic -Wshadow -Os -mmcu=$(DEVICE)
 
 
 all: build upload clean
@@ -20,7 +20,7 @@ build:
 	avr-size --format=avr --mcu=$(DEVICE) $(FILENAME).elf
 
 upload:
-	avrdude -p $(DEVICE) -c $(PROGRAMMER) -P $(PORT) -b $(BAUD) -U flash:w:$(FILENAME).hex:i 
+	avrdude -p $(DEVICE) -c $(PROGRAMMER) -P $(PORT) -b $(BAUD) -D -U flash:w:$(FILENAME).hex:i 
 
 clean:
 	rm -f *.elf

arduino/i2c.h

@@ -22,7 +22,6 @@
 #include <util/twi.h> // I2C library
 
 extern volatile uint8_t i2c_address;
-extern volatile uint8_t received;
 
 void i2c_init(uint8_t add);
 

arduino/main.c

@@ -21,24 +21,40 @@
 #include <util/delay.h>
 #include <avr/interrupt.h>
 #include <avr/pgmspace.h>
+#include <string.h>
 
 #include "serial.h"
 #include "sdimg.h"
 #include "i2c.h"
 #include "oled.h"
 #include "sd.h"
 
-volatile uint8_t fail_state = 0;
-volatile uint16_t n_frames = 0;
-volatile uint16_t data_ptr = 0;
-volatile uint8_t sd_type = 0;
-volatile uint8_t done = 0;
-volatile uint8_t loop = 0;
+// Header, prvi dio prvih 512 bajtova
+typedef struct _header header;
+struct _header
+{
+    uint8_t h_width;
+    uint8_t h_height;
+    uint16_t h_frames;
+    uint8_t h_header_text[7];
+    uint8_t h_loop;
+};
+
+typedef struct _playbackinfo playbackinfo;
+struct _playbackinfo
+{
+    uint8_t v_width;
+    uint8_t v_height;
+    uint16_t v_frames;
+    uint8_t v_loop;
+    uint8_t v_sd_type;
+    uint8_t v_done;
+    uint8_t v_fail_state;
+};
 
 uint8_t res[5], token;
-uint8_t header_text[] = {0x62, 0x61, 0x64, 0x75, 0x69, 0x6E, 0x6F}; // "baduino"
 
-void error_image()
+void error_image(const uint8_t fail_state)
 {
     if (fail_state == 0)
     {
@@ -58,76 +74,89 @@ void error_image()
     }
 }
 
-void read_header()
+void check_sd(playbackinfo *videoInfo)
+{
+    videoInfo->v_fail_state = 0;
+    if (SD_init(&(videoInfo->v_sd_type)) == SD_SUCCESS)
+    {
+        //uart_putstr("Success!\n");
+    }
+    else
+    {
+        //uart_putstr("No SD card\n");
+        videoInfo->v_fail_state = 1;
+    }
+    return;
+}
+
+void read_header(playbackinfo *videoInfo)
 {
-    if (done)
+    if (videoInfo->v_done)
     {
         return;
     }
+
     res[0] = SD_readSingleBlock(0, frame_buffer, &token); // read first 512 bytes
+
     // parse header
     if (SD_R1_NO_ERROR(res[0]) && (token == 0xFE))
     {
-        // "baduino" in hex from offset 4
+        header v_header; // Inicijaliziraj header
+        memcpy(&v_header, &frame_buffer, sizeof(header));
+
+        uart_putstr("Looping: ");
+        uart_putint(v_header.h_loop);
+        uart_putstr("\nResolution: ");
+        uart_putint(v_header.h_width);
+        uart_putchar('x');
+        uart_putint(v_header.h_height * 8);
+        uart_putstr("\nFrames: ");
+        uart_putint(v_header.h_frames);
+        uart_putstr("\n\n");
+
+        uint8_t header_text[] = {0x62, 0x61, 0x64, 0x75, 0x69, 0x6E, 0x6F}; // "baduino"
+
+        // Invalid header string
         for (int i = 0; i < 7; i++)
         {
-
-            if (frame_buffer[i + 4] != header_text[i])
+            if (v_header.h_header_text[i] != header_text[i])
             {
-                //uart_putstr("Invalid file format\n");
-                fail_state = 3;
+                videoInfo->v_fail_state = 3;
                 return;
             }
         }
 
-        // 0xF00D on the last 2 bytes for shits and giggles
-        if (frame_buffer[510] != 0xF0 || frame_buffer[511] != 0x0D)
+        // Invalid resolution
+        if (v_header.h_width != 128 || v_header.h_height != 8)
         {
-            //uart_putstr("Invalid file format\n");
-            fail_state = 3;
+            videoInfo->v_fail_state = 3;
             return;
         }
 
-        // first 4 bytes - width in pixels, height in pages, no. of frames (2 bytes)
-        data_ptr++;
-        if (frame_buffer[0] != 128 || frame_buffer[1] != 8)
-        {
-            //uart_putstr("Invalid resolution\n");
-            fail_state = 3;
-            return;
-        }
-        n_frames = 0 | (frame_buffer[2] << 8);
-        n_frames |= frame_buffer[3];
-        loop = frame_buffer[11];
-        uart_putstr("Looping: ");
-        uart_putint(loop);
-        uart_putstr("\nResolution: ");
-        uart_putint(frame_buffer[0]);
-        uart_putchar('x');
-        uart_putint(frame_buffer[1] * 8);
-        uart_putstr("\nFrames: ");
-        uart_putint(n_frames);
-        uart_putstr("\n\n");
+        videoInfo->v_height = v_header.h_height;
+        videoInfo->v_width = v_header.h_width;
+        videoInfo->v_loop = v_header.h_loop;
+        videoInfo->v_frames = v_header.h_frames;
     }
     else
     {
         //UART_puts("Error reading sector\n");
-        fail_state = 2;
+        videoInfo->v_fail_state = 2;
         return;
     }
 }
 
-void read_frames()
+void read_frames(playbackinfo *videoInfo)
 {
-    if (done)
+    if (videoInfo->v_done)
     {
         return;
     }
     clear_display();
     do
     {
         // SD v2 uses byte offset (za ovo sam propisao krv)
-        if (sd_type == SD2)
+        if (videoInfo->v_sd_type == SD2)
         {
             res[0] = SD_startMultiBlockRead(512);
         }
@@ -138,7 +167,7 @@ void read_frames()
         }
 
         // Reading block data directly into the frame buffer
-        for (int i = 0; i < n_frames; i++)
+        for (int i = 0; i < videoInfo->v_frames; i++)
         {
             //res[0] = SD_readMultipleBlocks(frame_buffer, &token);
             SD_readMultipleBlocks(frame_buffer, &token);
@@ -150,77 +179,64 @@ void read_frames()
             else
             {
                 UART_puts("Error multireading sector\n");
-                fail_state = 2;
+                videoInfo->v_fail_state = 2;
                 return;
             }
         }
 
         SD_stopMultiBlockRead();
-    } while (loop);
-}
-
-void check_sd()
-{
-    fail_state = 0;
-    if (SD_init() == SD_SUCCESS)
-    {
-        //uart_putstr("Success!\n");
-    }
-    else
-    {
-        //uart_putstr("No SD card\n");
-        fail_state = 1;
-        return;
-    }
+    } while (videoInfo->v_loop);
 }
 
 int main()
 {
-    fail_state = 0;
     sei();
 
     i2c_init(0x3C); // hex 3C je adresa OLED-a
     display_init();
     horizonal_mode();
-    clear_display();
-    send_command(0xaf);
+    clear_display();    // Nuliraj oled vram
+    send_command(0xaf); // Upali oled
     _delay_ms(50);
 
     uart_init();
     // initialize SPI
     SPI_init();
     _delay_ms(10);
 
+    playbackinfo videoInfo;
+    memset(&videoInfo, 0, sizeof(playbackinfo));
+
     // hotswap yaaaaay
     while (1)
     {
-        check_sd();
-        if (fail_state)
+        check_sd(&videoInfo);
+        if (videoInfo.v_fail_state)
         {
-            done = 0;
-            error_image();
+            videoInfo.v_done = 0;
+            error_image(videoInfo.v_fail_state);
             _delay_ms(100);
             continue;
         }
-        read_header();
+        read_header(&videoInfo);
 
-        if (fail_state)
+        if (videoInfo.v_fail_state)
         {
-            error_image();
+            error_image(videoInfo.v_fail_state);
             _delay_ms(100);
             continue;
         }
-        read_frames();
+        read_frames(&videoInfo);
 
-        if (fail_state)
+        if (videoInfo.v_fail_state)
         {
-            error_image();
+            error_image(videoInfo.v_fail_state);
             _delay_ms(2000);
             continue;
         }
         else
         {
-            done = 1;
+            videoInfo.v_done = 1;
         }
         _delay_ms(200);
     }

arduino/sd.c

@@ -215,7 +215,7 @@ uint8_t SD_sendOpCond()
     return res1;
 }
 
-uint8_t SD_init()
+uint8_t SD_init(uint8_t *sd_type)
 {
     uint8_t res[5], cmdAttempts = 0;
 
@@ -273,11 +273,11 @@ uint8_t SD_init()
 
     if (CCS_VAL(res[1]))
     {
-        sd_type = SDHC;
+        *sd_type = SDHC;
     }
     else
     {
-        sd_type = SD2;
+        *sd_type = SD2;
     }
 
     return SD_SUCCESS;

arduino/sd.h

@@ -126,8 +126,6 @@
 #define SD_MAX_READ_ATTEMPTS 1563
 #define SD_R1_NO_ERROR(X) X < 0x02
 
-extern volatile uint8_t sd_type;
-
 // SPI functions
 void SPI_init(void);
 uint8_t SPI_transfer(uint8_t data);
@@ -154,7 +152,7 @@ uint8_t SD_sendApp();
 
 uint8_t SD_sendOpCond();
 
-uint8_t SD_init();
+uint8_t SD_init(uint8_t *sd_type);
 
 uint8_t SD_readSingleBlock(uint32_t addr, uint8_t *buf, uint8_t *token);
 

tools/enc.py

@@ -65,19 +65,17 @@ def writeHeader(directory, filenames, outFileName, loopNum: int):
     getDimensions(f"{directory}/{filenames[0]}")
     writebuffer = [width, height // 8]  # 2
     for byte in writebuffer:
-        outFile.write(byte.to_bytes(1, byteorder='big'))
+        outFile.write(byte.to_bytes(1, byteorder='little'))
         byte_num += 1
-    outFile.write(len(filenames).to_bytes(2, 'big'))  # 2
+    outFile.write(len(filenames).to_bytes(2, 'little'))  # 2
     byte_num += 2
     header_str = str.encode("baduino")
     outFile.write(header_str)
     byte_num += len(header_str)
-    outFile.write(loopNum.to_bytes(1, 'big'))
+    outFile.write(loopNum.to_bytes(1, 'little'))
     byte_num += 1
-    for i in range(510 - byte_num):
-        outFile.write((0).to_bytes(1, 'big'))
-    outFile.write(0xF0.to_bytes(1, 'big'))
-    outFile.write(0x0D.to_bytes(1, 'big'))
+    for i in range(512 - byte_num):
+        outFile.write((0).to_bytes(1, 'little'))
 
     return
 
@@ -151,7 +149,7 @@ def processFrames(directory, filenames, outFileName):
 
     # Provjeravanje argumenata
     if len(argumenti) < 3:
-        print("Argumenti nisu dobri")
+        print("Argumenti nisu dobri\n ./enc.py <source directory> <output file name> [loop (1 ili 0, default 0)]")
         exit()
 
     if len(argumenti) < 4: