Can render text.

Font is not pretty, but works :)

CubeFirmware/buffhelp.c

 #include <serial.h>
 #include <strings.h>
 
-uint8_t *buffNew(void) {
+void buffClearAllPixels(uint8_t *buffer) {
 	uint8_t i;
-	uint8_t *tmp = (uint8_t *)malloc(64);
+	for(i = 0; i < 64; i++) {	
+		buffer[i] = 0;
+	}
+}
+
+uint8_t *buffNew(void) {
+	uint8_t *tmp = (uint8_t *)malloc(65);
 	if (tmp == NULL) {
 		serialWriteString(getString(24)); // Display warning, don't care for CubeControl
 		while(1); // Ran out of heap => Watchdog Reset
 	}
-	for (i = 0; i < 64; i++) {
-		// Clear pixels
-		tmp[i] = 0;
-	}
+	buffClearAllPixels(tmp);
+	tmp[64] = 1;
 	return tmp;
 }
 
 	buffer[(8 * (7 - z)) + (7 - y)] &= ~(1 << x);
 }
 
-void buffClearAllPixels(uint8_t *buffer) {
-	uint8_t i;
-	for(i = 0; i < 64; i++) {	
-		buffer[i] = 0;
-	}
-}
-
 void buffFree(uint8_t *buffer) {
 	free(buffer);
 }

CubeFirmware/cube.c

 	imgFlag = 0;
 	toggleFlag = 0;
 }
-
-void close(void) {
-	TIMSK &= ~(1 << OCIE1A); // Disable interrupt
-}

CubeFirmware/font.c

+/*
+ * font.c
+ *
+ * Copyright 2012 Thomas Buck <xythobuz@me.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/>.
+ */
+#include <stdint.h>
+#include <avr/io.h>
+#include <avr/pgmspace.h>
+
+uint8_t font[95][8];
+uint8_t fontBuff[8];
+
+uint8_t *getFont(char c) {
+	uint8_t i;
+	if (!((c >= 0x20) && (c <= 0x7E))) {
+		if ((c == '\r') || (c == '\n')) {
+			c = '!';
+		} else {
+			c = '?';
+		}
+	}
+	for (i = 0; i < 8; i++) {
+		fontBuff[i] = pgm_read_byte(&(font[(uint8_t)(c - 0x20)][i]));
+	}
+	return fontBuff;
+}
+
+
+// Source: http://www.mikrocontroller.net/topic/54860
+// Author: Benedikt K
+// This is a LCD Font originally for Codepage 850.
+// Because of size restraints, i cut everything but
+// the printable ascii range, 0x20 to 0x7E
+// Not really pretty on the cube, but enough for now.
+uint8_t font[95][8] PROGMEM = {
+	{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},	// 0x20
+	{0x0C,0x1E,0x1E,0x0C,0x0C,0x00,0x0C,0x00},	// 0x21
+	{0x36,0x36,0x36,0x00,0x00,0x00,0x00,0x00},	// 0x22
+	{0x36,0x36,0x7F,0x36,0x7F,0x36,0x36,0x00},	// 0x23
+	{0x0C,0x3E,0x03,0x1E,0x30,0x1F,0x0C,0x00},	// 0x24
+	{0x00,0x63,0x33,0x18,0x0C,0x66,0x63,0x00},	// 0x25
+	{0x1C,0x36,0x1C,0x6E,0x3B,0x33,0x6E,0x00},	// 0x26
+	{0x06,0x06,0x03,0x00,0x00,0x00,0x00,0x00},	// 0x27
+	{0x18,0x0C,0x06,0x06,0x06,0x0C,0x18,0x00},	// 0x28
+	{0x06,0x0C,0x18,0x18,0x18,0x0C,0x06,0x00},	// 0x29
+	{0x00,0x66,0x3C,0xFF,0x3C,0x66,0x00,0x00},	// 0x2A
+	{0x00,0x0C,0x0C,0x3F,0x0C,0x0C,0x00,0x00},	// 0x2B
+	{0x00,0x00,0x00,0x00,0x00,0x0E,0x0C,0x06},	// 0x2C
+	{0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x00},	// 0x2D
+	{0x00,0x00,0x00,0x00,0x00,0x0C,0x0C,0x00},	// 0x2E
+	{0x60,0x30,0x18,0x0C,0x06,0x03,0x01,0x00},	// 0x2F
+	{0x1E,0x33,0x3B,0x3F,0x37,0x33,0x1E,0x00},	// 0x30
+	{0x0C,0x0F,0x0C,0x0C,0x0C,0x0C,0x3F,0x00},	// 0x31
+	{0x1E,0x33,0x30,0x1C,0x06,0x33,0x3F,0x00},	// 0x32
+	{0x1E,0x33,0x30,0x1C,0x30,0x33,0x1E,0x00},	// 0x33
+	{0x38,0x3C,0x36,0x33,0x7F,0x30,0x30,0x00},	// 0x34
+	{0x3F,0x03,0x1F,0x30,0x30,0x33,0x1E,0x00},	// 0x35
+	{0x1C,0x06,0x03,0x1F,0x33,0x33,0x1E,0x00},	// 0x36
+	{0x3F,0x33,0x30,0x18,0x0C,0x06,0x06,0x00},	// 0x37
+	{0x1E,0x33,0x33,0x1E,0x33,0x33,0x1E,0x00},	// 0x38
+	{0x1E,0x33,0x33,0x3E,0x30,0x18,0x0E,0x00},	// 0x39
+	{0x00,0x00,0x0C,0x0C,0x00,0x0C,0x0C,0x00},	// 0x3A
+	{0x00,0x00,0x0C,0x0C,0x00,0x0E,0x0C,0x06},	// 0x3B
+	{0x18,0x0C,0x06,0x03,0x06,0x0C,0x18,0x00},	// 0x3C
+	{0x00,0x00,0x3F,0x00,0x3F,0x00,0x00,0x00},	// 0x3D
+	{0x06,0x0C,0x18,0x30,0x18,0x0C,0x06,0x00},	// 0x3E
+	{0x1E,0x33,0x30,0x18,0x0C,0x00,0x0C,0x00},	// 0x3F
+	{0x3E,0x63,0x7B,0x7B,0x7B,0x03,0x1E,0x00},	// 0x40
+	{0x0C,0x1E,0x33,0x33,0x3F,0x33,0x33,0x00},	// 0x41
+	{0x3F,0x66,0x66,0x3E,0x66,0x66,0x3F,0x00},	// 0x42
+	{0x3C,0x66,0x03,0x03,0x03,0x66,0x3C,0x00},	// 0x43
+	{0x3F,0x36,0x66,0x66,0x66,0x36,0x3F,0x00},	// 0x44
+	{0x7F,0x46,0x16,0x1E,0x16,0x46,0x7F,0x00},	// 0x45
+	{0x7F,0x46,0x16,0x1E,0x16,0x06,0x0F,0x00},	// 0x46
+	{0x3C,0x66,0x03,0x03,0x73,0x66,0x7C,0x00},	// 0x47
+	{0x33,0x33,0x33,0x3F,0x33,0x33,0x33,0x00},	// 0x48
+	{0x1E,0x0C,0x0C,0x0C,0x0C,0x0C,0x1E,0x00},	// 0x49
+	{0x78,0x30,0x30,0x30,0x33,0x33,0x1E,0x00},	// 0x4A
+	{0x67,0x66,0x36,0x1E,0x36,0x66,0x67,0x00},	// 0x4B
+	{0x0F,0x06,0x06,0x06,0x46,0x66,0x7F,0x00},	// 0x4C
+	{0x63,0x77,0x7F,0x6B,0x63,0x63,0x63,0x00},	// 0x4D
+	{0x63,0x67,0x6F,0x7B,0x73,0x63,0x63,0x00},	// 0x4E
+	{0x1C,0x36,0x63,0x63,0x63,0x36,0x1C,0x00},	// 0x4F
+	{0x3F,0x66,0x66,0x3E,0x06,0x06,0x0F,0x00},	// 0x50
+	{0x1E,0x33,0x33,0x33,0x3B,0x1E,0x38,0x00},	// 0x51
+	{0x3F,0x66,0x66,0x3E,0x1E,0x36,0x67,0x00},	// 0x52
+	{0x1E,0x33,0x07,0x1C,0x38,0x33,0x1E,0x00},	// 0x53
+	{0x3F,0x2D,0x0C,0x0C,0x0C,0x0C,0x1E,0x00},	// 0x54
+	{0x33,0x33,0x33,0x33,0x33,0x33,0x3F,0x00},	// 0x55
+	{0x33,0x33,0x33,0x33,0x33,0x1E,0x0C,0x00},	// 0x56
+	{0x63,0x63,0x63,0x6B,0x7F,0x77,0x63,0x00},	// 0x57
+	{0x63,0x63,0x36,0x1C,0x36,0x63,0x63,0x00},	// 0x58
+	{0x33,0x33,0x33,0x1E,0x0C,0x0C,0x1E,0x00},	// 0x59
+	{0x7F,0x33,0x19,0x0C,0x46,0x63,0x7F,0x00},	// 0x5A
+	{0x1E,0x06,0x06,0x06,0x06,0x06,0x1E,0x00},	// 0x5B
+	{0x03,0x06,0x0C,0x18,0x30,0x60,0x40,0x00},	// 0x5C
+	{0x1E,0x18,0x18,0x18,0x18,0x18,0x1E,0x00},	// 0x5D
+	{0x08,0x1C,0x36,0x63,0x00,0x00,0x00,0x00},	// 0x5E
+	{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF},	// 0x5F
+	{0x0C,0x0C,0x18,0x00,0x00,0x00,0x00,0x00},	// 0x60
+	{0x00,0x00,0x1E,0x30,0x3E,0x33,0x6E,0x00},	// 0x61
+	{0x07,0x06,0x3E,0x66,0x66,0x66,0x3D,0x00},	// 0x62
+	{0x00,0x00,0x1E,0x33,0x03,0x33,0x1E,0x00},	// 0x63
+	{0x38,0x30,0x30,0x3E,0x33,0x33,0x6E,0x00},	// 0x64
+	{0x00,0x00,0x1E,0x33,0x3F,0x03,0x1E,0x00},	// 0x65
+	{0x1C,0x36,0x06,0x0F,0x06,0x06,0x0F,0x00},	// 0x66
+	{0x00,0x00,0x6E,0x33,0x33,0x3E,0x30,0x1F},	// 0x67
+	{0x07,0x06,0x36,0x6E,0x66,0x66,0x67,0x00},	// 0x68
+	{0x0C,0x00,0x0E,0x0C,0x0C,0x0C,0x1E,0x00},	// 0x69
+	{0x18,0x00,0x1E,0x18,0x18,0x18,0x1B,0x0E},	// 0x6A
+	{0x07,0x06,0x66,0x36,0x1E,0x36,0x67,0x00},	// 0x6B
+	{0x0E,0x0C,0x0C,0x0C,0x0C,0x0C,0x1E,0x00},	// 0x6C
+	{0x00,0x00,0x37,0x7F,0x6B,0x63,0x63,0x00},	// 0x6D
+	{0x00,0x00,0x1F,0x33,0x33,0x33,0x33,0x00},	// 0x6E
+	{0x00,0x00,0x1E,0x33,0x33,0x33,0x1E,0x00},	// 0x6F
+	{0x00,0x00,0x3B,0x66,0x66,0x3E,0x06,0x0F},	// 0x70
+	{0x00,0x00,0x6E,0x33,0x33,0x3E,0x30,0x78},	// 0x71
+	{0x00,0x00,0x1B,0x36,0x36,0x06,0x0F,0x00},	// 0x72
+	{0x00,0x00,0x3E,0x03,0x1E,0x30,0x1F,0x00},	// 0x73
+	{0x08,0x0C,0x3E,0x0C,0x0C,0x2C,0x18,0x00},	// 0x74
+	{0x00,0x00,0x33,0x33,0x33,0x33,0x6E,0x00},	// 0x75
+	{0x00,0x00,0x33,0x33,0x33,0x1E,0x0C,0x00},	// 0x76
+	{0x00,0x00,0x63,0x63,0x6B,0x7F,0x36,0x00},	// 0x77
+	{0x00,0x00,0x63,0x36,0x1C,0x36,0x63,0x00},	// 0x78
+	{0x00,0x00,0x33,0x33,0x33,0x3E,0x30,0x1F},	// 0x79
+	{0x00,0x00,0x3F,0x19,0x0C,0x26,0x3F,0x00},	// 0x7A
+	{0x38,0x0C,0x0C,0x07,0x0C,0x0C,0x38,0x00},	// 0x7B
+	{0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00},	// 0x7C
+	{0x07,0x0C,0x0C,0x38,0x0C,0x0C,0x07,0x00},	// 0x7D
+	{0x6E,0x3B,0x00,0x00,0x00,0x00,0x00,0x00},	// 0x7E
+};

CubeFirmware/generator.c

+/*
+ * generator.c
+ *
+ * Copyright 2012 Thomas Buck <xythobuz@me.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/>.
+ */
+#include <avr/io.h>
+#include <util/delay.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include "memLayer.h"
+#include "font.h"
+#include "buffhelp.h"
+
+// Generate 8 frames, store them from index start.
+// data has 8 bytes --> 1 layer. This layer is moved from back to front.
+void generateMovingAnimation(uint8_t *data, uint8_t start, uint8_t duration) {
+	uint8_t i, j, d;
+	uint8_t *frame = (uint8_t *)malloc(65);
+	frame[64] = duration;
+
+	for (i = 0; i < 8; i++) {
+		d = 0;
+		for (j = 0; j < 64; j++) {
+			if ((j < (8 * (i + 1))) && (j >= (8 * i))) {
+				frame[j] = data[d++];
+			} else {
+				frame[j] = 0;
+			}
+		}
+		setFrame(i + start, frame);
+	}
+	free(frame);
+}
+
+void renderText(char *text, uint8_t start) {
+	uint8_t *buf;
+
+	while(text[0] != '\0') {
+		generateMovingAnimation(getFont(text[0]), start, 1);
+		start += 8;
+		text++;
+	}
+
+	buf = buffNew();
+	buf[64] = 10; // half second pause...
+	setFrame(start, buf);
+	free(buf);
+}

CubeFirmware/header/cube.h

 // Copies the data in img into its own buffer
 extern void setImage(uint8_t *img); // img[64]
 extern uint8_t isFinished(void);
-extern void close(void);
-
 extern void fillBuffer(uint8_t val);
-
 extern uint32_t getTriggerCount(void);

CubeFirmware/header/font.h

+/*
+ * font.h
+ *
+ * Copyright 2012 Thomas Buck <xythobuz@me.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/>.
+ */
+
+uint8_t *getFont(char c);

CubeFirmware/header/generator.h

+/*
+ * generator.h
+ *
+ * Copyright 2012 Thomas Buck <xythobuz@me.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/>.
+ */
+
+// Generate 8 frames, store them from index start.
+// data has 8 bytes --> 1 layer. This layer is moved from back to front.
+void generateMovingAnimation(uint8_t *data, uint8_t start, uint8_t duration);
+void renderText(char *text, uint8_t start);

CubeFirmware/header/transmit.h

  * along with LED-Cube.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#define LINEBUFFSIZE 81
+extern char buffer[LINEBUFFSIZE];
+
 void recieveAnimations(void);
 void transmitAnimations(void);
 void sendAudioData(void);
 uint8_t readNumber(uint8_t base);
 void writeNumber(uint8_t num, uint8_t base);
 uint8_t *readAFrame(void);
-void simpleAnimationInput(void);
+void simpleAnimationInput(void);
+void textRenderInput(void);

CubeFirmware/main.c

 #include "visualizer.h"
 #include "animations.h"
 #include "transmit.h"
+#include "font.h"
+#include "buffhelp.h"
 
 // Length of an idle animation frame, 24 -> 1 second
 #define IDLELENGTH 48
 uint8_t disableMemory = 0;
 uint8_t disableAnim = 0;
 
-char buffer[11];
-
 /* Not so powerful Debouncing Example
  * No Interrupt needed
  * Author: Peter Dannegger
 		maxButtonState = numberOfVisualizations() + 1; // Number of toggle steps for button
 		lastButtonState = 1;
 
+	serialWriteString(getString(2));
 
 	while(1) { // Our Mainloop
 		if (!shouldRestart) { // A flag to trigger a watchdog reset
 				lastButtonState = 0;
 			}
 		}
-
-		// Print fps after one second
-		/* if ((getSystemTime() >= 1000) && (fpsWasSent == 0)) {
-			temp = getTriggerCount();
-			serialWriteString(ltoa(temp, buffer, 10));
-			serialWriteString(getString(27));
-			serialWriteString(ltoa((temp / 8), buffer, 10));
-			serialWriteString(getString(28));
-			fpsWasSent = 1;
-		} */
-
 	}
 
-	close(); // This is of course unneccessary. We never reach this point.
-	return 0;
+	return 0; // We never reach this point, of course!
 }
 
 void init(void) {
 
 void serialHandler(char c) {
 	// Used letters:
-	// a, b, c, d, e, f, g, h, i, m, n, p, q, r, s, t, u, v, x, y, 0, 1, 2, 3, #
+	// a, b, c, d, e, f, g, h, i, m, n, o, p, q, r, s, t, u, v, w, x, y, 0, 1, 2, 3, #
 	uint8_t i, y, z;
 	uint8_t *tmp;
 
 		serialWriteString(getString(33)); // Done
 		break;
 
+	case 'w': case 'W':
+		serialWriteString(getString(42)); // Text:
+		textRenderInput();
+		break;
+
 	case 'x': case 'X':
 		// Get byte, store as animation count
 		serialWriteString(getString(16)); // "New animation count: "
 		disableAnim = 1;
 		break;
 
-	case '3':
-		setImage(defaultImageCube);
-		disableAnim = 1;
-		break;
-
 	case '2':
-		fillBuffer(0);
+		buffClearAllPixels(defaultImageCube);
 		while(1) {
 			for (i = 0; i < 8; i++) {
 				for (y = 0; y < 8; y++) {
 			}
 		}
 		break;
-killMeForIt:
+	killMeForIt:
 		serialGet(); // Killed because we got a serial char. Remove it from buffer.
 		serialWriteString(getString(25));
 		break;
 
+	case '3':
+		buffClearAllPixels(defaultImageCube);
+		y = 0;
+		while(1) {
+			tmp = getFont(y);
+			if (y < 255) {
+				y++;
+			} else {
+				y = 0;
+			}
+			for (i = 0; i < 8; i++) {
+				defaultImageCube[i] = tmp[i];
+			}
+			setImage(defaultImageCube);
+			while (isFinished() < 12) {
+				wdt_reset();
+				if (serialHasChar()) {
+					goto killMeForIt; // Yes, yes. But i already need it for '2'
+					// So why not do it again... Please, no raptors :)
+					// http://xkcd.com/292/
+				}
+			}
+		}
+		break;
+
 	case 'I': case 'i':
 		serialWriteString(ltoa(getTriggerCount(), buffer, 10));
 		serialWrite('\n');

CubeFirmware/makefile

 SRC += visualizer.c
 SRC += animations.c
 SRC += transmit.c
+SRC += generator.c
+SRC += font.c
 
 # List Assembler source files here.
 # Make them always end in a capital .S.  Files ending in a lowercase .s

CubeFirmware/strings.c

  * along with LED-Cube.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include <avr/pgmspace.h>
-
-char buffer[60];
+#include "transmit.h"
 
 const char stringVersion[] PROGMEM = "v2.5\n"; // 0
 const char stringSelfTestError[] PROGMEM = "Self-Test Error: 0b"; // 1
-const char stringInit[] PROGMEM = "Initialized: "; // 2
+const char stringInit[] PROGMEM = "Initialized!\n"; // 2
 const char stringAudioError[] PROGMEM = " => No answer from Audio!\n"; // 3
 const char stringMemError[] PROGMEM = " => No answer from Memory!\n"; // 4
 const char stringMemWriteError[] PROGMEM = " => Can't write to Memory!\n"; // 5
+
 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 a frame, sim(p)le anim\n"; // 8
 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 stringHelp8[] PROGMEM = "(3): All Surface LEDs on\n"; // 13
+const char stringHelp8[] PROGMEM = "(3): Font Test\n"; // 13
+
 const char stringTime[] PROGMEM = "System Time: "; // 14
 const char stringFrames[] PROGMEM = " Frames stored\n"; // 15
 const char stringByte[] PROGMEM = "New animation count: "; // 16
-const char stringWritten[] PROGMEM = "durati(o)n"; // 17
+
+const char stringWritten[] PROGMEM = "durati(o)n\n"; // 17
+
 const char stringCount[] PROGMEM = "Frame to change: "; // 18
 const char stringSelfTest[] PROGMEM = "Self-Test: 0b"; // 19
 const char stringKillCount[] PROGMEM = "Killed Animation Counter!\n"; // 20
 const char stringSnakeControl[] PROGMEM = "Controls: W A S D Q E, x to quit\n"; // 23
 const char stringNoMoreHeap[] PROGMEM = "Ran out of Heap!\n"; // 24
 const char stringKilledAnimation[] PROGMEM = "Animation aborted!\n"; // 25
+
 const char stringHelp9[] PROGMEM = "(i)nterrupt count, (r)andom, (q)reset\n"; // 26
+
 const char stringInterrupts[] PROGMEM = " Interrupts after 1000msec\n"; // 27
 const char stringFrames2[] PROGMEM = " Frames per Second\n"; // 28
 const char stringDeleted[] PROGMEM = "Memory deleted!\n"; // 29
 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 stringExtern[] PROGMEM = "(f)ormat memory, (w)rite text\n"; // 34
+
 const char stringJtag[] PROGMEM = "Duration: "; // 35
 const char stringPowerOn[] PROGMEM = "Start: "; // 36
 const char stringMinute[] PROGMEM = "8 Layerbytes...\n"; // 37
 const char stringCubeMode[] PROGMEM = "Ende: "; // 39
 const char stringModeChange[] PROGMEM = "Cube mode entered!\n"; // 40
 const char stringModeChange2[] PROGMEM = "Audio mode entered!\n"; // 41
+const char stringRenderText[] PROGMEM = "Text: "; // 42
 
 // Last index + 1
-#define STRINGNUM 42
+#define STRINGNUM 43
 
 PGM_P stringTable[STRINGNUM] PROGMEM = { stringVersion, stringSelfTestError, stringInit,
 								stringAudioError, stringMemError, stringMemWriteError,
 								stringHelp9, stringInterrupts, stringFrames2, stringDeleted,
 								stringReset, stringWatchdog, stringBrownout, stringNothing,
 								stringExtern, stringJtag, stringPowerOn, stringMinute, stringAudioMode,
-								stringCubeMode, stringModeChange, stringModeChange2 };
+								stringCubeMode, stringModeChange, stringModeChange2, stringRenderText };
 
 char stringNotFoundError[] PROGMEM = "String not found!\n";
 

CubeFirmware/transmit.c

 #include <stdint.h>
 #include <stdlib.h>
 #include <avr/wdt.h>
+#include <string.h>
 #include "memLayer.h"
 #include "serial.h"
 #include "time.h"
 #include "strings.h"
 #include "audio.h"
+#include "generator.h"
+
+#include "transmit.h"
 
 #define OK 0x42
 #define ERROR 0x23
 
 #define TIMEOUTPERFRAME 500
 
-// These are global variables from main.c
-extern char buffer[11];
+char buffer[LINEBUFFSIZE];
+
+extern uint8_t refreshAnimationCount;
 
 void recieveAnimations(void) {
 	uint8_t animCount, a, frameCount, f, i, c;
 				buffer[ptr] = '\0';
 				return (uint8_t *)buffer;
 			}
-			ptr++;
+			if (buffer[ptr] != '\r') {
+				// ignore carriage return (\r)
+				if (buffer[ptr] == 8) {
+					// handle backspace
+					ptr--;
+				} else {
+					ptr++;
+				}
+			}
 		}
-
 	}
 }
 
 }
 
 void simpleAnimationInput(void) {
-	uint8_t start, j, d;
-	int8_t i;
+	uint8_t start, i;
 	uint8_t data[8] = {0, 0, 0, 0, 0, 0, 0, 0};
-	uint8_t *frame = (uint8_t *)malloc(65);
-	frame[64] = 2;
-
+	
 	serialWriteString(getString(36));
 	start = readNumber(10);
 	serialWriteString(getString(37));
 		data[i] = readNumber(16);
 	}
 	serialWriteString(getString(38));
-	for (i = 0; i < 8; i++) {
-		d = 0;
-		for (j = 0; j < 64; j++) {
-			if ((j < (8 * (i + 1))) && (j >= (8 * i))) {
-				frame[j] = data[d++];
-			} else {
-				frame[j] = 0;
-			}
-		}
-		setFrame(i + start, frame);
-	}
+	generateMovingAnimation(data, start, 2);
+	serialWriteString(getString(33)); // Done
+}
+
+void textRenderInput(void) {
+	readLine();
+	renderText(buffer, 0);
+	setAnimationCount((strlen(buffer) * 8) + 1); // Theres an empty frame at the end.
+	refreshAnimationCount = 1;
 	serialWriteString(getString(33)); // Done
-	free(frame);
 }

CubeFirmware/visualizer.c

 	uint8_t *buff;
 
 	buff = buffNew();
-	buffClearAllPixels(buff);
 
 	// setRow(0, 0, maxVal(average(data), 1), buff); // Show average
 	simpleVUMeter(data, buff, 7, 1, 0);
 	uint8_t *buff;
 	buff = buffNew();
 
-	buffClearAllPixels(buff);
-
 	// setRow(0, 0, maxVal(average(data), 0), buff); // Show average
 	simpleVUMeter(data, buff, 7, 0, 0);
 
 	uint8_t i;
 	buff = buffNew();
 
-	buffClearAllPixels(buff);
-
 	for (i = 2; i < 6; i++) {
 		simpleVUMeter(data, buff, i, 0, 1);
 	}
 	uint8_t *buff;
 	buff = buffNew();
 
-	buffClearAllPixels(buff);
-
 	simpleVUMeter(data, buff, 2, 1, 0);
 	filterData(data, 0);
 	simpleVUMeter(data, buff, 5, 0, 0);
 	uint8_t i;
 	buff = buffNew();
 
-	buffClearAllPixels(buff);
-
 	for (i = 0; i < 8; i++) {
 		simpleVUMeter(data, buff, i, 1, 0);
 	}
 	uint8_t i;
 	buff = buffNew();
 
-	buffClearAllPixels(buff);
-
 	for (i = 0; i < 8; i++) {
 		simpleVUMeter(data, buff, i, 0, 0);
 	}
 
 void horribleWave(uint8_t *audioData) {
 	uint8_t *imageData = buffNew();
-	
-	buffClearAllPixels(imageData);
 
 	// Could not figure out a way to represent this easily in a loop
 	// without using a shitload of 'if's...