Consistent storage format.

No longer using one- and two-dimensional arrays combined.

CubeFirmware/cube.c

 inline void delay_ns(int16_t ns);
 inline void isrCall(void);
 
-void setImage(uint8_t **img) {
+void setImage(uint8_t *img) {
 	uint8_t i, j;
 	ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
 		changedFlag = 1;
 		imgFlag = 0;
 		for (i = 0; i < 8; i++) {
 			for (j = 0; j < 8; j++) {
-				imgBuffer[i][j] = img[i][j];
+				imgBuffer[i][j] = img[j + (i * 8)];
 			}
 		}
 	}

CubeFirmware/cube.h

 extern void initCube(void);
 
 // Copies the data in img into its own buffer, so free img afterwards...
-extern void setImage(uint8_t **img); // img[8][8]
+extern void setImage(uint8_t *img); // img[64]
 extern uint8_t isFinished(void);
 extern void close(void);
 

CubeFirmware/main.c

 #ifdef DEBUG
 #define VERSION "v2 (Debug Build)\nNOT COMPATIBLE WITH CubeControl!\n"
 #else
-#define VERSION "v2\n"
+#define VERSION "v2 Release\n"
 #endif
 
 #include <avr/io.h>
 #define MEMORYERROR 2
 // Memory not writeable
 #define MEMORYWRITEERROR 4
-
 // x = errorcode, e = error definition, not NOERROR
 #define ISERROR(x, e) ((x) & (e))
 
 void recieveAnimations(void);
 void transmitAnimations(void);
 uint8_t audioModeSelected(void);
-inline void setPixelBuffer(uint8_t x, uint8_t y, uint8_t z, uint8_t **buf);
-inline void clearPixelBuffer(uint8_t x, uint8_t y, uint8_t z, uint8_t **buf);
-void setRow(uint8_t x, uint8_t z, uint8_t height, uint8_t **buf);
-void visualizeAudioData(uint8_t *audioData, uint8_t **imageData);
+inline void setPixelBuffer(uint8_t x, uint8_t y, uint8_t z, uint8_t *buf);
+inline void clearPixelBuffer(uint8_t x, uint8_t y, uint8_t z, uint8_t *buf);
+void setRow(uint8_t x, uint8_t z, uint8_t height, uint8_t *buf);
+void visualizeAudioData(uint8_t *audioData, uint8_t *imageData);
 #ifdef DEBUG
 void printErrors(uint8_t e);
 #endif
 char buffer[11];
 
 int main(void) {
-	uint8_t *audioData;
-	uint8_t **imageData;
-	uint8_t i, lastMode;
+	uint8_t *audioData = NULL;
+	uint8_t *imageData = NULL;
+	uint8_t i, length = 0, lastMode;
 	uint16_t count;
 	uint64_t lastChecked;
 
 	DDRC = 0xFF; // Latch Enable
 	DDRA = 0xFF; // Latch Data
 
+#ifdef DEBUG
+	// Kill animation counter in debug mode
+	// => Don't preserve animations while power down
+	setAnimationCount(0);
+
 	i = selfTest();
 	if (i) {
-		// Something is not working
-#ifdef DEBUG
 		serialWriteString("Self-Test Error: 0b");
 		serialWriteString(itoa(i, buffer, 2));
 		serialWrite('\n');
 		printErrors(i);
-#endif
-	}
-
-	imageData = (uint8_t **)malloc(8 * sizeof(uint8_t *));
-	for (i = 0; i < 8; i++) {
-		imageData[i] = (uint8_t *)malloc(8 * sizeof(uint8_t));
 	}
+#endif
 
 #ifdef DEBUG
-	refreshAnimationCount = 0; // Don't talk to FRAM yet...
-
 	serialWriteString("\n\nInitialized: ");
 	serialWriteString(VERSION);
 	serialWriteString("Took ");
 	lastMode = audioModeSelected();
 	lastChecked = getSystemTime();
 
+	i = 0;
+	count = getAnimationCount();
 	while (1) {
-		//if(lastMode) {
+		if(lastMode) {
 			// Get Audio Data and visualize it
-			/* audioData = getAudioData();
-			if (audioData != NULL) {
-				visualizeAudioData(audioData, imageData);
-				setImage(imageData);
-				free(audioData);
-			}
-			while(!isFinished()); // Wait for it to display */
-		//} else {
-			// Look for commands, play from fram
-			// We have 128*1024 bytes
-			// A Frame needs 65 bytes (64 data + duration)
-			// We place 2016 Frames in mem => 131040
-			// That gives us 32 bytes at the beginning, 0 -> 31
-			// The first frame starts at 32
-			if (serialHasChar()) {
-				serialHandler((char)(serialGet()));
+			if (isFinished()) {
+				audioData = getAudioData();
+				if (audioData != NULL) {
+					visualizeAudioData(audioData, imageData);
+					setImage(imageData);
+					free(audioData);
+				}
 			}
-
-			/* if (refreshAnimationCount) {
+		} else {
+			if (refreshAnimationCount) {
 				// Get animation count stored in FRAM via TWI, if needed
 				count = getAnimationCount();
 				refreshAnimationCount = 0;
-			} */
-		//}
+				i = 0;
+			}
+
+			if (isFinished() > length) {
+				// Load next image
+				if (i < (count - 1)) {
+					i++;
+				} else {
+					i = 0;
+				}
+
+				imageData = getFrame(i);
+				length = imageData[64];
+				setImage(imageData);
+				free(imageData);
+			}
+		}
 
-		if ((getSystemTime() - lastChecked) > 100) {
+		if (serialHasChar()) {
+			serialHandler((char)(serialGet()));
+		}
+
+		if ((getSystemTime() - lastChecked) > 150) {
 			lastMode = audioModeSelected();
 			lastChecked = getSystemTime();
 		} 
 	return lastButtonState;
 }
 
-inline void setPixelBuffer(uint8_t x, uint8_t y, uint8_t z, uint8_t **buf) {
-	buf[z][y] |= (1 << x);
-}
-
-inline void clearPixelBuffer(uint8_t x, uint8_t y, uint8_t z, uint8_t **buf) {
-	buf[z][y] &= ~(1 << x);
+inline void setPixelBuffer(uint8_t x, uint8_t y, uint8_t z, uint8_t *buf) {
+	buf[(8 * z) + y] |= (1 << x);
 }
 
-void setBuffer(uint8_t d, uint8_t *buf, uint8_t length) {
-	uint8_t i;
-	for (i = 0; i < length; i++) {
-		buf[i] = d;
-	}
+inline void clearPixelBuffer(uint8_t x, uint8_t y, uint8_t z, uint8_t *buf) {
+	buf[(8 * z) + y] &= ~(1 << x);
 }
 
-void setRow(uint8_t x, uint8_t z, uint8_t height, uint8_t **buf) {
+void setRow(uint8_t x, uint8_t z, uint8_t height, uint8_t *buf) {
 	uint8_t i = 0;
 	for (; i < height; i++) {
 		setPixelBuffer(x, i, z, buf);
 	}
 }
 
-void visualizeAudioData(uint8_t *audioData, uint8_t **imageData) {
+void visualizeAudioData(uint8_t *audioData, uint8_t *imageData) {
 	uint8_t i;
-	for (i = 0; i < 8; i++) {
-		setBuffer(0, imageData[i], 8);
+	for (i = 0; i < 64; i++) {
+		imageData[i] = 0;
 	}
 
 	// 8 LEDs, Max Val 255:

CubeFirmware/memLayer.c

  #include "memLayer.h"
  #include "serial.h"
 
+// We have 128*1024 bytes
+// A Frame needs 65 bytes (64 data + duration)
+// We place 2016 Frames in mem => 131040
+// That gives us 32 bytes at the beginning, 0 -> 31
+// The first frame starts at 32
+
 // Free after usage!
 uint8_t *getFrame(uint16_t frameNumber) {
 	return memGetBytes(32 + (65 * frameNumber), 65);
 	uint8_t lsb = memGetByte(0);
 	uint8_t msb = memGetByte(1);
 	uint16_t animationCount = (uint16_t)lsb;
-	return (animationCount | (((uint16_t)(msb)) << 8));
+	animationCount |= (((uint16_t)(msb)) << 8);
+	if (animationCount <= 2016) {
+		return animationCount;
+	} else {
+		return 2016;
+	}
 }
 
 void setAnimationCount(uint16_t c) {