Replaced serial Library.

This was done because I was suspecting an error to be there. This is
not the case, so we probably have a Hardware Problem with our USB
Serial Stuff… If we send data too fast it sends garbage. It also always
sends two additional bytes (0xC2 at the beginning, 0xFF at the end),
which both come at the beginning if we don't delay between sending the
chars…

AudioFirmware/main.c

 #endif
 
 void blinkStatus(void) {
-	uint8_t i, mem[7] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
+	// uint8_t i, mem[7] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
 
 	PORTB |= (1 << PB2);
 	PORTB &= ~(1 << PB1);
-	eqLed(mem);
+	// eqLed(mem);
 	_delay_ms(250);
 	PORTB &= ~(1 << PB2);
 	PORTB |= (1 << PB1);
-	for (i = 0; i < 7; i++) {
-		mem[i] = 0x00;
-	}
-	eqLed(mem);
+	// for (i = 0; i < 7; i++) {
+	// 	mem[i] = 0x00;
+	// }
+	// eqLed(mem);
 	_delay_ms(250);
 }
 
 	while (1) {
 		music = equalizerGet();
 		if (twiDataWasSent()) {
+			PORTB ^= (1 << PB2); // Toggle for every transaction
 			twiSetDataToSend(music);
 		}
 		eqLed(music);

CubeFirmware/cube.c

 #include <stdlib.h>
 #include <util/atomic.h>
 
-#include "uart.h"
+ #include "serial.h"
 #include "cube.h"
 
 #ifndef F_CPU

CubeFirmware/main.c

  * 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 <stdlib.h>
-#include <stdint.h>
+
+#ifndef F_CPU
+#define F_CPU 16000000L
+#endif
+ 
+#define OK 0x42
+#define ERROR 0x23
+
 #include <avr/io.h>
 #include <util/delay.h>
 #include <avr/interrupt.h>
-#include "uart.h"
+#include <avr/pgmspace.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "serial.h"
 #include "cube.h"
 #include "time.h"
 #include "audio.h"
 #include "memLayer.h"
 
-#ifndef F_CPU
-#define F_CPU 16000000L
-#endif
-
-#define OK 0x42
-#define ERROR 0x23
-
 void serialHandler(char c);
 void recieveAnimations(void);
 void transmitAnimations(void);
 void visualizeAudioData(uint8_t *audioData, uint8_t **imageData);
 
 uint8_t refreshAnimationCount = 1;
+uint8_t lastButtonState = 1;
 
 int main(void) {
-	unsigned int character;
 	uint8_t *audioData;
 	uint8_t **imageData;
 	uint8_t i;
 	}
 
 	init(); // Initialize Cube Low-Level Code
-	uart_init(UART_BAUD_SELECT(19200, 16000000L)); // Initialize Serial
+	serialInit(51, 8, NONE, 1);
 	initSystemTimer();
 
 	sei(); // Enable Interrupts
 
+	for (i = 25; i < 55; i++) {
+		serialWrite(0x58); // 'X'
+		_delay_ms(1); // Sends garbage if no delay... :(
+	}
+
 	audioMode = audioModeSelected();
 	lastTimeChecked = getSystemTime();
 
 			// We place 2016 Frames in mem => 131040
 			// That gives us 32 bytes at the beginning, 0 -> 31
 			// The first frame starts at 32
-			character = uart_getc();
-			if (!(character & 0xFF00)) { // No error...
-				serialHandler((char)(character & 0x00FF));
+			if (serialHasChar()) {
+				serialHandler((char)(serialGet()));
 			}
 
 			if (refreshAnimationCount) {
 	switch(c) {
 		case OK:
 			// Send "Hello World"
-			uart_putc(OK);
+			serialWrite(OK);
 			break;
 
 		case 'd': case 'D':
 			clearMem();
-			uart_putc(OK);
+			serialWrite(OK);
 			break;
 
 		case 'g': case 'G':
 			recieveAnimations();
 			break;
 
+		case 'v':
+			serialWriteString("v1");
+			break;
+
 		default:
-			uart_putc(ERROR);
+			serialWrite(ERROR);
 			break;
 	}
 }
 	uint16_t completeCount = 0, character;
 	uint8_t frame[65];
 
-	uart_putc(OK); // We are ready...
+	serialWrite(OK); // We are ready...
 
-	character = uart_getc();
+	character = serialGet();
 	while (character & 0xFF00) { // Wait for answer
-		character = uart_getc();
+		character = serialGet();
 	}
 
 	animCount = (uint8_t)(character & 0x00FF); // Got animation count
-	uart_putc(OK);
+	serialWrite(OK);
 
 	for (a = 0; a < animCount; a++) {
-		character = uart_getc();
+		character = serialGet();
 		while (character & 0xFF00) { // Wait for answer
-			character = uart_getc();
+			character = serialGet();
 		}
 
 		frameCount = (uint8_t)(character & 0x00FF); // Got frame count
-		uart_putc(OK);
+		serialWrite(OK);
 
 		for (f = 0; f < frameCount; f++) {
-			character = uart_getc();
+			character = serialGet();
 			while (character & 0xFF00) { // Wait for answer
-				character = uart_getc();
+				character = serialGet();
 			}
 
 			frame[64] = (uint8_t)(character & 0x00FF); // Got duration
-			uart_putc(OK);
+			serialWrite(OK);
 
 			for (i = 0; i < 64; i++) {
-				character = uart_getc();
+				character = serialGet();
 				while (character & 0xFF00) { // Wait for answer
-					character = uart_getc();
+					character = serialGet();
 				}
 
 				frame[i] = (uint8_t)(character & 0x00FF); // Got data byte
 			}
-			uart_putc(OK);
+			serialWrite(OK);
 
 			setFrame(completeCount++, frame);
 		}
 	}
 
-	character = uart_getc();
+	character = serialGet();
 	while (character & 0xFF00) { // Wait for answer
-		character = uart_getc();
+		character = serialGet();
 	}
-	character = uart_getc();
+	character = serialGet();
 	while (character & 0xFF00) { // Wait for answer
-		character = uart_getc();
+		character = serialGet();
 	}
-	character = uart_getc();
+	character = serialGet();
 	while (character & 0xFF00) { // Wait for answer
-		character = uart_getc();
+		character = serialGet();
 	}
-	character = uart_getc();
+	character = serialGet();
 	while (character & 0xFF00) { // Wait for answer
-		character = uart_getc();
+		character = serialGet();
 	}
-	uart_putc(OK);
+	serialWrite(OK);
 	setAnimationCount(completeCount);
 	refreshAnimationCount = 1;
 }
 		animationsToGo = (framesToGo / 255) + 1;
 	}
 
-	uart_putc(OK);
-	uart_putc(animationsToGo);
-	while ((character = uart_getc()) & 0xFF00); // Wait for answer
+	serialWrite(OK);
+	serialWrite(animationsToGo);
+	while ((character = serialGet()) & 0xFF00); // Wait for answer
 	if ((character & 0x00FF) != OK) { // Error code recieved
 		return;
 	}
 			fMax = framesToGo;
 		}
 
-		uart_putc(fMax); // Number of Frames in current animation
-		while ((character = uart_getc()) & 0xFF00); // Wait for answer
+		serialWrite(fMax); // Number of Frames in current animation
+		while ((character = serialGet()) & 0xFF00); // Wait for answer
 		if ((character & 0x00FF) != OK) { // Error code recieved
 			return;
 		}
 		for (f = 0; f < fMax; f++) {
 			frame = getFrame(f + (255 * a));
 
-			uart_putc(frame[64]); // frame duration
-			while ((character = uart_getc()) & 0xFF00); // Wait for answer
+			serialWrite(frame[64]); // frame duration
+			while ((character = serialGet()) & 0xFF00); // Wait for answer
 			if ((character & 0x00FF) != OK) { // Error code recieved
 				free(frame);
 				return;
 			}
 
 			for (i = 0; i < 64; i++) {
-				uart_putc(frame[i]);
+				serialWrite(frame[i]);
 			}
-			while ((character = uart_getc()) & 0xFF00); // Wait for answer
+			while ((character = serialGet()) & 0xFF00); // Wait for answer
 			if ((character & 0x00FF) != OK) { // Error code recieved
 				free(frame);
 				return;
 		framesToGo -= fMax;
 	}
 
-	uart_putc(OK);
-	uart_putc(OK);
-	uart_putc(OK);
-	uart_putc(OK);
+	serialWrite(OK);
+	serialWrite(OK);
+	serialWrite(OK);
+	serialWrite(OK);
 
-	while ((character = uart_getc()) & 0xFF00); // Wait for answer
+	while ((character = serialGet()) & 0xFF00); // Wait for answer
 	// Error code ignored...
 }
 
 // Blocks 10ms or more
 uint8_t audioModeSelected(void) {
-	// Switch: PB0, Low active
+	// Pushbutton: PB0, Low active
 	uint64_t startTime = getSystemTime();
 	uint8_t startState = PINB & (1 << PB0);
 
 	while((getSystemTime() - startTime) < 10); // Wait 10ms
 
 	if ((PINB & (1 << PB0)) != startState) {
-		return audioModeSelected();
+		// State changed
+		// We can assume we have to toggle the state
+		if (lastButtonState == 0) {
+			lastButtonState = 1;
+		} else {
+			lastButtonState = 0;
+		}
+		return lastButtonState;
 	} else {
-		return startState;
+		if (startState) {
+			// Stayed the same, is pushed!
+			if (lastButtonState == 0) {
+				lastButtonState = 1;
+			} else {
+				lastButtonState = 0;
+			}
+			return lastButtonState;
+		} else {
+			// Stayed but is not pushed...
+			return lastButtonState;
+		}
 	}
 }
 

CubeFirmware/makefile

 
 # List C source files here. (C dependencies are automatically generated.)
 SRC = $(TARGET).c
-SRC += uart.c # Additional Source-File
+SRC += serial.c # Additional Source-File
 SRC += cube.c
 SRC += twi.c
 SRC += mem.c

CubeFirmware/serial.c

+/*
+ * serial.c
+ *
+ * Copyright 2011 Thomas Buck <xythobuz@me.com>
+ *
+ * This file is part of xyRobot.
+ *
+ * xyRobot 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.
+ *
+ * xyRobot 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 xyRobot.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <stdint.h>
+
+#include <serial.h>
+
+uint8_t volatile rxBuffer[RX_BUFFER_SIZE];
+uint8_t volatile txBuffer[TX_BUFFER_SIZE];
+uint16_t volatile rxRead = 0;
+uint16_t volatile rxWrite = 0;
+uint16_t volatile txRead = 0;
+uint16_t volatile txWrite = 0;
+uint8_t volatile shouldStartTransmission = 1;
+
+ISR(USART_RX_vect) { // Receive complete
+    rxBuffer[rxWrite] = UDR;
+	if (rxWrite < (RX_BUFFER_SIZE - 1)) {
+		rxWrite++;
+	} else {
+		rxWrite = 0;
+	}
+}
+
+ISR(USART_UDRE_vect) { // Data register empty
+    if (txRead != txWrite) {
+		UDR = txBuffer[txRead];
+		if (txRead < (TX_BUFFER_SIZE -1)) {
+			txRead++;
+		} else {
+			txRead = 0;
+		}
+	} else {
+		shouldStartTransmission = 1;
+		UCSRB &= ~(1 << UDRIE); // Disable Interrupt
+	}
+}
+
+uint8_t serialInit(uint16_t baud, uint8_t databits, uint8_t parity, uint8_t stopbits) {
+	if (parity > ODD) {
+		return 1;
+	}
+	if ((databits < 5) || (databits > 8)) {
+		return 1;
+	}
+	if ((stopbits < 1) || (stopbits > 2)) {
+		return 1;
+	}
+
+	if (parity != NONE) {
+		UCSRC |= (1 << UPM1);
+		if (parity == ODD) {
+			UCSRC |= (1 << UPM0);
+		}
+	}
+	if (stopbits == 2) {
+		UCSRC |= (1 << USBS);
+	}
+	if (databits != 5) {
+		if ((databits == 6) || (databits >= 8)) {
+			UCSRC |= (1 << UCSZ0);
+		}
+		if (databits >= 7) {
+			UCSRC |= (1 << UCSZ1);
+		}
+		if (databits == 9) {
+			UCSRB |= (1 << UCSZ2);
+		}
+	}
+	UBRRH = (baud >> 8);
+	UBRRL = baud;
+	UCSRB |= (1 << RXCIE) | (1 << RXEN) | (1 << TXEN); // Enable Interrupts and Receiver/Transmitter
+
+	return 0;
+}
+
+uint8_t serialHasChar() {
+	if (rxRead != rxWrite) {
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+uint8_t serialGet() {
+	uint8_t c;
+	if (rxRead != rxWrite) {
+		c = rxBuffer[rxRead];
+		rxBuffer[rxRead] = 0;
+		if (rxRead < (RX_BUFFER_SIZE - 1)) {
+			rxRead++;
+		} else {
+			rxRead = 0;
+		}
+		return c;
+	} else {
+		return 0;
+	}
+}
+
+uint8_t serialBufferSpaceRemaining() {
+	return (((txWrite + 1) == txRead) || ((txRead == 0) && ((txWrite + 1) == TX_BUFFER_SIZE)));
+}
+
+void serialWrite(uint8_t data) {
+	while (((txWrite + 1) == txRead) || ((txRead == 0) && ((txWrite + 1) == TX_BUFFER_SIZE))); // Buffer is full, wait!
+    txBuffer[txWrite] = data;
+	if (txWrite < (TX_BUFFER_SIZE - 1)) {
+		txWrite++;
+	} else {
+		txWrite = 0;
+	}
+	if (shouldStartTransmission == 1) {
+		shouldStartTransmission = 0;
+		UCSRB |= (1 << UDRIE); // Enable Interrupt
+		UCSRA |= (1 << UDRE); // Trigger Interrupt
+	}
+}
+
+void serialWriteString(char *data) {
+	while (*data != '\0') {
+		serialWrite(*data++);
+	}
+}
+
+void serialClose() {
+	UCSRB = 0;
+	UCSRC = 0;
+	UBRRH = 0;
+	UBRRL = 0;
+	rxRead = 0;
+	txRead = 0;
+	rxWrite = 0;
+	txWrite = 0;
+}

CubeFirmware/serial.h

+/*
+ * serial.h
+ *
+ * Copyright 2011 Thomas Buck <xythobuz@me.com>
+ *
+ * This file is part of xyRobot.
+ *
+ * xyRobot 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.
+ *
+ * xyRobot 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 xyRobot.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef serial_h_
+#define serial_h_
+
+// RX & TX buffer size in bytes
+#define RX_BUFFER_SIZE 32
+#define TX_BUFFER_SIZE 32
+
+// Select Baudrate with this macro
+#define UART_BAUD_SELECT(baudRate,xtalCpu) ((xtalCpu)/((baudRate)*16l)-1)
+
+#define ODD 2
+#define EVEN 1
+#define NONE 0
+
+uint8_t serialInit(uint16_t baud, uint8_t databits, uint8_t parity, uint8_t stopbits);
+
+uint8_t serialHasChar(void);
+uint8_t serialGet(void);
+
+// 1 if space remaining, 0 if full
+uint8_t serialBufferSpaceRemaining(void);
+void serialWrite(uint8_t data);
+void serialWriteString(char *data);
+
+void serialClose(void);
+
+#endif /* SERIAL_H_ */

CubeFirmware/uart.c

-/*************************************************************************
-Title:    Interrupt UART library with receive/transmit circular buffers
-Author:   Peter Fleury <pfleury@gmx.ch>   http://jump.to/fleury
-File:     $Id: uart.c,v 1.6.2.2 2009/11/29 08:56:12 Peter Exp $
-Software: AVR-GCC 4.1, AVR Libc 1.4.6 or higher
-Hardware: any AVR with built-in UART, 
-License:  GNU General Public License 
-          
-DESCRIPTION:
-    An interrupt is generated when the UART has finished transmitting or
-    receiving a byte. The interrupt handling routines use circular buffers
-    for buffering received and transmitted data.
-    
-    The UART_RX_BUFFER_SIZE and UART_TX_BUFFER_SIZE variables define
-    the buffer size in bytes. Note that these variables must be a 
-    power of 2.
-    
-USAGE:
-    Refere to the header file uart.h for a description of the routines. 
-    See also example test_uart.c.
-
-NOTES:
-    Based on Atmel Application Note AVR306
-                    
-LICENSE:
-    Copyright (C) 2006 Peter Fleury
-
-    This program 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 2 of the License, or
-    any later version.
-
-    This program 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.
-                        
-*************************************************************************/
-#include <avr/io.h>
-#include <avr/interrupt.h>
-#include <avr/pgmspace.h>
-#include "uart.h"
-
-
-/*
- *  constants and macros
- */
-
-/* size of RX/TX buffers */
-#define UART_RX_BUFFER_MASK ( UART_RX_BUFFER_SIZE - 1)
-#define UART_TX_BUFFER_MASK ( UART_TX_BUFFER_SIZE - 1)
-
-#if ( UART_RX_BUFFER_SIZE & UART_RX_BUFFER_MASK )
-#error RX buffer size is not a power of 2
-#endif
-#if ( UART_TX_BUFFER_SIZE & UART_TX_BUFFER_MASK )
-#error TX buffer size is not a power of 2
-#endif
-
-#if defined(__AVR_AT90S2313__) \
- || defined(__AVR_AT90S4414__) || defined(__AVR_AT90S4434__) \
- || defined(__AVR_AT90S8515__) || defined(__AVR_AT90S8535__) \
- || defined(__AVR_ATmega103__)
- /* old AVR classic or ATmega103 with one UART */
- #define AT90_UART
- #define UART0_RECEIVE_INTERRUPT   SIG_UART_RECV
- #define UART0_TRANSMIT_INTERRUPT  SIG_UART_DATA
- #define UART0_STATUS   USR
- #define UART0_CONTROL  UCR
- #define UART0_DATA     UDR  
- #define UART0_UDRIE    UDRIE
-#elif defined(__AVR_AT90S2333__) || defined(__AVR_AT90S4433__)
- /* old AVR classic with one UART */
- #define AT90_UART
- #define UART0_RECEIVE_INTERRUPT   SIG_UART_RECV
- #define UART0_TRANSMIT_INTERRUPT  SIG_UART_DATA
- #define UART0_STATUS   UCSRA
- #define UART0_CONTROL  UCSRB
- #define UART0_DATA     UDR 
- #define UART0_UDRIE    UDRIE
-#elif  defined(__AVR_ATmega8__)  || defined(__AVR_ATmega16__) || defined(__AVR_ATmega32__) \
-  || defined(__AVR_ATmega8515__) || defined(__AVR_ATmega8535__) \
-  || defined(__AVR_ATmega323__)
-  /* ATmega with one USART */
- #define ATMEGA_USART
- #define UART0_RECEIVE_INTERRUPT   SIG_UART_RECV
- #define UART0_TRANSMIT_INTERRUPT  SIG_UART_DATA
- #define UART0_STATUS   UCSRA
- #define UART0_CONTROL  UCSRB
- #define UART0_DATA     UDR
- #define UART0_UDRIE    UDRIE
-#elif defined(__AVR_ATmega163__) 
-  /* ATmega163 with one UART */
- #define ATMEGA_UART
- #define UART0_RECEIVE_INTERRUPT   SIG_UART_RECV
- #define UART0_TRANSMIT_INTERRUPT  SIG_UART_DATA
- #define UART0_STATUS   UCSRA
- #define UART0_CONTROL  UCSRB
- #define UART0_DATA     UDR
- #define UART0_UDRIE    UDRIE
-#elif defined(__AVR_ATmega162__) 
- /* ATmega with two USART */
- #define ATMEGA_USART0
- #define ATMEGA_USART1
- #define UART0_RECEIVE_INTERRUPT   SIG_USART0_RECV
- #define UART1_RECEIVE_INTERRUPT   SIG_USART1_RECV
- #define UART0_TRANSMIT_INTERRUPT  SIG_USART0_DATA
- #define UART1_TRANSMIT_INTERRUPT  SIG_USART1_DATA
- #define UART0_STATUS   UCSR0A
- #define UART0_CONTROL  UCSR0B
- #define UART0_DATA     UDR0
- #define UART0_UDRIE    UDRIE0
- #define UART1_STATUS   UCSR1A
- #define UART1_CONTROL  UCSR1B
- #define UART1_DATA     UDR1
- #define UART1_UDRIE    UDRIE1
-#elif defined(__AVR_ATmega64__) || defined(__AVR_ATmega128__) 
- /* ATmega with two USART */
- #define ATMEGA_USART0
- #define ATMEGA_USART1
- #define UART0_RECEIVE_INTERRUPT   SIG_UART0_RECV
- #define UART1_RECEIVE_INTERRUPT   SIG_UART1_RECV
- #define UART0_TRANSMIT_INTERRUPT  SIG_UART0_DATA
- #define UART1_TRANSMIT_INTERRUPT  SIG_UART1_DATA
- #define UART0_STATUS   UCSR0A
- #define UART0_CONTROL  UCSR0B
- #define UART0_DATA     UDR0
- #define UART0_UDRIE    UDRIE0
- #define UART1_STATUS   UCSR1A
- #define UART1_CONTROL  UCSR1B
- #define UART1_DATA     UDR1
- #define UART1_UDRIE    UDRIE1
-#elif defined(__AVR_ATmega161__)
- /* ATmega with UART */
- #error "AVR ATmega161 currently not supported by this libaray !"
-#elif defined(__AVR_ATmega169__) 
- /* ATmega with one USART */
- #define ATMEGA_USART
- #define UART0_RECEIVE_INTERRUPT   SIG_USART_RECV
- #define UART0_TRANSMIT_INTERRUPT  SIG_USART_DATA
- #define UART0_STATUS   UCSRA
- #define UART0_CONTROL  UCSRB
- #define UART0_DATA     UDR
- #define UART0_UDRIE    UDRIE
-#elif defined(__AVR_ATmega48__) ||defined(__AVR_ATmega88__) || defined(__AVR_ATmega168__) || defined(__AVR_ATmega48P__) || defined(__AVR_ATmega88P__) || defined(__AVR_ATmega168P__) || defined(__AVR_ATmega328P__)
- /* ATmega with one USART */
- #define ATMEGA_USART0
- #define UART0_RECEIVE_INTERRUPT   SIG_USART_RECV
- #define UART0_TRANSMIT_INTERRUPT  SIG_USART_DATA
- #define UART0_STATUS   UCSR0A
- #define UART0_CONTROL  UCSR0B
- #define UART0_DATA     UDR0
- #define UART0_UDRIE    UDRIE0
-#elif defined(__AVR_ATtiny2313__)
- #define ATMEGA_USART
- #define UART0_RECEIVE_INTERRUPT   SIG_USART0_RX 
- #define UART0_TRANSMIT_INTERRUPT  SIG_USART0_UDRE
- #define UART0_STATUS   UCSRA
- #define UART0_CONTROL  UCSRB
- #define UART0_DATA     UDR
- #define UART0_UDRIE    UDRIE
-#elif defined(__AVR_ATmega329__) ||defined(__AVR_ATmega3290__) ||\
-      defined(__AVR_ATmega649__) ||defined(__AVR_ATmega6490__) ||\
-      defined(__AVR_ATmega325__) ||defined(__AVR_ATmega3250__) ||\
-      defined(__AVR_ATmega645__) ||defined(__AVR_ATmega6450__)
-  /* ATmega with one USART */
-  #define ATMEGA_USART0
-  #define UART0_RECEIVE_INTERRUPT   SIG_UART_RECV
-  #define UART0_TRANSMIT_INTERRUPT  SIG_UART_DATA
-  #define UART0_STATUS   UCSR0A
-  #define UART0_CONTROL  UCSR0B
-  #define UART0_DATA     UDR0
-  #define UART0_UDRIE    UDRIE0
-#elif defined(__AVR_ATmega2560__) || defined(__AVR_ATmega2561__) || defined(__AVR_ATmega1280__)  || defined(__AVR_ATmega1281__) || defined(__AVR_ATmega640__)
-/* ATmega with two USART */
-  #define ATMEGA_USART0
-  #define ATMEGA_USART1
-  #define UART0_RECEIVE_INTERRUPT   SIG_USART0_RECV
-  #define UART1_RECEIVE_INTERRUPT   SIG_USART1_RECV
-  #define UART0_TRANSMIT_INTERRUPT  SIG_USART0_DATA
-  #define UART1_TRANSMIT_INTERRUPT  SIG_USART1_DATA
-  #define UART0_STATUS   UCSR0A
-  #define UART0_CONTROL  UCSR0B
-  #define UART0_DATA     UDR0
-  #define UART0_UDRIE    UDRIE0
-  #define UART1_STATUS   UCSR1A
-  #define UART1_CONTROL  UCSR1B
-  #define UART1_DATA     UDR1
-  #define UART1_UDRIE    UDRIE1  
-#elif defined(__AVR_ATmega644__)
- /* ATmega with one USART */
- #define ATMEGA_USART0
- #define UART0_RECEIVE_INTERRUPT   SIG_USART_RECV
- #define UART0_TRANSMIT_INTERRUPT  SIG_USART_DATA
- #define UART0_STATUS   UCSR0A
- #define UART0_CONTROL  UCSR0B
- #define UART0_DATA     UDR0
- #define UART0_UDRIE    UDRIE0
-#elif defined(__AVR_ATmega164P__) || defined(__AVR_ATmega324P__) || defined(__AVR_ATmega644P__)
- /* ATmega with two USART */
- #define ATMEGA_USART0
- #define ATMEGA_USART1
- #define UART0_RECEIVE_INTERRUPT   SIG_USART_RECV
- #define UART1_RECEIVE_INTERRUPT   SIG_USART1_RECV
- #define UART0_TRANSMIT_INTERRUPT  SIG_USART_DATA
- #define UART1_TRANSMIT_INTERRUPT  SIG_USART1_DATA
- #define UART0_STATUS   UCSR0A
- #define UART0_CONTROL  UCSR0B
- #define UART0_DATA     UDR0
- #define UART0_UDRIE    UDRIE0
- #define UART1_STATUS   UCSR1A
- #define UART1_CONTROL  UCSR1B
- #define UART1_DATA     UDR1
- #define UART1_UDRIE    UDRIE1
-#else
- #error "no UART definition for MCU available"
-#endif
-
-
-/*
- *  module global variables
- */
-static volatile unsigned char UART_TxBuf[UART_TX_BUFFER_SIZE];
-static volatile unsigned char UART_RxBuf[UART_RX_BUFFER_SIZE];
-static volatile unsigned char UART_TxHead;
-static volatile unsigned char UART_TxTail;
-static volatile unsigned char UART_RxHead;
-static volatile unsigned char UART_RxTail;
-static volatile unsigned char UART_LastRxError;
-
-#if defined( ATMEGA_USART1 )
-static volatile unsigned char UART1_TxBuf[UART_TX_BUFFER_SIZE];
-static volatile unsigned char UART1_RxBuf[UART_RX_BUFFER_SIZE];
-static volatile unsigned char UART1_TxHead;
-static volatile unsigned char UART1_TxTail;
-static volatile unsigned char UART1_RxHead;
-static volatile unsigned char UART1_RxTail;
-static volatile unsigned char UART1_LastRxError;
-#endif
-
-
-
-SIGNAL(UART0_RECEIVE_INTERRUPT)
-/*************************************************************************
-Function: UART Receive Complete interrupt
-Purpose:  called when the UART has received a character
-**************************************************************************/
-{
-    unsigned char tmphead;
-    unsigned char data;
-    unsigned char usr;
-    unsigned char lastRxError;
- 
- 
-    /* read UART status register and UART data register */ 
-    usr  = UART0_STATUS;
-    data = UART0_DATA;
-    
-    /* */
-#if defined( AT90_UART )
-    lastRxError = (usr & (_BV(FE)|_BV(DOR)) );
-#elif defined( ATMEGA_USART )
-    lastRxError = (usr & (_BV(FE)|_BV(DOR)) );
-#elif defined( ATMEGA_USART0 )
-    lastRxError = (usr & (_BV(FE0)|_BV(DOR0)) );
-#elif defined ( ATMEGA_UART )
-    lastRxError = (usr & (_BV(FE)|_BV(DOR)) );
-#endif
-        
-    /* calculate buffer index */ 
-    tmphead = ( UART_RxHead + 1) & UART_RX_BUFFER_MASK;
-    
-    if ( tmphead == UART_RxTail ) {
-        /* error: receive buffer overflow */
-        lastRxError = UART_BUFFER_OVERFLOW >> 8;
-    }else{
-        /* store new index */
-        UART_RxHead = tmphead;
-        /* store received data in buffer */
-        UART_RxBuf[tmphead] = data;
-    }
-    UART_LastRxError = lastRxError;   
-}
-
-
-SIGNAL(UART0_TRANSMIT_INTERRUPT)
-/*************************************************************************
-Function: UART Data Register Empty interrupt
-Purpose:  called when the UART is ready to transmit the next byte
-**************************************************************************/
-{
-    unsigned char tmptail;
-
-    
-    if ( UART_TxHead != UART_TxTail) {
-        /* calculate and store new buffer index */
-        tmptail = (UART_TxTail + 1) & UART_TX_BUFFER_MASK;
-        UART_TxTail = tmptail;
-        /* get one byte from buffer and write it to UART */
-        UART0_DATA = UART_TxBuf[tmptail];  /* start transmission */
-    }else{
-        /* tx buffer empty, disable UDRE interrupt */
-        UART0_CONTROL &= ~_BV(UART0_UDRIE);
-    }
-}
-
-
-/*************************************************************************
-Function: uart_init()
-Purpose:  initialize UART and set baudrate
-Input:    baudrate using macro UART_BAUD_SELECT()
-Returns:  none
-**************************************************************************/
-void uart_init(unsigned int baudrate)
-{
-    UART_TxHead = 0;
-    UART_TxTail = 0;
-    UART_RxHead = 0;
-    UART_RxTail = 0;
-    
-#if defined( AT90_UART )
-    /* set baud rate */
-    UBRR = (unsigned char)baudrate; 
-
-    /* enable UART receiver and transmmitter and receive complete interrupt */
-    UART0_CONTROL = _BV(RXCIE)|_BV(RXEN)|_BV(TXEN);
-
-#elif defined (ATMEGA_USART)
-    /* Set baud rate */
-    if ( baudrate & 0x8000 )
-    {
-    	 UART0_STATUS = (1<<U2X);  //Enable 2x speed 
-    	 baudrate &= ~0x8000;
-    }
-    UBRRH = (unsigned char)(baudrate>>8);
-    UBRRL = (unsigned char) baudrate;
-   
-    /* Enable USART receiver and transmitter and receive complete interrupt */
-    UART0_CONTROL = _BV(RXCIE)|(1<<RXEN)|(1<<TXEN);
-    
-    /* Set frame format: asynchronous, 8data, no parity, 1stop bit */
-    #ifdef URSEL
-    UCSRC = (1<<URSEL)|(3<<UCSZ0);
-    #else
-    UCSRC = (3<<UCSZ0);
-    #endif 
-    
-#elif defined (ATMEGA_USART0 )
-    /* Set baud rate */
-    if ( baudrate & 0x8000 ) 
-    {
-   		UART0_STATUS = (1<<U2X0);  //Enable 2x speed 
-   		baudrate &= ~0x8000;
-   	}
-    UBRR0H = (unsigned char)(baudrate>>8);
-    UBRR0L = (unsigned char) baudrate;
-
-    /* Enable USART receiver and transmitter and receive complete interrupt */
-    UART0_CONTROL = _BV(RXCIE0)|(1<<RXEN0)|(1<<TXEN0);
-    
-    /* Set frame format: asynchronous, 8data, no parity, 1stop bit */
-    #ifdef URSEL0
-    UCSR0C = (1<<URSEL0)|(3<<UCSZ00);
-    #else
-    UCSR0C = (3<<UCSZ00);
-    #endif 
-
-#elif defined ( ATMEGA_UART )
-    /* set baud rate */
-    if ( baudrate & 0x8000 ) 
-    {
-    	UART0_STATUS = (1<<U2X);  //Enable 2x speed 
-    	baudrate &= ~0x8000;
-    }
-    UBRRHI = (unsigned char)(baudrate>>8);
-    UBRR   = (unsigned char) baudrate;
-
-    /* Enable UART receiver and transmitter and receive complete interrupt */
-    UART0_CONTROL = _BV(RXCIE)|(1<<RXEN)|(1<<TXEN);
-
-#endif
-
-}/* uart_init */
-
-
-/*************************************************************************
-Function: uart_getc()
-Purpose:  return byte from ringbuffer  
-Returns:  lower byte:  received byte from ringbuffer
-          higher byte: last receive error
-**************************************************************************/
-unsigned int uart_getc(void)
-{    
-    unsigned char tmptail;
-    unsigned char data;
-
-
-    if ( UART_RxHead == UART_RxTail ) {
-        return UART_NO_DATA;   /* no data available */
-    }
-    
-    /* calculate /store buffer index */
-    tmptail = (UART_RxTail + 1) & UART_RX_BUFFER_MASK;
-    UART_RxTail = tmptail; 
-    
-    /* get data from receive buffer */
-    data = UART_RxBuf[tmptail];
-    
-    return (UART_LastRxError << 8) + data;
-
-}/* uart_getc */
-
-
-/*************************************************************************
-Function: uart_putc()
-Purpose:  write byte to ringbuffer for transmitting via UART
-Input:    byte to be transmitted
-Returns:  none          
-**************************************************************************/
-void uart_putc(unsigned char data)
-{
-    unsigned char tmphead;
-
-    
-    tmphead  = (UART_TxHead + 1) & UART_TX_BUFFER_MASK;
-    
-    while ( tmphead == UART_TxTail ){
-        ;/* wait for free space in buffer */
-    }
-    
-    UART_TxBuf[tmphead] = data;
-    UART_TxHead = tmphead;
-
-    /* enable UDRE interrupt */
-    UART0_CONTROL    |= _BV(UART0_UDRIE);
-
-}/* uart_putc */
-
-
-/*************************************************************************
-Function: uart_puts()
-Purpose:  transmit string to UART
-Input:    string to be transmitted
-Returns:  none          
-**************************************************************************/
-void uart_puts(const char *s )
-{
-    while (*s) 
-      uart_putc(*s++);
-
-}/* uart_puts */
-
-
-/*************************************************************************
-Function: uart_puts_p()
-Purpose:  transmit string from program memory to UART
-Input:    program memory string to be transmitted
-Returns:  none
-**************************************************************************/
-void uart_puts_p(const char *progmem_s )
-{
-    register char c;
-    
-    while ( (c = pgm_read_byte(progmem_s++)) ) 
-      uart_putc(c);
-
-}/* uart_puts_p */
-
-
-/*
- * these functions are only for ATmegas with two USART
- */
-#if defined( ATMEGA_USART1 )
-
-SIGNAL(UART1_RECEIVE_INTERRUPT)
-/*************************************************************************
-Function: UART1 Receive Complete interrupt
-Purpose:  called when the UART1 has received a character
-**************************************************************************/
-{
-    unsigned char tmphead;
-    unsigned char data;
-    unsigned char usr;
-    unsigned char lastRxError;
- 
- 
-    /* read UART status register and UART data register */ 
-    usr  = UART1_STATUS;
-    data = UART1_DATA;
-    
-    /* */
-    lastRxError = (usr & (_BV(FE1)|_BV(DOR1)) );
-        
-    /* calculate buffer index */ 
-    tmphead = ( UART1_RxHead + 1) & UART_RX_BUFFER_MASK;
-    
-    if ( tmphead == UART1_RxTail ) {
-        /* error: receive buffer overflow */
-        lastRxError = UART_BUFFER_OVERFLOW >> 8;
-    }else{
-        /* store new index */
-        UART1_RxHead = tmphead;
-        /* store received data in buffer */
-        UART1_RxBuf[tmphead] = data;
-    }
-    UART1_LastRxError = lastRxError;   
-}
-
-
-SIGNAL(UART1_TRANSMIT_INTERRUPT)
-/*************************************************************************
-Function: UART1 Data Register Empty interrupt
-Purpose:  called when the UART1 is ready to transmit the next byte
-**************************************************************************/
-{
-    unsigned char tmptail;
-
-    
-    if ( UART1_TxHead != UART1_TxTail) {
-        /* calculate and store new buffer index */
-        tmptail = (UART1_TxTail + 1) & UART_TX_BUFFER_MASK;
-        UART1_TxTail = tmptail;
-        /* get one byte from buffer and write it to UART */
-        UART1_DATA = UART1_TxBuf[tmptail];  /* start transmission */
-    }else{
-        /* tx buffer empty, disable UDRE interrupt */
-        UART1_CONTROL &= ~_BV(UART1_UDRIE);
-    }
-}
-
-
-/*************************************************************************
-Function: uart1_init()
-Purpose:  initialize UART1 and set baudrate
-Input:    baudrate using macro UART_BAUD_SELECT()
-Returns:  none
-**************************************************************************/
-void uart1_init(unsigned int baudrate)
-{
-    UART1_TxHead = 0;
-    UART1_TxTail = 0;
-    UART1_RxHead = 0;
-    UART1_RxTail = 0;
-    
-
-    /* Set baud rate */
-    if ( baudrate & 0x8000 ) 
-    {
-    	UART1_STATUS = (1<<U2X1);  //Enable 2x speed 
-      baudrate &= ~0x8000;
-    }
-    UBRR1H = (unsigned char)(baudrate>>8);
-    UBRR1L = (unsigned char) baudrate;
-
-    /* Enable USART receiver and transmitter and receive complete interrupt */
-    UART1_CONTROL = _BV(RXCIE1)|(1<<RXEN1)|(1<<TXEN1);
-    
-    /* Set frame format: asynchronous, 8data, no parity, 1stop bit */   
-    #ifdef URSEL1
-    UCSR1C = (1<<URSEL1)|(3<<UCSZ10);
-    #else
-    UCSR1C = (3<<UCSZ10);
-    #endif 
-}/* uart_init */
-
-
-/*************************************************************************
-Function: uart1_getc()
-Purpose:  return byte from ringbuffer  
-Returns:  lower byte:  received byte from ringbuffer
-          higher byte: last receive error
-**************************************************************************/
-unsigned int uart1_getc(void)
-{    
-    unsigned char tmptail;
-    unsigned char data;
-
-
-    if ( UART1_RxHead == UART1_RxTail ) {
-        return UART_NO_DATA;   /* no data available */
-    }
-    
-    /* calculate /store buffer index */
-    tmptail = (UART1_RxTail + 1) & UART_RX_BUFFER_MASK;
-    UART1_RxTail = tmptail; 
-    
-    /* get data from receive buffer */
-    data = UART1_RxBuf[tmptail];
-    
-    return (UART1_LastRxError << 8) + data;
-
-}/* uart1_getc */
-
-
-/*************************************************************************
-Function: uart1_putc()
-Purpose:  write byte to ringbuffer for transmitting via UART
-Input:    byte to be transmitted
-Returns:  none          
-**************************************************************************/
-void uart1_putc(unsigned char data)
-{
-    unsigned char tmphead;
-
-    
-    tmphead  = (UART1_TxHead + 1) & UART_TX_BUFFER_MASK;
-    
-    while ( tmphead == UART1_TxTail ){
-        ;/* wait for free space in buffer */
-    }
-    
-    UART1_TxBuf[tmphead] = data;
-    UART1_TxHead = tmphead;
-
-    /* enable UDRE interrupt */
-    UART1_CONTROL    |= _BV(UART1_UDRIE);
-
-}/* uart1_putc */
-
-
-/*************************************************************************
-Function: uart1_puts()
-Purpose:  transmit string to UART1
-Input:    string to be transmitted
-Returns:  none          
-**************************************************************************/
-void uart1_puts(const char *s )
-{
-    while (*s) 
-      uart1_putc(*s++);
-
-}/* uart1_puts */
-
-
-/*************************************************************************
-Function: uart1_puts_p()
-Purpose:  transmit string from program memory to UART1
-Input:    program memory string to be transmitted
-Returns:  none
-**************************************************************************/
-void uart1_puts_p(const char *progmem_s )
-{
-    register char c;
-    
-    while ( (c = pgm_read_byte(progmem_s++)) ) 
-      uart1_putc(c);
-
-}/* uart1_puts_p */
-
-
-#endif

CubeFirmware/uart.h

-#ifndef UART_H
-#define UART_H
-/************************************************************************
-Title:    Interrupt UART library with receive/transmit circular buffers
-Author:   Peter Fleury <pfleury@gmx.ch>   http://jump.to/fleury
-File:     $Id: uart.h,v 1.8.2.1 2007/07/01 11:14:38 peter Exp $
-Software: AVR-GCC 4.1, AVR Libc 1.4
-Hardware: any AVR with built-in UART, tested on AT90S8515 & ATmega8 at 4 Mhz
-License:  GNU General Public License 
-Usage:    see Doxygen manual
-
-LICENSE:
-    Copyright (C) 2006 Peter Fleury
-
-    This program 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 2 of the License, or
-    any later version.
-
-    This program 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.
-    
-************************************************************************/
-
-/** 
- *  @defgroup pfleury_uart UART Library
- *  @code #include <uart.h> @endcode
- * 
- *  @brief Interrupt UART library using the built-in UART with transmit and receive circular buffers. 
- *
- *  This library can be used to transmit and receive data through the built in UART. 
- *
- *  An interrupt is generated when the UART has finished transmitting or
- *  receiving a byte. The interrupt handling routines use circular buffers
- *  for buffering received and transmitted data.
- *
- *  The UART_RX_BUFFER_SIZE and UART_TX_BUFFER_SIZE constants define
- *  the size of the circular buffers in bytes. Note that these constants must be a power of 2.
- *  You may need to adapt this constants to your target and your application by adding 
- *  CDEFS += -DUART_RX_BUFFER_SIZE=nn -DUART_RX_BUFFER_SIZE=nn to your Makefile.
- *
- *  @note Based on Atmel Application Note AVR306
- *  @author Peter Fleury pfleury@gmx.ch  http://jump.to/fleury
- */
- 
-/**@{*/
-
-
-#if (__GNUC__ * 100 + __GNUC_MINOR__) < 304
-#error "This library requires AVR-GCC 3.4 or later, update to newer AVR-GCC compiler !"
-#endif
-
-
-/*
-** constants and macros
-*/
-
-/** @brief  UART Baudrate Expression
- *  @param  xtalcpu  system clock in Mhz, e.g. 4000000L for 4Mhz          
- *  @param  baudrate baudrate in bps, e.g. 1200, 2400, 9600     
- */
-#define UART_BAUD_SELECT(baudRate,xtalCpu) ((xtalCpu)/((baudRate)*16l)-1)
-
-/** @brief  UART Baudrate Expression for ATmega double speed mode
- *  @param  xtalcpu  system clock in Mhz, e.g. 4000000L for 4Mhz           
- *  @param  baudrate baudrate in bps, e.g. 1200, 2400, 9600     
- */
-#define UART_BAUD_SELECT_DOUBLE_SPEED(baudRate,xtalCpu) (((xtalCpu)/((baudRate)*8l)-1)|0x8000)
-
-
-/** Size of the circular receive buffer, must be power of 2 */
-#ifndef UART_RX_BUFFER_SIZE
-#define UART_RX_BUFFER_SIZE 32
-#endif
-/** Size of the circular transmit buffer, must be power of 2 */
-#ifndef UART_TX_BUFFER_SIZE
-#define UART_TX_BUFFER_SIZE 32
-#endif
-
-/* test if the size of the circular buffers fits into SRAM */
-#if ( (UART_RX_BUFFER_SIZE+UART_TX_BUFFER_SIZE) >= (RAMEND-0x60 ) )
-#error "size of UART_RX_BUFFER_SIZE + UART_TX_BUFFER_SIZE larger than size of SRAM"
-#endif
-
-/* 
-** high byte error return code of uart_getc()
-*/
-#define UART_FRAME_ERROR      0x0800              /* Framing Error by UART       */
-#define UART_OVERRUN_ERROR    0x0400              /* Overrun condition by UART   */
-#define UART_BUFFER_OVERFLOW  0x0200              /* receive ringbuffer overflow */
-#define UART_NO_DATA          0x0100              /* no receive data available   */
-
-
-/*
-** function prototypes
-*/
-
-/**
-   @brief   Initialize UART and set baudrate 
-   @param   baudrate Specify baudrate using macro UART_BAUD_SELECT()
-   @return  none
-*/
-extern void uart_init(unsigned int baudrate);
-
-
-/**
- *  @brief   Get received byte from ringbuffer
- *
- * Returns in the lower byte the received character and in the 
- * higher byte the last receive error.
- * UART_NO_DATA is returned when no data is available.
- *
- *  @param   void
- *  @return  lower byte:  received byte from ringbuffer
- *  @return  higher byte: last receive status
- *           - \b 0 successfully received data from UART
- *           - \b UART_NO_DATA           
- *             <br>no receive data available
- *           - \b UART_BUFFER_OVERFLOW   
- *             <br>Receive ringbuffer overflow.
- *             We are not reading the receive buffer fast enough, 
- *             one or more received character have been dropped 
- *           - \b UART_OVERRUN_ERROR     
- *             <br>Overrun condition by UART.
- *             A character already present in the UART UDR register was 
- *             not read by the interrupt handler before the next character arrived,
- *             one or more received characters have been dropped.
- *           - \b UART_FRAME_ERROR       
- *             <br>Framing Error by UART
- */
-extern unsigned int uart_getc(void);
-
-
-/**
- *  @brief   Put byte to ringbuffer for transmitting via UART
- *  @param   data byte to be transmitted
- *  @return  none
- */
-extern void uart_putc(unsigned char data);
-
-
-/**
- *  @brief   Put string to ringbuffer for transmitting via UART
- *
- *  The string is buffered by the uart library in a circular buffer
- *  and one character at a time is transmitted to the UART using interrupts.
- *  Blocks if it can not write the whole string into the circular buffer.
- * 
- *  @param   s string to be transmitted
- *  @return  none
- */
-extern void uart_puts(const char *s );
-
-
-/**
- * @brief    Put string from program memory to ringbuffer for transmitting via UART.
- *
- * The string is buffered by the uart library in a circular buffer
- * and one character at a time is transmitted to the UART using interrupts.
- * Blocks if it can not write the whole string into the circular buffer.
- *
- * @param    s program memory string to be transmitted
- * @return   none
- * @see      uart_puts_P
- */
-extern void uart_puts_p(const char *s );
-
-/**
- * @brief    Macro to automatically put a string constant into program memory
- */
-#define uart_puts_P(__s)       uart_puts_p(PSTR(__s))
-
-
-
-/** @brief  Initialize USART1 (only available on selected ATmegas) @see uart_init */
-extern void uart1_init(unsigned int baudrate);
-/** @brief  Get received byte of USART1 from ringbuffer. (only available on selected ATmega) @see uart_getc */
-extern unsigned int uart1_getc(void);
-/** @brief  Put byte to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_putc */
-extern void uart1_putc(unsigned char data);
-/** @brief  Put string to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_puts */
-extern void uart1_puts(const char *s );
-/** @brief  Put string from program memory to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_puts_p */
-extern void uart1_puts_p(const char *s );
-/** @brief  Macro to automatically put a string constant into program memory */
-#define uart1_puts_P(__s)       uart1_puts_p(PSTR(__s))
-
-/**@}*/
-
-
-#endif // UART_H 
-

README.md

 
 ## Firmware
 
-The firmware of the Controller is yet to be developed...
-It will use [Peter Fleury's UART and TWI Library](http://homepage.hispeed.ch/peterfleury/avr-software.html).
+The firmware of the Controller is yet to be tested...
+It uses [Peter Fleury's TWI Library](http://homepage.hispeed.ch/peterfleury/avr-software.html).
 
 ## Cube Control