CubeFirmware major rewrite.

Removed buggy idle animations. Killed idle frames alltogether.

CubeFirmware/animations.c

 */
 
 // Prototypes for all animations
-void upWave(void);
-void downWave(void);
-void xWave1(void);
-void xWave2(void);
-void zWave1(void);
-void zWave2(void);
-void tinyCube(void);
-void smallCube(void);
-void bigCube(void);
-void fullCube(void);
-
+void upWave(uint8_t i);
+void downWave(uint8_t i);
+void xWave1(uint8_t i);
+void xWave2(uint8_t i);
+void zWave1(uint8_t i);
+void zWave2(uint8_t i);
 
 // Array of animation functions
-#define NUMOFANIMATIONS 10
-void (*animations[NUMOFANIMATIONS])(void) = { &upWave, &downWave,
-								&xWave1, &xWave2, &zWave1,
-								&zWave2, &tinyCube, &smallCube, &bigCube, &fullCube };
+#define NUMOFANIMATIONS 0
+void (*animations[NUMOFANIMATIONS])(void) = { };
 
 #define WAVELENGTH 2
 
 uint8_t numOfAnimations(void) {
-	return NUMOFANIMATIONS;
+	return NUMOFANIMATIONS + 24;
 }
 
 void executeAnimation(uint8_t id) {
-	if (id < NUMOFANIMATIONS) {
-		animations[id](); // Call animation
+	if (id < (6*4)) {
+		if (id < 4) {
+			upWave(id);
+		} else if (id < 8) {
+			downWave(id - 4);
+		} else if (id < 12) {
+			xWave1(id - 8);
+		} else if (id < 16) {
+			xWave2(id - 12);
+		} else if (id < 20) {
+			zWave1(id - 16);
+		} else {
+			zWave2(id - 20);
+		}
+	} else if ((id - (6*4)) < NUMOFANIMATIONS) {
+		animations[id - (6*4)](); // Call animation
 	}
 }
 
-void upWave(void) {
+void upWave(uint8_t i) {
 	uint8_t *buff;
 	int8_t x, y, z;
 
 	buff = buffNew();
 	// Up-wave
-	for(y = 0; y < 8; y++) {
+	for(y = (i * 2); y < ((i * 2) + 2); y++) {
 		for(x = 0; x < 8; x++) {
 			for(z = 0; z < 8; z++) {
 				buffSetPixel(buff, x, y, z);
 	free(buff);
 }
 
-void downWave(void) {
+void downWave(uint8_t i) {
 	uint8_t *buff;
 	int8_t x, y, z;
 
 	buff = buffNew();
 	// Down-wave (Frames 9-15 of showoff.cube)
-	for(y = 7; y >= 0; y--) {
+	for(y = (7 - (2 * i)); y >= ((7 - (2 * i)) - 1); y--) {
 		for(x = 0; x < 8; x++) {
 			for(z = 0; z < 8; z++) {
 				buffSetPixel(buff, x, y, z);
 	free(buff);
 }
 
-void xWave1(void) {
+void xWave1(uint8_t i) {
 	uint8_t *buff;
 	int8_t x, y, z;
 
 	buff = buffNew();
 	// x-axis wave
-	for(x = 0; x < 8; x++) {
+	for(x = (i * 2); x < ((i * 2) + 2); x++) {
 		for(y = 0; y < 8; y++) {
 			for(z = 0; z < 8; z++) {
 				buffSetPixel(buff, x, y, z);
 	free(buff);
 }
 
-void xWave2(void) {
+void xWave2(uint8_t i) {
 	uint8_t *buff;
 	int8_t x, y, z;
 
 	buff = buffNew();
-	for(x = 7; x >= 0; x--) {
+	for(x = (7 - (2 * i)); x >= ((7 - (2 * i)) - 1); x--) {
 		for(y = 0; y < 8; y++) {
 			for(z = 0; z < 8; z++) {
 				buffSetPixel(buff, x, y, z);
 	free(buff);
 }
 
-void zWave1(void) {
+void zWave1(uint8_t i) {
 	uint8_t *buff;
 	int8_t x, y, z;
 
 	buff = buffNew();
 	// z-axis-wave
-	for(z = 0; z < 8; z++) {
+	for(z = (i * 2); z < ((i * 2) + 2); z++) {
 		for(y = 0; y < 8; y++) {
 			for(x = 0; x < 8; x++) {
 				buffSetPixel(buff, x, y, z);
 	free(buff);
 }
 
-void zWave2(void) {
+void zWave2(uint8_t i) {
 	uint8_t *buff;
 	int8_t x, y, z;
 
 	buff = buffNew();
-	for(z = 7; z >= 0; z--) {
+	for(z = (7 - (2 * i)); z >= ((7 - (2 * i)) - 1); z--) {
 		for(x = 0; x < 8; x++) {
 			for(y = 0; y < 8; y++) {
 				buffSetPixel(buff, x, y, z);
 	}
 	free(buff);
 }
-
-void tinyCube(void) {
-	uint8_t *buff;
-
-	buff = buffNew();
-
-	//Cube_1
-	buffSetPixel(buff, 3, 3, 3);
-	buffSetPixel(buff, 4, 3, 3);
-	buffSetPixel(buff, 4, 4, 3);
-	buffSetPixel(buff, 4, 4, 4);
-	setImage(buff);
-	while(isFinished() < WAVELENGTH) {
-		wdt_reset();	
-	}
-	buffClearAllPixels(buff);
-
-	free(buff);
-}
-
-void smallCube (void){
-	uint8_t *buff;
-	int8_t x, y, z;
-
-	buff = buffNew();
-
-	//Cube_2
-	for(x = 2; x < 6; x++) {
-		for(y = 2; y < 6; y++) {
-			buffSetPixel(buff, x, y, 2);
-			buffSetPixel(buff, x, y, 5);
-		}
-	}
-	for(y = 2; y < 6; y++) {
-		for(z = 2; z < 6; z++) {
-			buffSetPixel(buff, 2, y, z);
-			buffSetPixel(buff, 5, y, z);
-		}
-	}
-	for(x = 2; x < 6; x++) {
-		for(z = 2; z < 6; z++) {
-			buffSetPixel(buff, x, 2, z);
-			buffSetPixel(buff, x, 5, z);
-		}
-	}
-	setImage(buff);
-	while(isFinished() < WAVELENGTH) {
-		wdt_reset();	
-	}
-	buffClearAllPixels(buff);
-	free(buff);
-}
-
-void bigCube (void) {
-	uint8_t *buff;
-	int8_t x, y, z;
-
-	buff = buffNew();
-
-	//Cube_3
-	for(x = 1; x < 7; x++){
-		for(y = 1; y < 7; y++) {
-			buffSetPixel(buff, x, y, 1);
-			buffSetPixel(buff, x, y, 6);
-		}
-	}
-	for(y = 1; y < 7; y++){
-		for(z = 1; z < 7; z++) {
-			buffSetPixel(buff, 1, y, z);
-			buffSetPixel(buff, 6, y, z);
-		}
-	}
-	for(x = 1; x < 7; x++){
-		for(z = 1; z < 7; z++) {
-			buffSetPixel(buff, x, 1, z);
-			buffSetPixel(buff, x, 6, z);
-		}
-	}
-	setImage(buff);
-	while(isFinished() < WAVELENGTH) {
-		wdt_reset();	
-	}
-	buffClearAllPixels(buff);
-
-	free(buff);
-}
-
-void fullCube (void) {
-	uint8_t *buff;
-	int8_t x, y, z;
-
-	buff = buffNew();
-	
-	//Cube_4
-	for(x = 0; x < 8; x++){
-		for(y = 0; y < 8; y++) {
-			buffSetPixel(buff, x, y, 0);
-			buffSetPixel(buff, x, y, 7);
-		}
-	}
-	for(y = 0; y < 8; y++){
-		for(z = 0; z < 8; z++) {
-			buffSetPixel(buff, 0, y, z);
-			buffSetPixel(buff, 8, y, z);
-		}
-	}
-	for(x = 0; x < 8; x++){
-		for(z = 0; z < 8; z++) {
-			buffSetPixel(buff, x, 0, z);
-			buffSetPixel(buff, x, 8, z);
-		}
-	}
-	setImage(buff);
-	while(isFinished() < WAVELENGTH) {
-		wdt_reset();	
-	}
-	buffClearAllPixels(buff);
-
-	free(buff);
-}

CubeFirmware/builtInFrames.c

-/*
- * builtInFrames.c
- *
- * Copyright 2011 Thomas Buck <xythobuz@me.com>
- * Copyright 2011 Max Nuding <max.nuding@gmail.com>
- * Copyright 2011 Felix Bäder <baeder.felix@gmail.com>
- *
- * This file is part of LED-Cube.
- *
- * LED-Cube is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * LED-Cube is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with LED-Cube.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-// First image loaded after initializing cube code.
-// Only visible for a short period of time after every reset.
-uint8_t defaultImageCube[64] = {	0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-									0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xFF,
-									0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xFF,
-									0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xFF,
-									0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xFF,
-									0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xFF,
-									0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xFF,
-									0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
-
-// Idle animation. Displayed when no animations are stored in memory.
-uint8_t defaultImageA[64] = {	0xff, 0x01, 0x01, 0x01, 0xff, 0x80, 0x80, 0xff,
-								0xff, 0x01, 0x01, 0x01, 0xff, 0x80, 0x80, 0xff,
-								0xff, 0x01, 0x01, 0x01, 0xff, 0x80, 0x80, 0xff,
-								0xff, 0x01, 0x01, 0x01, 0xff, 0x80, 0x80, 0xff,
-								0xff, 0x01, 0x01, 0x01, 0xff, 0x80, 0x80, 0xff,
-								0xff, 0x01, 0x01, 0x01, 0xff, 0x80, 0x80, 0xff,
-								0xff, 0x01, 0x01, 0x01, 0xff, 0x80, 0x80, 0xff,
-								0xff, 0x01, 0x01, 0x01, 0xff, 0x80, 0x80, 0xff };
-
-uint8_t defaultImageB[64] = {	0x7e, 0x81, 0x81, 0x81, 0xff, 0x81, 0x81, 0x81,
-								0x7e, 0x81, 0x81, 0x81, 0xff, 0x81, 0x81, 0x81,
-								0x7e, 0x81, 0x81, 0x81, 0xff, 0x81, 0x81, 0x81,
-								0x7e, 0x81, 0x81, 0x81, 0xff, 0x81, 0x81, 0x81,
-								0x7e, 0x81, 0x81, 0x81, 0xff, 0x81, 0x81, 0x81,
-								0x7e, 0x81, 0x81, 0x81, 0xff, 0x81, 0x81, 0x81,
-								0x7e, 0x81, 0x81, 0x81, 0xff, 0x81, 0x81, 0x81,
-								0x7e, 0x81, 0x81, 0x81, 0xff, 0x81, 0x81, 0x81 };
-
-uint8_t defaultImageC[64] = {	0x1e, 0x42, 0x42, 0x42, 0x1e, 0x02, 0x02, 0x02,
-								0x1e, 0x42, 0x42, 0x42, 0x1e, 0x02, 0x02, 0x02,
-								0x1e, 0x42, 0x42, 0x42, 0x1e, 0x02, 0x02, 0x02,
-								0x1e, 0x42, 0x42, 0x42, 0x1e, 0x02, 0x02, 0x02,
-								0x1e, 0x42, 0x42, 0x42, 0x1e, 0x02, 0x02, 0x02,
-								0x1e, 0x42, 0x42, 0x42, 0x1e, 0x02, 0x02, 0x02,
-								0x1e, 0x42, 0x42, 0x42, 0x1e, 0x02, 0x02, 0x02,
-								0x1e, 0x42, 0x42, 0x42, 0x1e, 0x02, 0x02, 0x02 };
-
-#define IDLEANIMATIONCOUNT 3
-uint8_t *idleAnimation[IDLEANIMATIONCOUNT] = { defaultImageA, defaultImageB, defaultImageC };

CubeFirmware/header/transmit.h

 
 void recieveAnimations(void);
 void transmitAnimations(void);
-void sendAudioData(void);
+void sendAudioData(void);
+void printTime(void);

CubeFirmware/main.c

 #include "animations.h"
 #include "transmit.h"
 
+// Length of an idle animation frame, 24 -> 1 second
+#define IDLELENGTH 48
+
+void init(void);
+uint8_t audioModeSelected(void);
+uint8_t selfTest(void);
+void serialHandler(char c);
+
+uint8_t defaultImageCube[64] = {	0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81,
+									0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+									0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+									0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+									0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+									0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+									0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+									0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
 #define NOERROR 0
 // Audio does not answer
 #define AUDIOERROR 1
 // x = errorcode, e = error definition, not NOERROR
 #define ISERROR(x, e) ((x) & (e))
 
-// Length of an idle animation frame, 24 -> 1 second
-#define IDLELENGTH 48
-
-void serialHandler(char c);
-uint8_t audioModeSelected(void);
-void printErrors(uint8_t e);
-uint8_t selfTest(void);
-void printTime(void);
-
-// #include "snake.c"
-
 uint8_t shouldRestart = 0;
-uint8_t refreshAnimationCount = 1;
+uint8_t refreshAnimationCount = 0;
 uint8_t lastButtonState = 0;
-uint8_t maxButtonState = 0;
-char buffer[11];
-
-#include "builtInFrames.c"
+uint8_t maxButtonState = 1; // No audio, get's checked later
+uint8_t disableAudioData = 0;
+uint8_t disableMemory = 0;
+uint8_t disableAnim = 0;
 
-uint8_t DebugDone = 0; // Bit 0: 10s int. count, Bit 1: idle switch
-					   // Bit 2: state changed, disable idle
+char buffer[11];
 
 int main(void) {
-	uint8_t *audioData = NULL;
-	uint8_t *imageData = NULL;
-	uint8_t i, length = 0;
-	uint16_t count;
-	uint64_t lastChecked;
-	uint8_t idleCounter = 0;
+	/*
+		Quick Summary of the jobs main has to do:
+		- Initialize Cube
+		- Regularly check the buttonstate
+		- Check for incoming serial transmission and run serialHandler
+		- Check if animations are stored
+		--> If yes, display them
+		--> If no, display our idle animations
+	*/
+
+	uint8_t i;
+	uint8_t imageIndex = 0, imageCount = 0;
+	uint8_t idleIndex = 0, idleCount = 0;
+	uint8_t lastButtonCheck, fpsWasSent = 0;
 	uint32_t temp;
+	uint8_t *imageData = NULL, *audioData = NULL;
+	uint8_t duration = 0;
 
-	MCUCSR = 0;
+	// Initialization:
+	MCUCSR = 0; // Reset Watchdog
 	wdt_disable();
-
-	DDRA = 0xFF; // Latch Data Bus as Output
-	DDRD = 0xFC; DDRB = 24; // Mosfets as Output
-	DDRC = 0xFC; DDRB |= 6; // Latch Enable as Output
-	DDRB &= ~(1 << PB0); // Pushbutton as Input
-
-	initCube();
-	serialInit(25, 8, NONE, 1);
-	i2c_init();
-	initSystemTimer();
-	sei(); // Enable Interrupts
-
-	setImage(defaultImageCube); // Display something
-
+	init(); // Initialize all subsystems, set port directions, enable interrupts
 	wdt_enable(WDTO_1S); // Watchdog reset after 1 second
-
-	serialWriteString(getString(2)); // "Initialized: "
-
-	i = selfTest();
-	if (i) {
-		serialWriteString(getString(1)); // Selftest error
-		serialWriteString(itoa(i, buffer, 2));
-		serialWrite('\n');
-		printErrors(i);
-	}
-
-	serialWriteString(getString(0)); // Version
-
-	maxButtonState = numberOfVisualizations() + 1; // All visualizations and anim mode
-
-	audioModeSelected();
-	lastChecked = getSystemTime();
-
-	i = 0; // Image count
-	count = getAnimationCount();
-
-	while (1) {
-		// Reset if requested
-		if (!shouldRestart) {
+	i = selfTest(); // Run selftest, print errors
+	// Disable subsystems if they are unavailable
+	if (ISERROR(i, AUDIOERROR))
+		disableAudioData = 1;
+	if (ISERROR(i, MEMORYERROR) || ISERROR(i, MEMORYWRITEERROR))
+		disableMemory = 1;
+	serialWriteString(getString(0)); // Print Version
+
+	audioModeSelected(); // Initial button state check
+	lastButtonCheck = getSystemTime(); // Time we checked
+
+	if (disableMemory == 0)
+		imageCount = getAnimationCount(); // Retrieve image count from memory
+	idleCount = numOfAnimations();
+	if (disableAudioData == 0)
+		maxButtonState = numberOfVisualizations() + 1; // Number of toggle steps for button
+
+	while(1) { // Our Mainloop
+		if (!shouldRestart) { // A flag to trigger a watchdog reset
 			wdt_reset();
 		}
 
-		if(lastButtonState >= 1) {
-			// Get Audio Data and visualize it.
-			// Visualization id is in (lastButtonState - 1)
-			if (isFinished()) {
-				audioData = getAudioData(); // Not malloc'ed => Don't free
-				if (audioData != NULL) {
-					runVisualization(audioData, lastButtonState - 1);
-				}
-			}
-		} else {
-			if (refreshAnimationCount) {
-				// Get animation count stored in FRAM via TWI, if needed
-				count = getAnimationCount();
-				refreshAnimationCount = 0;
-				i = 0;
-			}
+		if (refreshAnimationCount) {
+			refreshAnimationCount = 0;
+			if (disableMemory == 0)
+				imageCount = getAnimationCount();
+		}
 
-			if (count > 0) { // We have frames stored
-				if (isFinished() > length) {
-					// Load next image
-					if (i < (count - 1)) {
-						i++;
-					} else {
-						i = 0;
-					}
+		if (serialHasChar()) { // Run serialHandler
+			serialHandler((char)(serialGet()));
+		}
 
-					imageData = getFrame(i);
-					length = imageData[64];
-					setImage(imageData);
-					free(imageData);
-				}
-			} else { // No frames available
-				if (!(DebugDone & 4)) { // Idle animation allowed
-					if (DebugDone & 2) {
-						if (idleCounter < numOfAnimations()) {
-							executeAnimation(idleCounter++);
+		if ((getSystemTime() - lastButtonCheck) > 150) { // Check button state every 150ms
+			audioModeSelected();
+			lastButtonCheck = getSystemTime();
+		}
+
+		if (lastButtonState == 0) {
+			// Display animations, stored or built-in
+			if (disableAnim == 0) {
+				if ((imageCount > 0) && (disableMemory == 0)) {
+					// Memory frames
+					if (isFinished() > duration) {
+						// Last frame was displayed long enough
+						imageIndex = (imageIndex < (imageCount - 1)) ? (imageIndex + 1) : 0;
+						imageData = getFrame(i);
+						if (imageData == NULL) {
+							duration = 24;
+							setImage(defaultImageCube);
 						} else {
-							idleCounter = 0;
-							DebugDone &= ~(2); // Show frames again
-						}
-					} else {
-						// Show idle frames
-						if (isFinished() >= IDLELENGTH) {
-							setImage(idleAnimation[idleCounter]);
-							if (idleCounter < IDLEANIMATIONCOUNT) {
-								idleCounter++;
-							} else {
-								idleCounter = 0;
-								DebugDone |= 2; // Show animation
-							}
+							duration = imageData[64];
+							setImage(imageData);
+							free(imageData);
 						}
 					}
+				} else {
+					// Built-In Frames
+					if (isFinished()) {
+						idleIndex = (idleIndex < (idleCount - 1)) ? (idleIndex + 1) : 0;
+						executeAnimation(idleIndex);
+					}
 				}
 			}
-		}
+		} else {
+			// An audiomode is selected
 
-		if (serialHasChar()) {
-			serialHandler((char)(serialGet()));
 		}
 
 		// Print fps after one second
-		if ((getSystemTime() >= 1000) && ((DebugDone & 1) == 0)) {
+		if ((getSystemTime() >= 1000) && (fpsWasSent == 0)) {
 			temp = getTriggerCount();
 			serialWriteString(ltoa(temp, buffer, 10));
 			serialWriteString(getString(27));
 			serialWriteString(ltoa((temp / 8), buffer, 10));
 			serialWriteString(getString(28));
-			DebugDone |= 1;
+			fpsWasSent = 1;
 		}
 
-		if ((getSystemTime() - lastChecked) > 150) { // Check button state every 150ms
-			audioModeSelected();
-			lastChecked = getSystemTime();
-		} 
 	}
 
-	close();
+	close(); // This is of course unneccessary. We never reach this point.
 	return 0;
 }
 
+void init(void) {
+	DDRA = 0xFF; // Latch Data Bus as Output
+	DDRD = 0xFC; DDRB = 24; // Mosfets as Output
+	DDRC = 0xFC; DDRB |= 6; // Latch Enable as Output
+	DDRB &= ~(1 << PB0); // Pushbutton as Input
+
+	initCube();
+	serialInit(25, 8, NONE, 1);
+	i2c_init();
+	initSystemTimer();
+	sei(); // Enable Interrupts
+
+	setImage(defaultImageCube); // Display something
+}
+
 uint8_t audioModeSelected(void) {
 	// Pushbutton: PB0, Low active
 
 		result |= MEMORYWRITEERROR;
 	}
 
-	return result;
-}
-
-void printErrors(uint8_t e) {
-	if (ISERROR(e, AUDIOERROR)) {
-		serialWriteString(getString(3));
-	}
-	if (ISERROR(e, MEMORYERROR)) {
-		serialWriteString(getString(4));
-	}
-	if (ISERROR(e, MEMORYWRITEERROR)) {
-		serialWriteString(getString(5));
+	if (result) { // Error in Selftest
+		serialWriteString(getString(1));
+		serialWriteString(itoa(result, buffer, 2));
+		serialWrite('\n');
+		if (ISERROR(result, AUDIOERROR)) {
+			serialWriteString(getString(3));
+		}
+		if (ISERROR(result, MEMORYERROR)) {
+			serialWriteString(getString(4));
+		}
+		if (ISERROR(result, MEMORYWRITEERROR)) {
+			serialWriteString(getString(5));
+		}
 	}
+
+	return result;
 }
 
 void randomAnimation(void) {
 		b[x] = 0;
 	}
 	while(1) {
+		wdt_reset();
 		setImage(b);
 		while(isFinished() == 0);
 		x = rand() / 4096;
 		if (serialHasChar()) {
 			serialWriteString(getString(25));
 			free(b);
-			serialHandler(serialGet());
+			serialGet();
 			return;
 		}
 	}
 		break;
 
 	case 'd': case 'D':
-		clearMem();
+		// clearMem(); // Much too invasive
+		setAnimationCount(0);
 		serialWrite(OK);
+		refreshAnimationCount = 1;
 		break;
 
 	case 'g': case 'G':
 		break;
 
 	case 'e': case 'E':
-		c = selfTest();
-		serialWriteString(getString(19));
-		serialWriteString(itoa(c, buffer, 2));
-		serialWrite('\n');
-		printErrors(c);
+		selfTest();
 		break;
 
 	case 'n': case 'N':
 
 	case '0':
 		fillBuffer(0);
-		DebugDone |= 4;
+		disableAnim = 1;
 		break;
 
 	case '1':
 		fillBuffer(0xFF);
-		DebugDone |= 4;
+		disableAnim = 1;
 		break;
 
 	case '3':
 		setImage(defaultImageCube);
-		DebugDone |= 4;
+		disableAnim = 1;
 		break;
 
 	case '2':
-		DebugDone |= 4;
 		fillBuffer(0);
-		for (i = 0; i < 64; i++) {
-			defaultImageA[i] = 0;
-		}
 		while(1) {
 			for (i = 0; i < 8; i++) {
 				for (y = 0; y < 8; y++) {
-					defaultImageA[y + (i * 8)] = 0;
+					defaultImageCube[y + (i * 8)] = 0;
 					for (z = 0; z < 8; z++) {
-						defaultImageA[y + (i * 8)] |= (1 << z);
-						setImage(defaultImageA);
+						defaultImageCube[y + (i * 8)] |= (1 << z);
+						setImage(defaultImageCube);
 						while (isFinished() == 0) {
 							wdt_reset();
 							if (serialHasChar()) {
 							}
 						}
 					}
-					defaultImageA[y + (i * 8)] = 0;
+					// defaultImageCube[y + (i * 8)] = 0;
 				}
 			}
 		}
 		break;
 killMeForIt:
-		serialGet();
+		serialGet(); // Killed because we got a serial char. Remove it from buffer.
 		serialWriteString(getString(25));
 		break;
 
 	}
 	// c was used as temp var and does not contain the char anymore...!
 }
-
-void printTime(void) {
-	serialWriteString(getString(14));
-	serialWriteString(ltoa(getSystemTime(), buffer, 10));
-	serialWriteString("ms");
-	if (getSystemTime() > 60000) {
-		serialWriteString(" (");
-		serialWriteString(itoa(getSystemTime() / 60000, buffer, 10));
-		serialWriteString(" min)");
-	}
-	if (getSystemTime() > 1000) {
-		serialWriteString(" (");
-		serialWriteString(itoa(getSystemTime() / 1000, buffer, 10));
-		itoa(getSystemTime() % 1000, buffer, 10);
-		if (buffer[0] != '\0')
-			serialWrite('.');
-		if (buffer[2] == '\0') 
-			serialWrite('0');
-		if (buffer[1] == '\0')
-			serialWrite('0');
-		if (buffer[0] != '\0')
-			serialWriteString(buffer);
-		serialWriteString("s)\n");
-	} else {
-		serialWrite('\n');
-	}
-}

CubeFirmware/transmit.c

 	while (!serialHasChar()) { // Wait for answer
 		if ((getSystemTime() - timestamp) <= TRANSTIMEOUT) {
 			wdt_reset();
+		} else {
+			setAnimationCount(0);
+			return;
 		}
 	}
 	c = serialGet();
 		while (!serialHasChar()) { // Wait for answer
 			if ((getSystemTime() - timestamp) <= TRANSTIMEOUT) {
 				wdt_reset();
+			} else {
+				setAnimationCount(0);
+				return;
 			}
 		}
 		c = serialGet();
 			while (!serialHasChar()) { // Wait for answer
 				if ((getSystemTime() - timestamp) <= TRANSTIMEOUT) {
 					wdt_reset();
+				} else {
+					setAnimationCount(0);
+					return;
 				}
 			}
 			c = serialGet();
 				while (!serialHasChar()) { // Wait for answer
 					if ((getSystemTime() - timestamp) <= TRANSTIMEOUT) {
 						wdt_reset();
+					} else {
+						setAnimationCount(0);
+						return;
 					}
 				}
 				c = serialGet();
 	while (!serialHasChar()) { // Wait for answer
 		if ((getSystemTime() - timestamp) <= TRANSTIMEOUT) {
 			wdt_reset();
+		} else {
+			setAnimationCount(0);
+			return;
 		}
 	}
 	c = serialGet();
 	while (!serialHasChar()) { // Wait for answer
 		if ((getSystemTime() - timestamp) <= TRANSTIMEOUT) {
 			wdt_reset();
+		} else {
+			setAnimationCount(0);
+			return;
 		}
 	}
 	c = serialGet();
 	while (!serialHasChar()) { // Wait for answer
 		if ((getSystemTime() - timestamp) <= TRANSTIMEOUT) {
 			wdt_reset();
+		} else {
+			setAnimationCount(0);
+			return;
 		}
 	}
 	c = serialGet();
 	while (!serialHasChar()) { // Wait for answer
 		if ((getSystemTime() - timestamp) <= TRANSTIMEOUT) {
 			wdt_reset();
+		} else {
+			setAnimationCount(0);
+			return;
 		}
 	}
 	c = serialGet();
 			serialWrite('\n');
 		}
 	}
+}
+
+void printTime(void) {
+	serialWriteString(getString(14));
+	serialWriteString(ltoa(getSystemTime(), buffer, 10));
+	serialWriteString("ms");
+	if (getSystemTime() > 60000) {
+		serialWriteString(" (");
+		serialWriteString(itoa(getSystemTime() / 60000, buffer, 10));
+		serialWriteString(" min)");
+	}
+	if (getSystemTime() > 1000) {
+		serialWriteString(" (");
+		serialWriteString(itoa(getSystemTime() / 1000, buffer, 10));
+		itoa(getSystemTime() % 1000, buffer, 10);
+		if (buffer[0] != '\0')
+			serialWrite('.');
+		if (buffer[2] == '\0') 
+			serialWrite('0');
+		if (buffer[1] == '\0')
+			serialWrite('0');
+		if (buffer[0] != '\0')
+			serialWriteString(buffer);
+		serialWriteString("s)\n");
+	} else {
+		serialWrite('\n');
+	}
 }

UploadTest/main.c

 
 	readAck();
 
-	printf("\tSending anim count (1)...");
+	printf("\tSending anim count (%d)...", animationCount);
 	c = (char)animationCount;
 	if (serialWriteTry(&c, 1) != 0) {
 		printf(" Could not send it!\n");
 
 	readAck();
 
-	printf("\tSending frame count (2)...");
+	printf("\tSending frame count (%d)...", frameCount);
 	c = (char)frameCount;
 	if (serialWriteTry(&c, 1) != 0) {
 		printf(" Could not send it!\n");
 	readAck();
 
 	for (f = 0; f < frameCount; f++) {
-		printf("\tSending duration (3)...");
+		printf("\tSending duration (%d)...", duration);
 		c = (char)duration;
 		if (serialWriteTry(&c, 1) != 0) {
 			printf(" Could not send it!\n");