Cube now flicker free.

The display now gets updated with 48fps or 384 layers per second, while
the animations still play with 24fps.

CubeFirmware/cube.c

 #define F_CPU 16000000L
 #endif
 
-// Should be 41666
-#define COUNT 41666
-
 /*
- * 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
+ * 24 fps, 8 layers => 192 Interrupts per second
+ * We are at 16MHz, so we count to:
+ * 16000000 / 192 = 83333,33...
+ * We can only count to 2^16, therefore we have a second counter
+ * COUNT * (COUNT2 + 1) = Realcount
+ * 41666 * 2 = 83332
+ * This is flickering really hard.
  *
- * |-------------------------------|
- * |  COUNT   |  1   | 41666 |     |
- * |----------|------|-------|-----|
- * | intcount | 2451 | 2451  |     |
- * |-------------------------------|
- *
- * Haha, what's up with that?
+ * COUNT2 set to 0 on the other hand, thus producing 48fps,
+ * works flicker-free. Now we just return imgFlag / 2 as isFinished(),
+ * so we still fake 24fps for the main program...
  */
 
+#define COUNT 41666
+#define COUNT2 0
+
 volatile uint8_t imgBuffer[8][8];
 volatile uint8_t changedFlag = 0;
 volatile uint8_t imgFlag = 0;
 volatile uint8_t layer = 0;
+volatile uint8_t toggleFlag = 0;
 
 inline void isrCall(void);
 
 volatile uint32_t timesTriggered = 0;
 volatile uint8_t warningDisplayed = 0;
 
+ISR(TIMER1_COMPA_vect) {
+	if (toggleFlag >= COUNT2) {
+		isrCall();
+		toggleFlag = 0;
+		timesTriggered++;
+	} else {
+		toggleFlag++;
+	}
+}
+
 uint32_t getTriggerCount(void) {
 	return timesTriggered;
 }
 }
 
 uint8_t isFinished(void) {
-	return imgFlag;
+	return (imgFlag / 2);
 }
 
 void initCube(void) {
 	TIMSK &= ~(1 << OCIE1A); // Disable interrupt
 }
 
-ISR(TIMER1_COMPA_vect) {
-	isrCall();
-	timesTriggered++;
-#ifdef DEBUG
-	if (TIFR & TOV1) {
-		if (warningDisplayed) {
-			serialWrite('!');
-		} else {
-			serialWriteString(getString(27));
-			warningDisplayed++;
-		}
-		TIFR |= (1 << TOV1); // Clear flag
-	}
-#endif
-}
-
 // Data is sent to 8 Fet bits...
 inline void setFet(uint8_t data) {
 	PORTD = (data & ~(3)); // Doesn't interfere with serial communication...

CubeFirmware/main.c

 // x = errorcode, e = error definition, not NOERROR
 #define ISERROR(x, e) ((x) & (e))
 
+// Length of an idle animation frame, 24 -> 1 second
+#define IDLELENGTH 24
+
 void serialHandler(char c);
 void sendAudioData(void);
 void recieveAnimations(void);
 								0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 								0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
 
+uint8_t DebugDone = 0; // Bit 0: 10s int. count, Bit 1: switch idle display
+					   // Bit 2: state changed, disable idle
+
 int main(void) {
 	uint8_t *audioData = NULL;
 	uint8_t *imageData = NULL;
 	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
+	uint32_t temp;
 
 	initCube();
 	serialInit(25, 8, NONE, 1);
 					free(imageData);
 				}
 			} else {
-				if (isFinished() >= 12) {
-					// Should happen every half second
-					if (DebugDone & 2) {
-						fillBuffer(0);
-						DebugDone &= ~(2);
-					} else {
-						fillBuffer(0xFF);
-						DebugDone |= 2;
+				if (!(DebugDone & 4)) {
+					if (isFinished() >= IDLELENGTH) {
+						// Should happen every half second
+						if (DebugDone & 2) {
+							fillBuffer(0);
+							DebugDone &= ~(2);
+						} else {
+							fillBuffer(0xFF);
+							DebugDone |= 2;
+						}
 					}
 				}
 			}
 		}
 
 		if ((getSystemTime() >= 1000) && ((DebugDone & 1) == 0)) {
-			printTime();
-			serialWriteString(ltoa(getTriggerCount(), buffer, 10));
-			serialWrite('\n');
+			temp = getTriggerCount();
+			serialWriteString(ltoa(temp, buffer, 10));
+			serialWriteString(getString(27));
+			serialWriteString(ltoa((temp / 8), buffer, 10));
+			serialWriteString(getString(28));
 			DebugDone |= 1;
 		}
 
 
 	case 'd': case 'D':
 		clearMem();
+#ifndef DEBUG
 		serialWrite(OK);
+#endif
+#ifdef DEBUG
+		serialWriteString(getString(29));
+#endif
 		break;
 
+#ifndef DEBUG
 	case 'g': case 'G':
 		transmitAnimations();
 		break;
 	case 's': case 'S':
 		recieveAnimations();
 		break;
+#endif
 
 	case 'v': case 'V':
 		serialWriteString(getString(0));
 		setAnimationCount(0);
 		refreshAnimationCount = 1;
 		serialWriteString(getString(20));
+		DebugDone |= 4;
 		break;
 
 	case '1':
 		setAnimationCount(0);
 		refreshAnimationCount = 1;
 		serialWriteString(getString(20));
+		DebugDone |= 4;
 		break;
 
 	case '2':
+		DebugDone |= 4;
 		fillBuffer(0);
 		for (i = 0; i < 64; i++) {
 			defaultImage[i] = 0;

CubeFirmware/strings.c

 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
-char stringTimerOverflow[] PROGMEM = "Cube Timer Overflowed (now !)\n"; // 27
+char stringInterrupts[] PROGMEM = " Interrupts after 1000msec\n"; // 27
+char stringFrames2[] PROGMEM = " Frames per Second\n"; // 28
+char stringDeleted[] PROGMEM = "Memory deleted!\n"; // 29
 
 // Last index + 1
-#define STRINGNUM 28
+#define STRINGNUM 30
 
 PGM_P stringTable[STRINGNUM] PROGMEM = { stringVersion, stringSelfTestError, stringInit,
 								stringAudioError, stringMemError, stringMemWriteError,
 								stringByte, stringWritten, stringCount, stringSelfTest,
 								stringKillCount, stringAccessError, stringAudioData,
 								stringSnakeControl, stringNoMoreHeap, stringKilledAnimation,
-								stringHelp9, stringTimerOverflow };
+								stringHelp9, stringInterrupts, stringFrames2, stringDeleted };
 
 char stringNotFoundError[] PROGMEM = "String not found!\n";