CubeFirmware debug mode improvements.

Now talks to FRAM most of the time…

AudioFirmware/eq.c

@@ -82,7 +82,6 @@ uint8_t *equalizerGet(void) {
 		_delay_us(STROBEDELAY);
 	}
 
-	eqLed(result);
 	return result;
 }
 

AudioFirmware/main.c

@@ -73,7 +73,7 @@ int main(void) {
 			PORTB ^= (1 << PB2); // Toggle for every transaction
 			twiSetDataToSend(music);
 		}
-		eqLed(music);
+		// eqLed(music);
 		free(music);
 
 		// Heartbeat

CubeFirmware/audio.c

@@ -26,13 +26,22 @@
 
 #include "twi.h"
 #include "audio.h"
+#ifdef DEBUG
+#include "serial.h"
+#endif
 
 // free returned memory!
 uint8_t *getAudioData(void) {
 	// We read 7 bytes from our Audio µC
 	uint8_t i;
 	uint8_t *ret = (uint8_t *)malloc(7);
-
+	if (ret == NULL) {
+		// Ran out of memory...
+#ifdef DEBUG
+		serialWriteString("getAudioData: No memory!\n");
+#endif
+		return NULL;
+	}
 	if (i2c_start(TWIADDRESSAUDIO | I2C_READ) == 0) {
 		for (i = 0; i < 6; i++) {
 			ret[i] = i2c_readAck();
@@ -41,6 +50,7 @@ uint8_t *getAudioData(void) {
 		i2c_stop();
 		return ret;
 	} else {
+		free(ret);
 		return NULL;
 	}
 }

CubeFirmware/cube.c

@@ -26,7 +26,9 @@
 #include <stdlib.h>
 #include <util/atomic.h>
 
- #include "serial.h"
+#ifdef DEBUG
+#include "serial.h"
+#endif
 #include "cube.h"
 
 #ifndef F_CPU
@@ -87,10 +89,22 @@ void initCube(void) {
 	// We just assume this works, because after reset,
 	// enough Memory should be available...
 	imgBuffer = malloc(8 * sizeof(uint8_t*));
+	if (imgBuffer == NULL) {
+#ifdef DEBUG
+		serialWriteString("initCube: No memory!\nHalting!");
+#endif
+		while(1);
+	}
 
 	for(ctr = 0; ctr < 8; ctr++) {
 		// Same reasoning here...
 		imgBuffer[ctr] = malloc(8 * sizeof(uint8_t));
+		if (imgBuffer[ctr] == NULL) {
+#ifdef DEBUG
+			serialWriteString("initCube: No memory!\nHalting!");
+#endif
+			while(1);
+		}
 	}
 }
 

CubeFirmware/main.c

@@ -28,7 +28,11 @@
 #define OK 0x42
 #define ERROR 0x23
 
-#define VERSION "8^3 LED-Cube v1\n"
+#ifdef DEBUG
+#define VERSION "v2 (Debug Build)\nNOT COMPATIBLE WITH CubeControl!\n"
+#else
+#define VERSION "v2\n"
+#endif
 
 #include <avr/io.h>
 #include <util/delay.h>
@@ -41,9 +45,22 @@
 #include "cube.h"
 #include "time.h"
 #include "audio.h"
+#include "mem.h"
 #include "memLayer.h"
 #include "twi.h"
 
+#define NOERROR 0
+// Audio does not answer
+#define AUDIOERROR 1
+// Memory does not answer
+#define MEMORYERROR 2
+// Memory not writeable
+#define MEMORYWRITEERROR 4
+
+// x = errorcode, e = error definition, not NOERROR
+#define ISERROR(x, e) ((x) & (e))
+
+uint8_t selfTest(void);
 void serialHandler(char c);
 void sendAudioData(void);
 void recieveAnimations(void);
@@ -53,6 +70,9 @@ 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
 
 uint8_t refreshAnimationCount = 1;
 uint8_t lastButtonState = 0;
@@ -76,6 +96,17 @@ int main(void) {
 	DDRC = 0xFF; // Latch Enable
 	DDRA = 0xFF; // Latch Data
 
+	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));
@@ -132,14 +163,66 @@ int main(void) {
 	return 0;
 }
 
+uint8_t selfTest(void) {
+	uint8_t result = NOERROR;
+	
+	uint8_t *data = getAudioData();
+	if (data == NULL) {
+		result |= AUDIOERROR;
+	} else {
+		free(data);
+	}
+
+	data = memGetBytes(0, 1);
+	if (data == NULL) {
+		result |= MEMORYERROR;
+	} else {
+		free(data);
+	}
+
+	setGeneralPurposeByte(0, 0x42);
+	if (getGeneralPurposeByte(0) != 0x42) {
+		result |= MEMORYWRITEERROR;
+	}
+
+	return result;
+}
+
+#ifdef DEBUG
+void printErrors(uint8_t e) {
+	if (ISERROR(e, AUDIOERROR)) {
+		serialWriteString(" => No answer from Audio!\n");
+	}
+	if (ISERROR(e, MEMORYERROR)) {
+		serialWriteString(" => No answer from Memory!\n");
+	}
+	if (ISERROR(e, MEMORYWRITEERROR)) {
+		serialWriteString(" => Can't write to Memory!\n");
+	}
+}
+#endif
+
 void serialHandler(char c) {
 	// Used letters:
 	// a, c, d, g, s, t, v, x
+#ifdef DEBUG
+	serialWrite(c);
+	serialWriteString(": ");
+#endif
+
 	switch(c) {
 	case OK:
 		serialWrite(OK);
 		break;
 
+	case 'h': case 'H':
+		serialWriteString("(d)elete, (g)et anims, (s)et anims, (v)ersion\n");
+#ifdef DEBUG
+		serialWriteString("(t)ime, (a)udio, (c)ount, (x)Custom count\n");
+		serialWriteString("(y)Set fixed animation count\n");
+#endif
+		break;
+
 	case 'd': case 'D':
 		clearMem();
 		serialWrite(OK);
@@ -157,6 +240,7 @@ void serialHandler(char c) {
 		serialWriteString(VERSION);
 		break;
 
+#ifdef DEBUG
 	case 't': case 'T':
 		serialWriteString("System Time: ");
 		serialWriteString(ltoa(getSystemTime(), buffer, 10));
@@ -190,42 +274,46 @@ void serialHandler(char c) {
 
 	case 'x': case 'X':
 		// Get byte, store as animation count
-		serialWriteString("Send a byte...");
+		serialWriteString("Send a byte... ");
 		while (!serialHasChar());
-		setAnimationCount(serialGet());
-		serialWriteString(" Byte written!\n");
+		c = serialGet();
+		setAnimationCount(c);
+		serialWriteString(itoa(c, buffer, 10));
+		serialWriteString(" written!\n");
 		break;
 
-	case '\n':
-		serialWriteString(VERSION);
-		serialWriteString("See xythobuz.org for more Infos!\n");
+	case 'y': case 'Y':
+		setAnimationCount(0x2201);
+		serialWriteString("Animation count now 8705!\n");
 		break;
+#endif
 
 	default:
 		serialWrite(ERROR);
 		break;
 	}
+	// c was used as temp var and does not contain the char anymore...!
 }
 
+#ifdef DEBUG
 void sendAudioData(void) {
 	uint8_t i;
 	uint8_t *audioData = getAudioData();
 	if (audioData == NULL) {
 		serialWriteString("Could not access device!\n");
-		return;
-	}
-
-	serialWriteString("Audio Data:\n");
-	for (i = 0; i < 7; i++) {
-		serialWrite(i + '0');
-		serialWriteString(": ");
-		itoa(audioData[i], buffer, 10);
-		serialWriteString(buffer);
-		serialWrite('\n');
+	} else {
+		serialWriteString("Audio Data:\n");
+		for (i = 0; i < 7; i++) {
+			serialWrite(i + '0');
+			serialWriteString(": ");
+			itoa(audioData[i], buffer, 10);
+			serialWriteString(buffer);
+			serialWrite('\n');
+		}
+		free(audioData);
 	}
-
-	free(audioData);
 }
+#endif
 
 void recieveAnimations() {
 	uint8_t animCount, a, frameCount, f, i;

CubeFirmware/makefile

@@ -19,6 +19,7 @@
 # To rebuild project do "make clean" then "make all".
 #
 
+CDEFS = -D DEBUG
 
 # MCU name
 MCU = atmega32
@@ -77,9 +78,6 @@ EXTRAINCDIRS =
 # gnu99 - c99 plus GCC extensions
 CSTANDARD = -std=gnu99
 
-# Place -D or -U options here
-CDEFS = -D DEBUG
-
 # Place -I options here
 CINCS =
 

CubeFirmware/mem.c

@@ -20,11 +20,15 @@
  * 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 <stdlib.h>
 #include <stdint.h>
 #include "twi.h"
 #include "mem.h"
+#ifdef DEBUG
+#include "serial.h"
+#endif
 
 // address is a number between (inclusive) zero and 131071
 uint8_t memGetByte(uint32_t address) {
@@ -60,6 +64,12 @@ uint8_t *memGetBytes(uint32_t address, uint8_t length) {
 	addA = memAddress & 0xFF00;
 	addB = memAddress & 0xFF;
 	ret = (uint8_t *)malloc(length); // Allocate memory for values read
+	if (ret == NULL) {
+#ifdef DEBUG
+		serialWriteString("memGetBytes: No memory!\n");
+#endif
+		return NULL;
+	}
 
 	if (i2c_start(memAddress | I2C_WRITE) == 0) {
 		i2c_write(addA);

CubeFirmware/memLayer.c

@@ -45,12 +45,29 @@ void clearMem() {
 }
 
 uint16_t getAnimationCount() {
-	uint16_t animationCount = memGetByte(0);
-	animationCount |= (memGetByte(1) << 8);
-	return animationCount;
+	uint8_t lsb = memGetByte(0);
+	uint8_t msb = memGetByte(1);
+	uint16_t animationCount = (uint16_t)lsb;
+	return (animationCount | (((uint16_t)(msb)) << 8));
 }
 
 void setAnimationCount(uint16_t c) {
-	memWriteByte(0, (uint8_t)(c & 0x00FF));
-	memWriteByte(0, (uint8_t)((c & 0xFF00) >> 8));
+	uint8_t lsb = (uint8_t)(c & 0x00FF);
+	uint8_t msb = (uint8_t)((c & 0xFF00) >> 8);
+	memWriteByte(0, lsb);
+	memWriteByte(1, msb);
+}
+
+void setGeneralPurposeByte(uint8_t address, uint8_t data) {
+	if (address < 30) {
+		memWriteByte(address + 2, data);
+	}
+}
+
+uint8_t getGeneralPurposeByte(uint8_t address) {
+	if (address < 30) {
+		return memGetByte(address + 2);
+	} else {
+		return 0;
+	}
 }

CubeFirmware/memLayer.h

@@ -23,12 +23,14 @@
 
 // Free after usage!
 uint8_t *getFrame(uint16_t frameNumber);
-
 // 65 bytes framedata, data and duration...
 void setFrame(uint16_t frameNumber, uint8_t *frameData);
 
 void clearMem(void);
 
 uint16_t getAnimationCount(void);
+void setAnimationCount(uint16_t c);
 
-void setAnimationCount(uint16_t c);
+// address 0 - 29
+void setGeneralPurposeByte(uint8_t address, uint8_t data);
+uint8_t getGeneralPurposeByte(uint8_t address);