Uploading animations with up to 4 frames works.

Larger animations get everything but the last 4 frames corrupted.

CubeFirmware/animations.c

 // Prototypes for all animations
 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);
 
 #define NUMOFANIMATIONS 0
 uint8_t (*animations[NUMOFANIMATIONS])(void) = { };
 
-#define WAVELENGTH 2
+#define WAVELENGTH 1
 
 uint8_t numOfAnimations(void) {
-	return NUMOFANIMATIONS + 24;
+	return NUMOFANIMATIONS + (4*4);
 }
 
 uint8_t executeAnimation(uint8_t id) {
-	if (id < (6*4)) {
+	if (id < (4*4)) {
 		if (id < 4) {
-			upWave(id);
+			zWave1(id);
 		} else if (id < 8) {
-			downWave(id - 4);
+			zWave2(id - 4);
 		} else if (id < 12) {
-			xWave1(id - 8);
+			upWave(id - 8);
 		} else if (id < 16) {
-			xWave2(id - 12);
-		} else if (id < 20) {
-			zWave1(id - 16);
-		} else {
-			zWave2(id - 20);
+			downWave(id - 12);
 		}
 		return 1;
-	} else if ((id - (6*4)) < NUMOFANIMATIONS) {
-		return animations[id - (6*4)](); // Call animation
+	} else if ((id - (4*4)) < NUMOFANIMATIONS) {
+		return animations[id - (4*4)](); // Call animation
 	}
 	return 1;
 }
 	free(buff);
 }
 
-void xWave1(uint8_t i) {
-	uint8_t *buff;
-	int8_t x, y, z;
-
-	buff = buffNew();
-	// x-axis wave
-	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);
-			}
-		}
-		setImage(buff);
-		while(isFinished() < WAVELENGTH) {
-			wdt_reset();
-		}
-		buffClearAllPixels(buff);
-	}
-	free(buff);
-}
-
-void xWave2(uint8_t i) {
-	uint8_t *buff;
-	int8_t x, y, z;
-
-	buff = buffNew();
-	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);
-			}
-		}
-		setImage(buff);
-		while(isFinished() < WAVELENGTH) {
-			wdt_reset();
-		}
-		buffClearAllPixels(buff);
-	}
-	free(buff);
-}
-
 void zWave1(uint8_t i) {
 	uint8_t *buff;
 	int8_t x, y, z;

CubeFirmware/cube.c

 #include <avr/interrupt.h>
 #include <stdlib.h>
 #include <util/atomic.h>
+#include <avr/pgmspace.h>
 
 #include "cube.h"
 
 volatile uint8_t layer = 0;
 volatile uint8_t toggleFlag = 0;
 
-inline void isrCall(void);
-
 volatile uint32_t timesTriggered = 0;
 volatile uint8_t warningDisplayed = 0;
 
-uint8_t lookUp[] = { 	0,  64,  128,  192,  16,  80,  144,  208,  32,  96,  160,
-					224,  48,  112,  176,  240,  4,  68,  132,  196,  20,
-					84,  148,  212,  36,  100,  164,  228,  52,  116,  180,
-					244,  8,  72,  136,  200,  24,  88,  152,  216,  40,
-					104,  168,  232,  56,  120,  184,  248,  12,  76,  140,
-					204,  28,  92,  156,  220,  44,  108,  172,  236,  60,
-					124,  188,  252,  1,  65,  129,  193,  17,  81,  145,
-					209,  33,  97,  161,  225,  49,  113,  177,  241,  5,
-					69,  133,  197,  21,  85,  149,  213,  37,  101,  165,
-					229,  53,  117,  181,  245,  9,  73,  137,  201,  25,
-					89,  153,  217,  41,  105,  169,  233,  57,  121,  185,
-					249,  13,  77,  141,  205,  29,  93,  157,  221,  45,
-					109,  173,  237,  61,  125,  189,  253,  2,  66,  130,
-					194,  18,  82,  146,  210,  34,  98,  162,  226,  50,
-					114,  178,  242,  6,  70,  134,  198,  22,  86,  150,
-					214,  38,  102,  166,  230,  54,  118,  182,  246,  10,
-					74,  138,  202,  26,  90,  154,  218,  42,  106,  170,
-					234,  58,  122,  186,  250,  14,  78,  142,  206,  30,
-					94,  158,  222,  46,  110,  174,  238,  62,  126,  190,
-					254,  3,  67,  131,  195,  19,  83,  147,  211,  35,
-					99,  163,  227,  51,  115,  179,  243,  7,  71,  135,
-					199,  23,  87,  151,  215,  39,  103,  167,  231,  55,
-					119,  183,  247,  11,  75,  139,  203,  27,  91,  155,
-					219,  43,  107,  171,  235,  59,  123,  187,  251,  15,
-					79,  143,  207,  31,  95,  159,  223,  47,  111,  175,
-					239,  63,  127,  191,  255 };
+// A fix for our mirrored 64pin cable.
+uint8_t lookUp[256] PROGMEM = { 	0,  64,  128,  192,  16,  80,  144,  208,  32,  96,  160,
+									224,  48,  112,  176,  240,  4,  68,  132,  196,  20,
+									84,  148,  212,  36,  100,  164,  228,  52,  116,  180,
+									244,  8,  72,  136,  200,  24,  88,  152,  216,  40,
+									104,  168,  232,  56,  120,  184,  248,  12,  76,  140,
+									204,  28,  92,  156,  220,  44,  108,  172,  236,  60,
+									124,  188,  252,  1,  65,  129,  193,  17,  81,  145,
+									209,  33,  97,  161,  225,  49,  113,  177,  241,  5,
+									69,  133,  197,  21,  85,  149,  213,  37,  101,  165,
+									229,  53,  117,  181,  245,  9,  73,  137,  201,  25,
+									89,  153,  217,  41,  105,  169,  233,  57,  121,  185,
+									249,  13,  77,  141,  205,  29,  93,  157,  221,  45,
+									109,  173,  237,  61,  125,  189,  253,  2,  66,  130,
+									194,  18,  82,  146,  210,  34,  98,  162,  226,  50,
+									114,  178,  242,  6,  70,  134,  198,  22,  86,  150,
+									214,  38,  102,  166,  230,  54,  118,  182,  246,  10,
+									74,  138,  202,  26,  90,  154,  218,  42,  106,  170,
+									234,  58,  122,  186,  250,  14,  78,  142,  206,  30,
+									94,  158,  222,  46,  110,  174,  238,  62,  126,  190,
+									254,  3,  67,  131,  195,  19,  83,  147,  211,  35,
+									99,  163,  227,  51,  115,  179,  243,  7,  71,  135,
+									199,  23,  87,  151,  215,  39,  103,  167,  231,  55,
+									119,  183,  247,  11,  75,  139,  203,  27,  91,  155,
+									219,  43,  107,  171,  235,  59,  123,  187,  251,  15,
+									79,  143,  207,  31,  95,  159,  223,  47,  111,  175,
+									239,  63,  127,  191,  255 };
 
 ISR(TIMER1_COMPA_vect) {
+	uint8_t latchCtr;
 	if (toggleFlag >= COUNT2) {
-		isrCall();
+
+		if (changedFlag != 0) {
+			// The picture changed. Restart!
+			layer = 0;
+			changedFlag = 0;
+		}
+
+		PORTD = 0;
+		PORTB &= ~(24); // Disable all Fets
+
+		for (latchCtr = 0; latchCtr < 8; latchCtr++) {
+			// Disable all latches
+			PORTC &= ~(0xFC); // 2 - 7
+			PORTB &= ~(6); // 0 & 1
+
+			PORTA = imgBuffer[layer][latchCtr]; // Put latch data
+
+			// Enable desired latch
+			if (latchCtr > 1) {
+				PORTC |= (1 << latchCtr);
+			} else {
+				PORTB |= (1 << (latchCtr + 1));
+			}
+		}
+
+		// Set FET
+		PORTD = (1 << layer); // PD2 to 7
+		PORTB = (PORTB & ~(24)) | (((1 << layer) << 3) & 24); // PB3 & 4
+		
+		// Select next layer
+		if (layer < 7) {
+			layer++;
+		} else {
+			layer = 0;
+			imgFlag++; // Finished
+		}
+
 		toggleFlag = 0;
 		timesTriggered++;
 	} else {
 	return timesTriggered;
 }
 
-uint8_t bitSwitch(uint8_t d) {
-	return lookUp[d];
-}
-
 void setImage(uint8_t *img) {
 	uint8_t i, j;
 	ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
 		toggleFlag = 0;
 		for (i = 0; i < 8; i++) {
 			for (j = 0; j < 8; j++) {
-				imgBuffer[j][7 - i] = ~(bitSwitch(img[j + (i * 8)]));
+				imgBuffer[j][7 - i] = ~(pgm_read_byte(&(lookUp[img[j + (i * 8)]])));
 			}
 		}
 	}
 void close(void) {
 	TIMSK &= ~(1 << OCIE1A); // Disable interrupt
 }
-
-// Data is sent to 8 Fet bits...
-inline void setFet(uint8_t data) {
-	PORTD = (data & ~(3)); // Doesn't interfere with serial communication...
-	PORTB = (PORTB & ~(24)) | ((data << 3) & 24);
-}
-
-// Give id of latch, 0 - 7
-inline void selectLatch(uint8_t latchNr) {
-	// Disable all latches
-	PORTC &= ~(0xFC); // 2 - 7
-	PORTB &= ~(6); // 0 & 1
-
-	// Enable desired latch
-	if (latchNr > 1) {
-		PORTC |= (1 << latchNr);
-	} else {
-		PORTB |= (1 << (latchNr + 1));
-	}
-}
-
-inline void setLatch(uint8_t latchNr, uint8_t data) {
-	selectLatch(latchNr); // Activate current latch
-	PORTA = data; // Put latch data
-	asm volatile("nop"::); // Wait for latch
-}
-
-inline void isrCall(void) {
-	uint8_t latchCtr = 0;
-
-	if (changedFlag != 0) {
-		// The picture changed. Restart!
-		layer = 0;
-		changedFlag = 0;
-	}
-	setFet(0);
-	for (; latchCtr < 8; latchCtr++) {
-		setLatch(latchCtr, imgBuffer[layer][latchCtr]); // Put out all the data
-	}
-	setFet(1 << layer);
-	
-	// Select next layer
-	if (layer < 7) {
-		layer++;
-	} else {
-		layer = 0;
-		imgFlag++; // Finished
-	}
-}

CubeFirmware/header/transmit.h

 void recieveAnimations(void);
 void transmitAnimations(void);
 void sendAudioData(void);
-void printTime(void);
+void printTime(void);
+void dumpFrame(uint8_t *f);

CubeFirmware/main.c

 					if (isFinished() > duration) {
 						// Last frame was displayed long enough
 						imageIndex = (imageIndex < (imageCount - 1)) ? (imageIndex + 1) : 0;
-						imageData = getFrame(i);
+						imageData = getFrame(imageIndex);
 						if (imageData == NULL) {
 							duration = 24;
 							setImage(defaultImageCube);
 						}
 					}
 				} else {
-					// Built-In Frames
+					// Built-In Anims
 					if (isFinished() > duration) {
 						idleIndex = (idleIndex < (idleCount - 1)) ? (idleIndex + 1) : 0;
 						duration = executeAnimation(idleIndex);
 
 void serialHandler(char c) {
 	// Used letters:
-	// a, b, c, d, e, g, i, n, q, r, s, t, v, x, y, 0, 1, 2, 3, #
+	// a, b, c, d, e, f, g, h, i, n, q, r, s, t, u, v, x, y, 0, 1, 2, 3, #
 	uint8_t i, y, z;
+	uint8_t *tmp;
 
 	switch(c) {
 	case OK:
 		serialWriteString(getString(8));
 		serialWriteString(getString(9));
 		serialWriteString(getString(10));
+		serialWriteString(getString(26));
+		serialWriteString(getString(34));
+
 		serialWriteString(getString(11));
 		serialWriteString(getString(12));
 		serialWriteString(getString(13));
-		serialWriteString(getString(26));
 		break;
 
 	case 'd': case 'D':
-		// clearMem(); // Much too invasive
 		setAnimationCount(0);
 		serialWrite(OK);
 		refreshAnimationCount = 1;
 		break;
 
+	case 'f': case 'F':
+		serialWriteString(getString(32));
+		clearMem();
+		serialWriteString(getString(33));
+		refreshAnimationCount = 1;
+		break;
+
 	case 'g': case 'G':
 		transmitAnimations();
 		break;
 
 	case 's': case 'S':
 		recieveAnimations();
+		refreshAnimationCount = 1;
 		break;
 
 	case 'v': case 'V':
 
 	case 'c': case 'C':
 		serialWriteString(itoa(getAnimationCount(), buffer, 10));
+		serialWriteString(" (");
+		serialWriteString(itoa(refreshAnimationCount, buffer, 10));
+		serialWriteString(")");
 		serialWriteString(getString(15));
 		break;
 
+	case 'u': case 'U':
+		serialWriteString(getString(31));
+		while(!serialHasChar()) {
+			wdt_reset();
+		}
+		i = serialGet() - '0';
+		serialWrite(i + '0');
+		serialWrite('\n');
+		tmp = getFrame(i);
+		dumpFrame(tmp);
+		free(tmp);
+		break;
+
 	case 'x': case 'X':
 		// Get byte, store as animation count
 		serialWriteString(getString(16));

CubeFirmware/memLayer.c

  #include <stdint.h>
  #include <avr/io.h>
  #include <stdlib.h>
+ #include <avr/wdt.h>
  #include "mem.h"
  #include "memLayer.h"
  #include "serial.h"
 	uint32_t i;
 	for (i = 0; i < MemLength; i++) {
 		memWriteByte(i, 0);
+		wdt_reset();
 	}
 }
 

CubeFirmware/strings.c

 const char stringHelp1[] PROGMEM = "(d)elete, (g)et anims, (s)et anims, (v)ersion\n"; // 6
 const char stringHelp2[] PROGMEM = "(t)ime, (a)udio, (c)ount, (x)Custom count\n"; // 7
 const char stringHelp3[] PROGMEM = "(y)Set fixed animation count\n"; // 8
-const char stringHelp4[] PROGMEM = "S(e)lf Test, (m)ode\n"; // 9
+const char stringHelp4[] PROGMEM = "S(e)lf Test, (m)ode, d(u)mp\n"; // 9
 const char stringHelp5[] PROGMEM = "Play S(n)ake\n"; // 10
 const char stringHelp6[] PROGMEM = "All LEDs Off/On (0/1)\n"; // 11
 const char stringHelp7[] PROGMEM = "(2): Test Anim. 1\n"; // 12
 const char stringFrames2[] PROGMEM = " Frames per Second\n"; // 28
 const char stringDeleted[] PROGMEM = "Memory deleted!\n"; // 29
 const char stringReset[] PROGMEM = "Reset in 500ms. Bye!\n"; // 30
-const char stringWatchdog[] PROGMEM = ""; // 31
-const char stringBrownout[] PROGMEM = ""; // 32
-const char stringNothing[] PROGMEM = ""; // 33
-const char stringExtern[] PROGMEM = ""; // 34
+const char stringWatchdog[] PROGMEM = "Enter frame to dump: "; // 31
+const char stringBrownout[] PROGMEM = "Formatting memory... "; // 32
+const char stringNothing[] PROGMEM = "Done!\n"; // 33
+const char stringExtern[] PROGMEM = "(f)ormat memory\n"; // 34
 const char stringJtag[] PROGMEM = ""; // 35
 const char stringPowerOn[] PROGMEM = ""; // 36
-const char stringMinute[] PROGMEM = "Yay! Another minute passed :)\n"; // 37
+const char stringMinute[] PROGMEM = ""; // 37
 const char stringAudioMode[] PROGMEM = ""; // 38
 const char stringCubeMode[] PROGMEM = ""; // 39
 const char stringModeChange[] PROGMEM = "Cube mode entered!\n"; // 40

CubeFirmware/transmit.c

 #define OK 0x42
 #define ERROR 0x23
 
-#define TRANSTIMEOUT 2500
+#define TIMEOUTPERFRAME 500
 
 // These are global variables from main.c
 extern char buffer[11];
-extern uint8_t refreshAnimationCount;
 
 void recieveAnimations(void) {
 	uint8_t animCount, a, frameCount, f, i, c;
 	uint16_t completeCount = 0;
 	uint8_t *frame = (uint8_t *)malloc(65);
 	uint64_t timestamp = getSystemTime();
+	uint64_t timeout = TIMEOUTPERFRAME;
 
 	serialWrite(OK); // We are ready...
 
 	while (!serialHasChar()) { // Wait for answer
-		if ((getSystemTime() - timestamp) <= TRANSTIMEOUT) {
+		if ((getSystemTime() - timestamp) <= timeout) {
 			wdt_reset();
 		} else {
 			setAnimationCount(0);
 
 	for (a = 0; a < animCount; a++) {
 		while (!serialHasChar()) { // Wait for answer
-			if ((getSystemTime() - timestamp) <= TRANSTIMEOUT) {
+			if ((getSystemTime() - timestamp) <= timeout) {
 				wdt_reset();
 			} else {
 				setAnimationCount(0);
 		serialWrite(OK);
 
 		for (f = 0; f < frameCount; f++) {
+			timeout += TIMEOUTPERFRAME;
 			while (!serialHasChar()) { // Wait for answer
-				if ((getSystemTime() - timestamp) <= TRANSTIMEOUT) {
+				if ((getSystemTime() - timestamp) <= timeout) {
 					wdt_reset();
 				} else {
 					setAnimationCount(0);
 
 			for (i = 0; i < 64; i++) {
 				while (!serialHasChar()) { // Wait for answer
-					if ((getSystemTime() - timestamp) <= TRANSTIMEOUT) {
+					if ((getSystemTime() - timestamp) <= timeout) {
 						wdt_reset();
 					} else {
 						setAnimationCount(0);
 	free(frame);
 
 	while (!serialHasChar()) { // Wait for answer
-		if ((getSystemTime() - timestamp) <= TRANSTIMEOUT) {
+		if ((getSystemTime() - timestamp) <= timeout) {
 			wdt_reset();
 		} else {
 			setAnimationCount(0);
 	}
 	c = serialGet();
 	while (!serialHasChar()) { // Wait for answer
-		if ((getSystemTime() - timestamp) <= TRANSTIMEOUT) {
+		if ((getSystemTime() - timestamp) <= timeout) {
 			wdt_reset();
 		} else {
 			setAnimationCount(0);
 	}
 	c = serialGet();
 	while (!serialHasChar()) { // Wait for answer
-		if ((getSystemTime() - timestamp) <= TRANSTIMEOUT) {
+		if ((getSystemTime() - timestamp) <= timeout) {
 			wdt_reset();
 		} else {
 			setAnimationCount(0);
 	}
 	c = serialGet();
 	while (!serialHasChar()) { // Wait for answer
-		if ((getSystemTime() - timestamp) <= TRANSTIMEOUT) {
+		if ((getSystemTime() - timestamp) <= timeout) {
 			wdt_reset();
 		} else {
 			setAnimationCount(0);
 	serialWrite(OK);
 
 	setAnimationCount(completeCount);
-	refreshAnimationCount = 1;
 }
 
 // TODO: Rewrite for new Serial API
 void transmitAnimations(void) {
-	// We store no animation information in here
-	// So we have to place all frames in one or more
-	// animations... We need 8 animations max...
-	uint8_t animationsToGo;
-	uint16_t framesToGo = getAnimationCount();
-	uint16_t character;
-	uint8_t a;
-	uint8_t f, fMax, i;
-	uint8_t *frame;
-
-	if ((framesToGo % 255) == 0) {
-		animationsToGo = framesToGo / 255;
-	} else {
-		animationsToGo = (framesToGo / 255) + 1;
-	}
-
-	serialWrite(OK);
-	serialWrite(animationsToGo);
-	while ((character = serialGet()) & 0xFF00); // Wait for answer
-	if ((character & 0x00FF) != OK) { // Error code recieved
-		return;
-	}
-
-	for (a = 0; a < animationsToGo; a++) {
-		if (framesToGo > 255) {
-			fMax = 255;
-		} else {
-			fMax = framesToGo;
-		}
-
-		serialWrite(fMax); // Number of Frames in current animation
-		while ((character = serialGet()) & 0xFF00); // Wait for answer
-		if ((character & 0x00FF) != OK) { // Error code recieved
-			return;
-		}
-
-		for (f = 0; f < fMax; f++) {
-			frame = getFrame(f + (255 * a));
-
-			serialWrite(frame[64]); // frame duration
-			while ((character = serialGet()) & 0xFF00); // Wait for answer
-			if ((character & 0x00FF) != OK) { // Error code recieved
-				free(frame);
-				return;
-			}
-
-			for (i = 0; i < 64; i++) {
-				serialWrite(frame[i]);
-			}
-			while ((character = serialGet()) & 0xFF00); // Wait for answer
-			if ((character & 0x00FF) != OK) { // Error code recieved
-				free(frame);
-				return;
-			}
-
-			free(frame);
-		}
-		framesToGo -= fMax;
-	}
-
-	serialWrite(OK);
-	serialWrite(OK);
-	serialWrite(OK);
-	serialWrite(OK);
-
-	while ((character = serialGet()) & 0xFF00); // Wait for answer
-	// Error code ignored...
+	serialWrite(ERROR);
 }
 
 void sendAudioData(void) {
 	} else {
 		serialWrite('\n');
 	}
-}
+}
+
+void dumpFrame(uint8_t *f) {
+	uint8_t zeile, spalte;
+	for (zeile = 0; zeile < 8; zeile++) {
+		serialWrite(zeile + '0');
+		serialWriteString(": ");
+		for (spalte = 0; spalte < 8; spalte++) {
+			itoa(f[(8 * zeile) + spalte], buffer, 16);
+			serialWriteString(buffer);
+			serialWrite(' ');
+		}
+		serialWrite('\n');
+	}
+	serialWriteString("Duration: ");
+	itoa(f[64], buffer, 10);
+	serialWriteString(buffer);
+	serialWrite('\n');
+}

UploadTest/main.c

 int serialReadTry(char *data, size_t length);
 int serialWriteTry(char *data, size_t length);
 void intHandler(int dummy);
+void transferFile(char *file);
 
 volatile int keepRunning = 1;
+FILE *fp = NULL;
 
 #define suicide intHandler(0)
 
 	char command = -1;
 
 	if (argc < 2) {
-		printf("Usage:\n%s /dev/port [-d 0xff]\n", argv[0]);
+		printf("Usage:\n%s /dev/port [-d 0xff] | [-f /file]\n", argv[0]);
 		return 0;
 	}
 
 		return 0;
 	}
 
-	if ((argc >= 4) && (strcmp(argv[2], "-d") == 0)) {
+	signal(SIGINT, intHandler);
+	signal(SIGQUIT, intHandler);
+
+	if ((argc == 4) && (strcmp(argv[2], "-d") == 0)) {
 		sscanf(argv[3], "%x", &data);
 		frameCount = 1;
 	}
 
+	if ((argc == 4) && (strcmp(argv[2], "-f") == 0)) {
+		printf("Trying to send from file.\n");
+		transferFile(argv[3]);
+	}
+
 	if (argc == 3) {
 		command = argv[2][0];
 	}
 
-	signal(SIGINT, intHandler);
-	signal(SIGQUIT, intHandler);
-
 	printf("Port opened. Sending test data:\n");
 
-	printf("\tSending command 's'...");
 	if (command != -1) {
 		c = command;
 	} else {
 		c = 's';
 	}
+	printf("\tSending command '%c'...", c);
 	if (serialWriteTry(&c, 1) != 0) {
 		printf(" Could not send it!\n");
 		suicide;
 	return 0;
 }
 
+void writeS(char c) {
+	if (serialWriteTry(&c, 1) != 0) {
+		printf("Error while sending!\n");
+		suicide;
+	}
+}
+
+int readFrame(char *frame) {
+	char lineBuffer[80];
+	char buff[3];
+	int lines, byte, i = 0, tmp;
+	buff[2] = '\0';
+
+	fgets(lineBuffer, 80, fp);// Frame name, ignore
+	for (lines = 0; lines < 8; lines++) {
+		fgets(lineBuffer, 80, fp);
+		for(byte = 0; byte < 8; byte++) {
+			buff[0] = lineBuffer[(2 * byte)];
+			buff[1] = lineBuffer[(2 * byte) + 1];
+			sscanf(buff, "%x", &tmp);
+			frame[i++] = (char)tmp;
+		}
+	}
+
+	fgets(lineBuffer, 80, fp);
+	if(lineBuffer[strlen(lineBuffer)-1] == '\n') {
+		lineBuffer[strlen(lineBuffer)-1] = '\0';
+	}
+	sscanf(lineBuffer, "%d", &lines);
+	return lines;
+}
+
+void transferFile(char *file) {
+	char lineBuffer[80];
+	int f, i;
+	int fMax = 0;
+	char frame[64];
+	int duration;
+
+	fp = fopen(file, "r");
+	if (fp != NULL) {
+		printf("File opened...\n");
+		fgets(lineBuffer, 80, fp);
+		if (lineBuffer[strlen(lineBuffer)-1] == '\n') {
+			lineBuffer[strlen(lineBuffer)-1] = '\0';
+		}
+		fMax = atoi(lineBuffer);
+		printf("Has %d frames.\n", fMax);
+		fgets(lineBuffer, 80, fp);
+		printf("Sendind command.\n");
+		writeS('s');
+		readAck();
+		printf("Sendind animation count.\n");
+		writeS(1); // Animation count
+		readAck();
+		printf("Sending frame count.\n");
+		writeS(fMax); // Frame count
+		readAck();
+		for (f = 0; f < fMax; f++) {
+			printf("Reading frame from file... ");
+			duration = readFrame(frame);
+			printf("Done!\nSending duration.\n");
+			writeS(duration);
+			readAck();
+			printf("Sending frame (");
+			for (i = 0; i < 64; i++) {
+				writeS(frame[i]);
+				printf("%x", frame[i]);
+				if (i < 63) {
+					printf(" ");
+				}
+			}
+			printf(") Done!\n");
+			readAck();
+			printf("Wrote frame %d\n\n", f);
+		}
+		printf("Sending end sequence!\n");
+		writeS(0x42);
+		writeS(0x42);
+		writeS(0x42);
+		writeS(0x42);
+		readAck();
+	} else {
+		printf("File not found\n");
+		suicide;
+	}
+	printf("Success!\n");
+	suicide;
+}
+
 void readAck() {
 	char c;
 	printf("Awaiting acknowledge...");
 
 void intHandler(int dummy) {
 	keepRunning = 0;
+	if (fp != NULL) {
+		fclose(fp);
+	}
 	serialClose();
 	exit(0);
 }