Debugging

CubeFirmware/audio.c

@@ -33,11 +33,14 @@ uint8_t *getAudioData(void) {
 	uint8_t i;
 	uint8_t *ret = (uint8_t *)malloc(7);
 
-	i2c_start(TWIADDRESSAUDIO | I2C_READ);
-	for (i = 0; i < 6; i++) {
-		ret[i] = i2c_readAck();
+	if (i2c_start(TWIADDRESSAUDIO | I2C_READ) == 0) {
+		for (i = 0; i < 6; i++) {
+			ret[i] = i2c_readAck();
+		}
+		ret[6] = i2c_readNak();
+		i2c_stop();
+		return ret;
+	} else {
+		return NULL;
 	}
-	ret[6] = i2c_readNak();
-	i2c_stop();
-	return ret;
 }

CubeFirmware/cube.c

@@ -76,7 +76,7 @@ uint8_t isFinished(void) {
 	return imgFlag;
 }
 
-void init(void) {
+void initCube(void) {
 	uint8_t ctr = 0;
 
 	TCCR1A |= (1 << WGM12); // CTC Mode

CubeFirmware/cube.h

@@ -26,7 +26,7 @@
  * After the last part is applied to the latches, isFinished() will change
  * to 1. Now you can place a new picture here.
  */
-extern void init(void);
+extern void initCube(void);
 
 // Copies the data in img into its own buffer, so free img afterwards...
 extern void setImage(uint8_t **img); // img[8][8]

CubeFirmware/main.c

@@ -44,8 +44,10 @@
 #include "time.h"
 #include "audio.h"
 #include "memLayer.h"
+#include "twi.h"
 
 void serialHandler(char c);
+void sendAudioData(void);
 void recieveAnimations(void);
 void transmitAnimations(void);
 uint8_t audioModeSelected(void);
@@ -61,10 +63,15 @@ char buffer[11];
 int main(void) {
 	uint8_t *audioData;
 	uint8_t **imageData;
-	uint8_t i;
-	uint64_t lastTimeChecked;
-	uint8_t audioMode;
+	uint8_t i, lastMode;
 	uint16_t count;
+	uint64_t lastChecked;
+
+	initCube();
+	serialInit(51, 8, NONE, 1);
+	i2c_init();
+	initSystemTimer();
+	sei(); // Enable Interrupts
 
 	DDRD = 0xFC; // Mosfets as Output
 	DDRB = 0xFE;
@@ -76,17 +83,7 @@ int main(void) {
 		imageData[i] = (uint8_t *)malloc(8 * sizeof(uint8_t));
 	}
 
-	init(); // Initialize Cube Low-Level Code
-	serialInit(51, 8, NONE, 1);
-	initSystemTimer();
-
-	sei(); // Enable Interrupts
-
-	lastTimeChecked = getSystemTime();
-	audioMode = audioModeSelected();
-
 #ifdef DEBUG
-#warning NOT TALKING TO FRAM YET!
 	refreshAnimationCount = 0; // Don't talk to FRAM yet...
 
 	serialWriteString("Initialized: ");
@@ -96,14 +93,19 @@ int main(void) {
 	serialWriteString(" ms!\n");
 #endif
 
+	lastMode = audioModeSelected();
+	lastChecked = getSystemTime();
+
 	while (1) {
-		if(audioMode) {
+		if(lastMode) {
 			// Get Audio Data and visualize it
-			audioData = getAudioData();
-			visualizeAudioData(audioData, imageData);
-			setImage(imageData);
-			free(audioData);
-			while(!isFinished()); // Wait for it to display
+			/* audioData = getAudioData();
+			if (audioData != NULL) {
+				visualizeAudioData(audioData, imageData);
+				setImage(imageData);
+				free(audioData);
+			}
+			while(!isFinished()); // Wait for it to display */
 		} else {
 			// Look for commands, play from fram
 			// We have 128*1024 bytes
@@ -115,18 +117,17 @@ int main(void) {
 				serialHandler((char)(serialGet()));
 			}
 
-			if (refreshAnimationCount) {
+			/* if (refreshAnimationCount) {
 				// Get animation count stored in FRAM via TWI, if needed
 				count = getAnimationCount();
 				refreshAnimationCount = 0;
-			}
+			} */
 		}
 
-		if ((getSystemTime() - lastTimeChecked) > 1000) {
-			// 1 second since we checked button position last time
-			audioMode = audioModeSelected();
-			lastTimeChecked = getSystemTime();
-		}
+		if ((getSystemTime() - lastChecked) > 100) {
+			lastMode = audioModeSelected();
+			lastChecked = getSystemTime();
+		} 
 	}
 
 	close();
@@ -134,44 +135,90 @@ int main(void) {
 }
 
 void serialHandler(char c) {
-	// Got a char on serial line...
-	// React accordingly
-	// Set refreshAnimationCount if Animation Data in Ram was changed...
-	// We do a complete transaction in one call of this routine...
-
+	// Used letters:
+	// a, c, d, g, s, t, v
 	switch(c) {
-		case OK:
-			// Send "Hello World"
-			serialWrite(OK);
-			break;
+	case OK:
+		serialWrite(OK);
+		break;
 
-		case 'd': case 'D':
-			clearMem();
-			serialWrite(OK);
-			break;
+	case 'd': case 'D':
+		clearMem();
+		serialWrite(OK);
+		break;
+
+	case 'g': case 'G':
+		transmitAnimations();
+		break;
+
+	case 's': case 'S':
+		recieveAnimations();
+		break;
+
+	case 'v': case 'V':
+		serialWriteString(VERSION);
+		break;
+
+	case 't': case 'T':
+		serialWriteString("System Time: ");
+		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');
+		}
+		break;
 
-		case 'g': case 'G':
-			transmitAnimations();
-			break;
+	case 'a': case 'A':
+		sendAudioData();
+		break;
 
-		case 's': case 'S':
-			recieveAnimations();
-			break;
+	case 'c': case 'C':
+		serialWriteString(itoa(getAnimationCount(), buffer, 10));
+		serialWriteString(" Frames stored\n");
+		break;
 
-		case 'v': case 'V':
-			serialWriteString(VERSION);
-			break;
+	case '\n':
+		serialWriteString(VERSION);
+		serialWriteString("See xythobuz.org for more Infos!\n");
+		break;
 
-		case 't': case 'T':
-			serialWriteString("System Time: ");
-			serialWriteString(itoa(getSystemTime(), buffer, 10));
-			serialWrite('\n');
-			break;
+	default:
+		serialWrite(ERROR);
+		break;
+	}
+}
 
-		default:
-			serialWrite(ERROR);
-			break;
+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');
+	}
+
+	free(audioData);
 }
 
 void recieveAnimations() {
@@ -242,10 +289,6 @@ void recieveAnimations() {
 	refreshAnimationCount = 1;
 }
 
-#define CAF(x) (x % 256)
-#define CAS(x) (x / 256)
-#define CALCANIMATIONS(x) ((CAF(x) == 0) ? (CAS(x)) : (CAS(x) + 1))
-
 void transmitAnimations() {
 	// We store no animation information in here
 	// So we have to place all frames in one or more
@@ -316,42 +359,25 @@ void transmitAnimations() {
 	// Error code ignored...
 }
 
-// Blocks 10ms or more
 uint8_t audioModeSelected(void) {
 	// Pushbutton: PB0, Low active
-	uint8_t startState = PINB & (1 << PB0);
-
-	_delay_ms(10);
 
-	if ((PINB & (1 << PB0)) != startState) {
-		// State changed
-		// We can assume we have to toggle the state
-#ifdef DEBUG
-		serialWriteString("New State!");
-#endif
+	if (!(PINB & (1 << PB0))) {
+		// Button pushed
 		if (lastButtonState == 0) {
 			lastButtonState = 1;
 		} else {
 			lastButtonState = 0;
 		}
-		return lastButtonState;
-	} else {
-		if (!startState) {
-			// Stayed the same, is pushed!
+
 #ifdef DEBUG
-			serialWriteString("New State!");
+		serialWriteString("New State (");
+		serialWriteString(itoa(lastButtonState, buffer, 10));
+		serialWriteString(")\n");
 #endif
-			if (lastButtonState == 0) {
-				lastButtonState = 1;
-			} else {
-				lastButtonState = 0;
-			}
-			return lastButtonState;
-		} else {
-			// Stayed but is not pushed...
-			return lastButtonState;
-		}
+
 	}
+	return lastButtonState;
 }
 
 inline void setPixelBuffer(uint8_t x, uint8_t y, uint8_t z, uint8_t **buf) {

CubeFirmware/mem.c

@@ -36,13 +36,16 @@ uint8_t memGetByte(uint32_t address) {
 	addA = memAddress & 0xFF00;
 	addB = memAddress & 0xFF;
 
-	i2c_start(memAddress | I2C_WRITE); // Send start, write address to read
-	i2c_write(addA);
-	i2c_write(addB); // Give address to memory
-	i2c_rep_start(memAddress | I2C_READ); // Start again, this time reading
-	ret = i2c_readNak(); // Read one byte from memory
-	i2c_stop();
-	return ret;
+	if (i2c_start(memAddress | I2C_WRITE) == 0) { // Send start, write address to read
+		i2c_write(addA);
+		i2c_write(addB); // Give address to memory
+		i2c_rep_start(memAddress | I2C_READ); // Start again, this time reading
+		ret = i2c_readNak(); // Read one byte from memory
+		i2c_stop();
+		return ret;
+	} else {
+		return 0;
+	}
 }
 
 // Free returned memory!
@@ -58,16 +61,19 @@ uint8_t *memGetBytes(uint32_t address, uint8_t length) {
 	addB = memAddress & 0xFF;
 	ret = (uint8_t *)malloc(length); // Allocate memory for values read
 
-	i2c_start(memAddress | I2C_WRITE);
-	i2c_write(addA);
-	i2c_write(addB);
-	i2c_rep_start(memAddress | I2C_READ);
-	for (i = 0; i < (length - 1); i++) {
-		ret[i] = i2c_readAck();
+	if (i2c_start(memAddress | I2C_WRITE) == 0) {
+		i2c_write(addA);
+		i2c_write(addB);
+		i2c_rep_start(memAddress | I2C_READ);
+		for (i = 0; i < (length - 1); i++) {
+			ret[i] = i2c_readAck();
+		}
+		ret[length - 1] = i2c_readNak();
+		i2c_stop();
+		return ret;
+	} else {
+		return NULL;
 	}
-	ret[length - 1] = i2c_readNak();
-	i2c_stop();
-	return ret;
 }
 
 void memWriteByte(uint32_t address, uint8_t data) {
@@ -78,10 +84,12 @@ void memWriteByte(uint32_t address, uint8_t data) {
 	}
 	addA = memAddress & 0xFF00;
 	addB = memAddress & 0xFF;
-	i2c_write(addA);
-	i2c_write(addB); // Give address to memory
-	i2c_write(data);
-	i2c_stop();
+	if (i2c_start(memAddress | I2C_WRITE) == 0) {
+		i2c_write(addA);
+		i2c_write(addB); // Give address to memory
+		i2c_write(data);
+		i2c_stop();
+	}
 }
 
 void memWriteBytes(uint32_t address, uint8_t *data, uint8_t length) {
@@ -92,10 +100,12 @@ void memWriteBytes(uint32_t address, uint8_t *data, uint8_t length) {
 	}
 	addA = memAddress & 0xFF00;
 	addB = memAddress & 0xFF;
-	i2c_write(addA);
-	i2c_write(addB); // Give address to memory
-	for (i = 0; i < length; i++) {
-		i2c_write(data[i]);
+	if (i2c_start(memAddress | I2C_WRITE) == 0) {
+		i2c_write(addA);
+		i2c_write(addB); // Give address to memory
+		for (i = 0; i < length; i++) {
+			i2c_write(data[i]);
+		}
+		i2c_stop();
 	}
-	i2c_stop();
 }

CubeFirmware/time.c

@@ -20,35 +20,28 @@
  * You should have received a copy of the GNU General Public License
  * along with LED-Cube.  If not, see <http://www.gnu.org/licenses/>.
  */
-// Uses Timer 0!
 #include <stdlib.h>
 #include <stdint.h>
 #include <avr/io.h>
 #include <avr/interrupt.h>
 #include "time.h"
 
+// Uses Timer 0!
 // Interrupt:
-// Prescaler 256
-// Count to 208
-// Execute every 3 times
+// Prescaler 64
+// Count to 250
 // => 1 Interrupt per millisecond
 
 volatile uint64_t systemTime = 0; // Overflows in 500 million years... :)
-volatile uint8_t isrCounter = 0;
 
 void initSystemTimer() {
-	TCCR0 |= (1 << WGM01) | (1 << CS02); // Prescaler: 256, CTC Mode
-	OCR0 = 208;
-	TIMSK |= (1 << TOIE0); // Enable overflow interrupt
+	TCCR0 |= (1 << WGM01) | (1 << CS01) | (1 << CS00); // Prescaler: 256, CTC Mode
+	OCR0 = 250;
+	TIMSK |= (1 << OCIE0); // Enable overflow interrupt
 }
 
-ISR(TIMER0_OVF_vect) {
-	if (isrCounter >= 2) {
-		isrCounter = 0;
-		systemTime++;
-	} else {
-		isrCounter++;
-	}
+ISR(TIMER0_COMP_vect) {
+	systemTime++;
 }
 
 uint64_t getSystemTime() {