Worked at firmware.

Interrupt execution time does not change, strangely?

CubeFirmware/audio.c

 #include "serial.h"
 #endif
 
-// free returned memory!
+uint8_t ret[7]; // Buffer for data
+
+// don't free returned memory! It's static mem
 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();
 		i2c_stop();
 		return ret;
 	} else {
-		free(ret);
 		return NULL;
 	}
 }

CubeFirmware/audio.h

 
 #define TWIADDRESSAUDIO 0x42
 
-// free returned memory!
+// don't free returned memory! It's static mem
 uint8_t *getAudioData(void);

CubeFirmware/cube.c

 #endif
 
 // Should be 41666
-#define FIRSTCOUNT 1000
-// Time we wait for latch in ns, should be 63
-#define LATCHDELAY 63
+#define COUNT 41666
 
-volatile uint8_t **imgBuffer = NULL; // imgBuffer[8][8]
+/*
+ * We have:
+ * Fosc / prescaler / fps / interruptsPerFrame = interruptCount
+ * 16000000 / 1 / 24 / 8 = 83333 (round-a-bout)
+ * That means, 192 Interrupts per second, 1920 after 10 secs!
+ *
+ * Small Study: Interrupt count after 10 seconds
+ *
+ * |-------------------------------|
+ * |  COUNT   |  1   | 41666 |     |
+ * |----------|------|-------|-----|
+ * | intcount | 2451 | 2451  |     |
+ * |-------------------------------|
+ *
+ * Haha, what's up with that?
+ */
+
+volatile uint8_t imgBuffer[8][8];
 volatile uint8_t changedFlag = 0;
 volatile uint8_t imgFlag = 0;
 volatile uint8_t layer = 0;
 
-inline void delay_ns(int16_t ns);
 inline void isrCall(void);
 
+volatile uint32_t timesTriggered = 0;
+
+uint32_t getTriggerCount(void) {
+	return timesTriggered;
+}
+
 void setImage(uint8_t *img) {
 	uint8_t i, j;
 	ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
 }
 
 void initCube(void) {
-	uint8_t ctr = 0;
-
 	TCCR1A |= (1 << WGM12); // CTC Mode
 	TCCR1B |= (1 << CS10); // Prescaler: 1
-	OCR1A = FIRSTCOUNT;
+	OCR1A = COUNT;
 	TIMSK = (1 << OCIE1A); // Enable Output Compare Interrupt
-
-	// 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);
-		}
-	}
 }
 
 void close(void) {
-	uint8_t ctr = 0;
-	for (; ctr < 8; ctr++) {
-		free((uint8_t *)imgBuffer[ctr]);
-	}
-	free(imgBuffer);
 	TIMSK &= ~(1 << OCIE1A); // Disable interrupt
 }
 
-// Count to FIRSTCOUNT SECONDCOUNT times...
 ISR(TIMER1_COMPA_vect) {
 	isrCall();
+	timesTriggered++;
 }
 
 // Data is sent to 8 Fet bits...
 inline void setLatch(uint8_t latchNr, uint8_t data) {
 	selectLatch(latchNr); // Activate current latch
 	PORTA = data; // Put latch data
-	delay_ns(LATCHDELAY); // Wait for latch
+	asm volatile("nop"::); // Wait for latch
 }
 
 inline void isrCall(void) {
 		layer = 0;
 		changedFlag = 0;
 	}
-	setFet(0);
+	// setFet(0);
 	for (; latchCtr < 8; latchCtr++) {
 		setLatch(latchCtr, imgBuffer[layer][latchCtr]); // Put out all the data
 	}
 		imgFlag++; // Finished
 	}
 }
-
-inline void delay_ns(int16_t ns) {
-	// minimum 63 nanoseconds (= 1 tick)
-	for (;ns > 0; ns -= 63)
-		asm volatile("nop"::);
-}

CubeFirmware/cube.h

  */
 extern void initCube(void);
 
-// Copies the data in img into its own buffer, so free img afterwards...
+// 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);
 // For debugging, not normal operation:
 extern void setFet(uint8_t data);
 extern void setLatch(uint8_t latchNr, uint8_t data);
+extern uint32_t getTriggerCount(void);

CubeFirmware/main.c

 #ifdef DEBUG
 void printErrors(uint8_t e);
 uint8_t selfTest(void);
+void printTime(void);
 
 #include "snake.c"
 #endif
 	uint8_t i, length = 0, lastMode;
 	uint16_t count;
 	uint64_t lastChecked;
+	uint8_t DebugDone = 0; // Bit 0: 10s int. count, Bit 1: switch idle display
 
 	initCube();
 	serialInit(25, 8, NONE, 1);
 				audioData = getAudioData();
 				if (audioData != NULL) {
 					imageData = (uint8_t *)malloc(64);
+					if (imageData == NULL) {
+#ifdef DEBUG
+						serialWriteString(getString(24));
+#endif
+						while(1);
+					}
 					visualizeAudioData(audioData, imageData);
 					setImage(imageData);
 					free(imageData);
-					free(audioData);
 				}
 			}
 		} else {
 					setImage(imageData);
 					free(imageData);
 				}
+			} else {
+				if (isFinished() >= 12) {
+					// Should happen every half second
+					if (DebugDone & 2) {
+						fillBuffer(0);
+						DebugDone &= ~(2);
+					} else {
+						fillBuffer(0xFF);
+						DebugDone |= 2;
+					}
+				}
 			}
 		}
 
 			serialHandler((char)(serialGet()));
 		}
 
+		if ((getSystemTime() >= 10000) && ((DebugDone & 1) == 0)) {
+			printTime();
+			serialWriteString(ltoa(getTriggerCount(), buffer, 10));
+			serialWrite('\n');
+			DebugDone |= 1;
+		}
+
 		if ((getSystemTime() - lastChecked) > 150) {
 			lastMode = audioModeSelected();
 			lastChecked = getSystemTime();
 
 void serialHandler(char c) {
 	// Used letters:
-	// a, c, d, g, s, t, v, x
+	// a, c, d, e, g, n, s, t, v, x, 0, 1, 2
 	uint8_t i, y, z;
 #ifdef DEBUG
 	serialWrite(c);
 		serialWriteString(getString(11));
 		serialWriteString(getString(12));
 		serialWriteString(getString(13));
+		serialWriteString(getString(26));
 #endif
 		break;
 
 
 #ifdef DEBUG
 	case 't': case 'T':
-		serialWriteString(getString(14));
-		serialWriteString(ltoa(getSystemTime(), buffer, 10));
-		serialWriteString("ms");
-		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');
-		}
+		printTime();
 		break;
 
 	case 'a': case 'A':
 					for (z = 0; z < 8; z++) {
 						defaultImage[y + (i * 8)] |= (1 << z);
 						setImage(defaultImage);
-						while (isFinished() == 0);
+						while (isFinished() == 0) {
+							if (serialHasChar()) {
+								goto killMeForIt; // Yes I know...
+								// But I need to break out of 2 while Loops...
+							}
+						}
 					}
 					defaultImage[y + (i * 8)] = 0;
 				}
 			}
-			if (serialHasChar()) {
-				break;
-			}
 		}
 		break;
+killMeForIt:
+		serialGet();
+		serialWriteString(getString(25));
+		break;
+
+	case 'I': case 'i':
+		serialWriteString(ltoa(getTriggerCount(), buffer, 10));
+		serialWrite('\n');
+		break;
 #endif
 
 	default:
 }
 
 #ifdef DEBUG
+void printTime(void) {
+	serialWriteString(getString(14));
+	serialWriteString(ltoa(getSystemTime(), buffer, 10));
+	serialWriteString("ms");
+	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');
+	}
+}
+
 void sendAudioData(void) {
 	uint8_t i;
 	uint8_t *audioData = getAudioData();
 			serialWriteString(buffer);
 			serialWrite('\n');
 		}
-		free(audioData);
 	}
 }
 #endif

CubeFirmware/mem.c

 #include "mem.h"
 #ifdef DEBUG
 #include "serial.h"
+#include "strings.h"
 #endif
 
 // address is a number between (inclusive) zero and 131071
 // Free returned memory!
 uint8_t *memGetBytes(uint32_t address, uint8_t length) {
 	// We could use the High-Speed Mode of the FM24V10 here, but we don't, right now...
-	uint8_t addA, addB, memAddress = MEMTWIADDRESS, i;
-	uint8_t *ret;
+	uint8_t addA, addB, memAddress = MEMTWIADDRESS, i, *ret;
 	if (address >= 65536) {
 		// Address needs more than 16 bits, we have to set the PAGE bit in i2c address
 		memAddress |= 2;
 	ret = (uint8_t *)malloc(length); // Allocate memory for values read
 	if (ret == NULL) {
 #ifdef DEBUG
-		serialWriteString("memGetBytes: No memory!\n");
+		serialWriteString(getString(24));
 #endif
 		return NULL;
 	}

CubeFirmware/snake.c

 
 void displayBuffs(uint8_t *a, uint8_t *b) {
 	uint8_t *buf = (uint8_t *)malloc(64);
+	if (buf == NULL) {
+		serialWriteString(getString(24));
+		while(1);
+	}
 	uint8_t i;
 	for (i = 0; i < 64; i++) {
 		buf[i] = a[i] | b[i];
 
 void snake() {
 	uint8_t *snake = (uint8_t *)malloc(64); // Snake
+	if (snake == NULL) {
+		serialWriteString(getString(24));
+		while(1);
+	}
 	uint8_t i, xPos = 3, yPos = 3, zPos = 3, dir = UP, length = 1;
 	uint8_t xCoin = 1, yCoin = 1, zCoin = 1;
 	char c;

CubeFirmware/strings.c

 char stringAccessError[] PROGMEM = "Could not access device!\n"; // 21
 char stringAudioData[] PROGMEM = "Audio Data:\n"; // 22
 char stringSnakeControl[] PROGMEM = "Controls: W A S D Q E, x to quit\n"; // 23
+char stringNoMoreHeap[] PROGMEM = "Ran out of Heap... Bye\n"; // 24
+char stringKilledAnimation[] PROGMEM = "Animation aborted!\n"; // 25
+char stringHelp9[] PROGMEM = "(i)nterrupt count\n"; // 26
 
-#define STRINGNUM 24
+// Last index + 1
+#define STRINGNUM 27
 
 PGM_P stringTable[STRINGNUM] PROGMEM = { stringVersion, stringSelfTestError, stringInit,
 								stringAudioError, stringMemError, stringMemWriteError,
 								stringHelp1, stringHelp2, stringHelp3, stringHelp4, stringHelp5,
 								stringHelp6, stringHelp7, stringHelp8, stringTime, stringFrames,
 								stringByte, stringWritten, stringCount, stringSelfTest,
-								stringKillCount, stringAccessError, stringAudioData, stringSnakeControl };
+								stringKillCount, stringAccessError, stringAudioData,
+								stringSnakeControl, stringNoMoreHeap, stringKilledAnimation,
+								stringHelp9 };
 
 char stringNotFoundError[] PROGMEM = "String not found!\n";