Restructure lib, add uart

13 files changed, 2043 insertions, 20 deletions

diff --git a/sw/Makefile b/sw/Makefile
index 393725f..152caaa 100644
--- a/sw/Makefile
+++ b/sw/Makefile
@@ -10,8 +10,8 @@ AVRDUDE_DEV=usb
 PROG = dragon_isp
 
 # Modify this to the CPU you are using
-PART=atmega328
-AVRDUDE_PART=m328
+PART=atmega328p
+AVRDUDE_PART=m328p
 
 # Cpu frequency is 16MHz, divider = 8
 F_CPU="(16000000UL/8)"
@@ -27,7 +27,7 @@ APP_CXX_OBJECTS = main.o
 APP_OBJECTS =
 
 # Library object files to build and use
-LIB_OBJECTS =
+LIB_OBJECTS = uart/uart.o
 LIB_CXX_OBJECTS =
 LIB_ASM_OBJECTS =
 LIB_DIR = lib
@@ -46,8 +46,10 @@ vpath %.elf ./$(BUILD_DIR)
 vpath %.hex ./$(BUILD_DIR)
 
 # GCC flags
-CFLAGS=-g -mmcu=$(PART) -O1 -Wall -Werror -DF_CPU=$(F_CPU)
-CXXFLAGS=$(CFLAGS) -std=c++11
+DEFINES=-DUART_RX0_BUFFER_SIZE=64 -DUART_TX0_BUFFER_SIZE=64
+FLAGS=-g -mmcu=$(PART) -Os -Wall -Werror -DF_CPU=$(F_CPU) $(DEFINES)
+CFLAGS=$(FLAGS) -std=c99
+CXXFLAGS=$(FLAGS) -std=c++11
 INCLUDES=-I. -I$(LIB_DIR)
 
 
diff --git a/sw/README.rst b/sw/README.rst
index 7b890a4..eb5196d 100644
--- a/sw/README.rst
+++ b/sw/README.rst
@@ -9,6 +9,21 @@ Au démarrage, avant de passer à la mesure régulière, le code doit:
   - Attention au risque de problemes après 100000 écritures
   - Faire une vérification lecture après écriture et communiquer le problème
 - Mettre en place un watchdog
+- Initialiser UART (uniquement TX, on verra si on a besoin du RX plus tard)
+
+Protocole du port série:
+
+Chaque message commence par un identificateur, suivi d'une virgule, du temps en
+secondes, une virgule, un champ de données, et termine par CR LF.
+
++--------------------+-----------------------------------+
+| Identificateur     | Contenu du champ                  |
++--------------------+-----------------------------------+
+| `TEXT`             | Un message informatif             |
+| `ERROR`            | Erreur ou avertissement           |
++--------------------+-----------------------------------+
+
+Par exemple: `TEXT,12,Startup\r\n`
 
 TODO
 ----
@@ -17,8 +32,6 @@ TODO
 - Configurer SPI pour LTC2400
 - Initialiser entrées analogiques
 - Initialiser DS18B20
-- Initialiser UART (uniquement TX, on verra si on a besoin du RX plus tard)
-  - Décider quel protocole utiliser sur le port série
 
 
 Reglages eFuse
diff --git a/sw/lib/DallasTemperature/DallasTemperature.cpp b/sw/lib/DallasTemperature.cpp
index a1107ec..a1107ec 100644
--- a/sw/lib/DallasTemperature/DallasTemperature.cpp
+++ b/sw/lib/DallasTemperature.cpp
diff --git a/sw/lib/DallasTemperature/DallasTemperature.h b/sw/lib/DallasTemperature.h
index 49a059d..49a059d 100644
--- a/sw/lib/DallasTemperature/DallasTemperature.h
+++ b/sw/lib/DallasTemperature.h
diff --git a/sw/lib/LTC2400/LTC24XX_general.cpp b/sw/lib/LTC24XX_general.cpp
index 615edff..615edff 100644
--- a/sw/lib/LTC2400/LTC24XX_general.cpp
+++ b/sw/lib/LTC24XX_general.cpp
diff --git a/sw/lib/LTC2400/LTC24XX_general.h b/sw/lib/LTC24XX_general.h
index 42fd65a..42fd65a 100644
--- a/sw/lib/LTC2400/LTC24XX_general.h
+++ b/sw/lib/LTC24XX_general.h
diff --git a/sw/lib/OneWire/OneWire.cpp b/sw/lib/OneWire.cpp
index 38bf4ee..38bf4ee 100644
--- a/sw/lib/OneWire/OneWire.cpp
+++ b/sw/lib/OneWire.cpp
diff --git a/sw/lib/OneWire/OneWire.h b/sw/lib/OneWire.h
index a7bfab7..a7bfab7 100644
--- a/sw/lib/OneWire/OneWire.h
+++ b/sw/lib/OneWire.h
diff --git a/sw/lib/uart.c b/sw/lib/uart.c
new file mode 100644
index 0000000..d87bd54
--- /dev/null
+++ b/sw/lib/uart.c
@@ -0,0 +1,1522 @@
+/*************************************************************************
+
+	Title:    Interrupt UART library with receive/transmit circular buffers
+	Author:   Andy Gock
+	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 README.md and Doxygen manual
+
+	Based on original library by Peter Fluery, Tim Sharpe, Nicholas Zambetti.
+
+	https://github.com/andygock/avr-uart
+
+	Updated UART library (this one) by Andy Gock
+	https://github.com/andygock/avr-uart
+
+	Based on updated UART library (this one) by Tim Sharpe
+	http://beaststwo.org/avr-uart/index.shtml
+
+	Based on original library by Peter Fluery
+	http://homepage.hispeed.ch/peterfleury/avr-software.html
+
+*************************************************************************/
+
+/*************************************************************************
+
+LICENSE:
+	Copyright (C) 2012 Andy Gock
+	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.
+
+*************************************************************************/
+
+/************************************************************************
+uart_available, uart_flush, uart1_available, and uart1_flush functions
+were adapted from the Arduino HardwareSerial.h library by Tim Sharpe on
+11 Jan 2009.  The license info for HardwareSerial.h is as follows:
+
+  HardwareSerial.cpp - Hardware serial library for Wiring
+  Copyright (c) 2006 Nicholas Zambetti.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library 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
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+  Modified 23 November 2006 by David A. Mellis
+************************************************************************/
+
+/************************************************************************
+Changelog for modifications made by Tim Sharpe, starting with the current
+  library version on his Web site as of 05/01/2009.
+
+Date        Description
+=========================================================================
+05/11/2009  Changed all existing UARTx_RECEIVE_INTERRUPT and UARTx_TRANSMIT_INTERRUPT
+			macros to use the "_vect" format introduced in AVR-Libc
+			v1.4.0.  Had to split the 3290 and 6490 out of their existing
+			macro due to an inconsistency in the UART0_RECEIVE_INTERRUPT
+			vector name (seems like a typo: USART_RX_vect for the 3290/6490
+			vice USART0_RX_vect for the others in the macro).
+			Verified all existing macro register names against the device
+			header files in AVR-Libc v1.6.6 to catch any inconsistencies.
+05/12/2009  Added support for 48P, 88P, 168P, and 328P by adding them to the
+			existing 48/88/168 macro.
+			Added Arduino-style available() and flush() functions for both
+			supported UARTs.  Really wanted to keep them out of the library, so
+			that it would be as close as possible to Peter Fleury's original
+			library, but has scoping issues accessing internal variables from
+			another program.  Go C!
+05/13/2009  Changed Interrupt Service Routine label from the old "SIGNAL" to
+			the "ISR" format introduced in AVR-Libc v1.4.0.
+
+************************************************************************/
+
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/pgmspace.h>
+#include <util/atomic.h>
+#include "uart.h"
+
+/*
+ *  constants and macros
+ */
+
+/* size of RX/TX buffers */
+#define UART_RX0_BUFFER_MASK (UART_RX0_BUFFER_SIZE - 1)
+#define UART_RX1_BUFFER_MASK (UART_RX1_BUFFER_SIZE - 1)
+#define UART_RX2_BUFFER_MASK (UART_RX2_BUFFER_SIZE - 1)
+#define UART_RX3_BUFFER_MASK (UART_RX3_BUFFER_SIZE - 1)
+
+#define UART_TX0_BUFFER_MASK (UART_TX0_BUFFER_SIZE - 1)
+#define UART_TX1_BUFFER_MASK (UART_TX1_BUFFER_SIZE - 1)
+#define UART_TX2_BUFFER_MASK (UART_TX2_BUFFER_SIZE - 1)
+#define UART_TX3_BUFFER_MASK (UART_TX3_BUFFER_SIZE - 1)
+
+#if (UART_RX0_BUFFER_SIZE & UART_RX0_BUFFER_MASK)
+	#error RX0 buffer size is not a power of 2
+#endif
+#if (UART_TX0_BUFFER_SIZE & UART_TX0_BUFFER_MASK)
+	#error TX0 buffer size is not a power of 2
+#endif
+
+#if (UART_RX1_BUFFER_SIZE & UART_RX1_BUFFER_MASK)
+	#error RX1 buffer size is not a power of 2
+#endif
+#if (UART_TX1_BUFFER_SIZE & UART_TX1_BUFFER_MASK)
+	#error TX1 buffer size is not a power of 2
+#endif
+
+#if (UART_RX2_BUFFER_SIZE & UART_RX2_BUFFER_MASK)
+	#error RX2 buffer size is not a power of 2
+#endif
+#if (UART_TX2_BUFFER_SIZE & UART_TX2_BUFFER_MASK)
+	#error TX2 buffer size is not a power of 2
+#endif
+
+#if (UART_RX3_BUFFER_SIZE & UART_RX3_BUFFER_MASK)
+	#error RX3 buffer size is not a power of 2
+#endif
+#if (UART_TX3_BUFFER_SIZE & UART_TX3_BUFFER_MASK)
+	#error TX3 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   UART_RX_vect
+	#define UART0_TRANSMIT_INTERRUPT  UART_UDRE_vect
+	#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   UART_RX_vect
+	#define UART0_TRANSMIT_INTERRUPT  UART_UDRE_vect
+	#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_ATmega323__)
+	/* ATmega with one USART */
+	#define ATMEGA_USART
+	#define UART0_RECEIVE_INTERRUPT   USART_RXC_vect
+	#define UART0_TRANSMIT_INTERRUPT  USART_UDRE_vect
+	#define UART0_STATUS   UCSRA
+	#define UART0_CONTROL  UCSRB
+	#define UART0_DATA     UDR
+	#define UART0_UDRIE    UDRIE
+#elif defined(__AVR_ATmega8U2__) || defined(__AVR_ATmega16U2__) || defined(__AVR_ATmega16U4__) || \
+      defined(__AVR_ATmega32U2__) || defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega32U6__)
+	/* ATmega with one USART, but is called USART1 (untested) */
+	#define ATMEGA_USART1
+	#define UART1_RECEIVE_INTERRUPT   USART1_RX_vect
+	#define UART1_TRANSMIT_INTERRUPT  USART1_UDRE_vect
+	#define UART1_STATUS   UCSR1A
+	#define UART1_CONTROL  UCSR1B
+	#define UART1_DATA     UDR1
+	#define UART1_UDRIE    UDRIE1
+#elif  defined(__AVR_ATmega8515__) || defined(__AVR_ATmega8535__)
+	/* ATmega with one USART */
+	#define ATMEGA_USART
+	#define UART0_RECEIVE_INTERRUPT   USART_RX_vect
+	#define UART0_TRANSMIT_INTERRUPT  USART_UDRE_vect
+	#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   UART_RX_vect
+	#define UART0_TRANSMIT_INTERRUPT  UART_UDRE_vect
+	#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   USART0_RXC_vect
+	#define UART1_RECEIVE_INTERRUPT   USART1_RXC_vect
+	#define UART0_TRANSMIT_INTERRUPT  USART0_UDRE_vect
+	#define UART1_TRANSMIT_INTERRUPT  USART1_UDRE_vect
+	#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   USART0_RX_vect
+	#define UART1_RECEIVE_INTERRUPT   USART1_RX_vect
+	#define UART0_TRANSMIT_INTERRUPT  USART0_UDRE_vect
+	#define UART1_TRANSMIT_INTERRUPT  USART1_UDRE_vect
+	#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   USART0_RX_vect
+	#define UART0_TRANSMIT_INTERRUPT  USART0_UDRE_vect
+	#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__) 
+	/* TLS-Added 48P/88P/168P/328P */
+	/* ATmega with one USART */
+	#define ATMEGA_USART0
+	#define UART0_RECEIVE_INTERRUPT   USART_RX_vect
+	#define UART0_TRANSMIT_INTERRUPT  USART_UDRE_vect
+	#define UART0_STATUS   UCSR0A
+	#define UART0_CONTROL  UCSR0B
+	#define UART0_DATA     UDR0
+	#define UART0_UDRIE    UDRIE0
+#elif defined(__AVR_ATtiny2313__) || defined(__AVR_ATtiny2313A__) || defined(__AVR_ATtiny4313__)
+	#define ATMEGA_USART
+	#define UART0_RECEIVE_INTERRUPT   USART_RX_vect 
+	#define UART0_TRANSMIT_INTERRUPT  USART_UDRE_vect
+	#define UART0_STATUS   UCSRA
+	#define UART0_CONTROL  UCSRB
+	#define UART0_DATA     UDR
+	#define UART0_UDRIE    UDRIE
+#elif defined(__AVR_ATmega329__) ||\
+      defined(__AVR_ATmega649__) ||\
+      defined(__AVR_ATmega325__) ||defined(__AVR_ATmega3250__) ||\
+      defined(__AVR_ATmega645__) ||defined(__AVR_ATmega6450__)
+	/* ATmega with one USART */
+	#define ATMEGA_USART0
+	#define UART0_RECEIVE_INTERRUPT   USART0_RX_vect
+	#define UART0_TRANSMIT_INTERRUPT  USART0_UDRE_vect
+	#define UART0_STATUS   UCSR0A
+	#define UART0_CONTROL  UCSR0B
+	#define UART0_DATA     UDR0
+	#define UART0_UDRIE    UDRIE0
+#elif defined(__AVR_ATmega3290__) ||\
+      defined(__AVR_ATmega6490__)
+	/* TLS-Separated these two from the previous group because of inconsistency in the USART_RX */
+	/* ATmega with one USART */
+	#define ATMEGA_USART0
+	#define UART0_RECEIVE_INTERRUPT   USART_RX_vect
+	#define UART0_TRANSMIT_INTERRUPT  USART0_UDRE_vect
+	#define UART0_STATUS   UCSR0A
+	#define UART0_CONTROL  UCSR0B
+	#define UART0_DATA     UDR0
+	#define UART0_UDRIE    UDRIE0
+#elif defined(__AVR_ATmega2560__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega640__)
+	/* ATmega with four USART */
+	#define ATMEGA_USART0
+	#define ATMEGA_USART1
+	#define ATMEGA_USART2
+	#define ATMEGA_USART3
+	#define UART0_RECEIVE_INTERRUPT   USART0_RX_vect
+	#define UART1_RECEIVE_INTERRUPT   USART1_RX_vect
+	#define UART2_RECEIVE_INTERRUPT   USART2_RX_vect
+	#define UART3_RECEIVE_INTERRUPT   USART3_RX_vect
+	#define UART0_TRANSMIT_INTERRUPT  USART0_UDRE_vect
+	#define UART1_TRANSMIT_INTERRUPT  USART1_UDRE_vect
+	#define UART2_TRANSMIT_INTERRUPT  USART2_UDRE_vect
+	#define UART3_TRANSMIT_INTERRUPT  USART3_UDRE_vect
+	#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  
+	#define UART2_STATUS   UCSR2A
+	#define UART2_CONTROL  UCSR2B
+	#define UART2_DATA     UDR2
+	#define UART2_UDRIE    UDRIE2  
+	#define UART3_STATUS   UCSR3A
+	#define UART3_CONTROL  UCSR3B
+	#define UART3_DATA     UDR3
+	#define UART3_UDRIE    UDRIE3  
+#elif defined(__AVR_ATmega644__)
+	/* ATmega with one USART */
+	#define ATMEGA_USART0
+	#define UART0_RECEIVE_INTERRUPT   USART0_RX_vect
+	#define UART0_TRANSMIT_INTERRUPT  USART0_UDRE_vect
+	#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__) || \
+      defined(__AVR_ATmega1284P__)
+	/* ATmega with two USART */
+	#define ATMEGA_USART0
+	#define ATMEGA_USART1
+	#define UART0_RECEIVE_INTERRUPT   USART0_RX_vect
+	#define UART1_RECEIVE_INTERRUPT   USART1_RX_vect
+	#define UART0_TRANSMIT_INTERRUPT  USART0_UDRE_vect
+	#define UART1_TRANSMIT_INTERRUPT  USART1_UDRE_vect
+	#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
+ */
+
+#if defined(USART0_ENABLED)
+	#if defined(ATMEGA_USART) || defined(ATMEGA_USART0)
+		static volatile uint8_t UART_TxBuf[UART_TX0_BUFFER_SIZE];
+		static volatile uint8_t UART_RxBuf[UART_RX0_BUFFER_SIZE];
+		
+		#if defined(USART0_LARGE_BUFFER)
+			static volatile uint16_t UART_TxHead;
+			static volatile uint16_t UART_TxTail;
+			static volatile uint16_t UART_RxHead;
+			static volatile uint16_t UART_RxTail;
+			static volatile uint8_t UART_LastRxError;
+		#else
+			static volatile uint8_t UART_TxHead;
+			static volatile uint8_t UART_TxTail;
+			static volatile uint8_t UART_RxHead;
+			static volatile uint8_t UART_RxTail;
+			static volatile uint8_t UART_LastRxError;
+		#endif
+		
+	#endif
+#endif
+
+#if defined(USART1_ENABLED)
+	#if defined(ATMEGA_USART1)
+		static volatile uint8_t UART1_TxBuf[UART_TX1_BUFFER_SIZE];
+		static volatile uint8_t UART1_RxBuf[UART_RX1_BUFFER_SIZE];
+		
+		#if defined(USART1_LARGE_BUFFER)
+			static volatile uint16_t UART1_TxHead;
+			static volatile uint16_t UART1_TxTail;
+			static volatile uint16_t UART1_RxHead;
+			static volatile uint16_t UART1_RxTail;
+			static volatile uint8_t UART1_LastRxError;
+		#else
+			static volatile uint8_t UART1_TxHead;
+			static volatile uint8_t UART1_TxTail;
+			static volatile uint8_t UART1_RxHead;
+			static volatile uint8_t UART1_RxTail;
+			static volatile uint8_t UART1_LastRxError;
+		#endif		
+	#endif
+#endif
+
+#if defined(USART2_ENABLED)
+	#if defined(ATMEGA_USART2)
+		static volatile uint8_t UART2_TxBuf[UART_TX2_BUFFER_SIZE];
+		static volatile uint8_t UART2_RxBuf[UART_RX2_BUFFER_SIZE];
+
+		#if defined(USART2_LARGE_BUFFER)
+			static volatile uint16_t UART2_TxHead;
+			static volatile uint16_t UART2_TxTail;
+			static volatile uint16_t UART2_RxHead;
+			static volatile uint16_t UART2_RxTail;
+			static volatile uint8_t UART2_LastRxError;
+		#else
+			static volatile uint8_t UART2_TxHead;
+			static volatile uint8_t UART2_TxTail;
+			static volatile uint8_t UART2_RxHead;
+			static volatile uint8_t UART2_RxTail;
+			static volatile uint8_t UART2_LastRxError;
+		#endif		
+	#endif
+#endif
+
+#if defined(USART3_ENABLED)
+	#if defined(ATMEGA_USART3)
+		static volatile uint8_t UART3_TxBuf[UART_TX3_BUFFER_SIZE];
+		static volatile uint8_t UART3_RxBuf[UART_RX3_BUFFER_SIZE];
+
+		#if defined(USART3_LARGE_BUFFER)
+			static volatile uint16_t UART3_TxHead;
+			static volatile uint16_t UART3_TxTail;
+			static volatile uint16_t UART3_RxHead;
+			static volatile uint16_t UART3_RxTail;
+			static volatile uint8_t UART3_LastRxError;
+		#else
+			static volatile uint8_t UART3_TxHead;
+			static volatile uint8_t UART3_TxTail;
+			static volatile uint8_t UART3_RxHead;
+			static volatile uint8_t UART3_RxTail;
+			static volatile uint8_t UART3_LastRxError;
+		#endif
+
+	#endif
+#endif
+
+#if defined(USART0_ENABLED)
+
+#if defined(AT90_UART) || defined(ATMEGA_USART) || defined(ATMEGA_USART0)
+
+ISR(UART0_RECEIVE_INTERRUPT)
+/*************************************************************************
+Function: UART Receive Complete interrupt
+Purpose:  called when the UART has received a character
+**************************************************************************/
+{
+    uint16_t tmphead;
+    uint8_t data;
+    uint8_t usr;
+    uint8_t 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_RX0_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;   
+}
+
+
+ISR(UART0_TRANSMIT_INTERRUPT)
+/*************************************************************************
+Function: UART Data Register Empty interrupt
+Purpose:  called when the UART is ready to transmit the next byte
+**************************************************************************/
+{
+    uint16_t tmptail;
+
+    if (UART_TxHead != UART_TxTail) {
+        /* calculate and store new buffer index */
+        tmptail = (UART_TxTail + 1) & UART_TX0_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: uart0_init()
+Purpose:  initialize UART and set baudrate
+Input:    baudrate using macro UART_BAUD_SELECT()
+Returns:  none
+**************************************************************************/
+void uart0_init(uint16_t baudrate)
+{
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		UART_TxHead = 0;
+		UART_TxTail = 0;
+		UART_RxHead = 0;
+		UART_RxTail = 0;
+	}
+	
+#if defined(AT90_UART)
+	/* set baud rate */
+	UBRR = (uint8_t) baudrate;
+
+	/* enable UART receiver and transmitter 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 = (uint8_t) (baudrate>>8);
+	UBRRL = (uint8_t) 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 = (uint8_t)(baudrate>>8);
+	UBRR0L = (uint8_t) 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 = (uint8_t) (baudrate>>8);
+	UBRR   = (uint8_t) baudrate;
+
+	/* Enable UART receiver and transmitter and receive complete interrupt */
+	UART0_CONTROL = _BV(RXCIE)|(1<<RXEN)|(1<<TXEN);
+
+#endif
+
+} /* uart0_init */
+
+
+/*************************************************************************
+Function: uart0_getc()
+Purpose:  return byte from ringbuffer
+Returns:  lower byte:  received byte from ringbuffer
+          higher byte: last receive error
+**************************************************************************/
+uint16_t uart0_getc(void)
+{
+	uint16_t tmptail;
+	uint8_t data;
+
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		if (UART_RxHead == UART_RxTail) {
+			return UART_NO_DATA;   /* no data available */
+		}
+	}
+	
+	/* calculate / store buffer index */
+	tmptail = (UART_RxTail + 1) & UART_RX0_BUFFER_MASK;
+	
+	UART_RxTail = tmptail;
+	
+	/* get data from receive buffer */
+	data = UART_RxBuf[tmptail];
+
+	return (UART_LastRxError << 8) + data;
+
+} /* uart0_getc */
+
+/*************************************************************************
+Function: uart0_peek()
+Purpose:  Returns the next byte (character) of incoming UART data without
+          removing it from the ring buffer. That is, successive calls to
+		  uartN_peek() will return the same character, as will the next
+		  call to uartN_getc()
+Returns:  lower byte:  next byte in ring buffer
+          higher byte: last receive error
+**************************************************************************/
+uint16_t uart0_peek(void)
+{
+	uint16_t tmptail;
+	uint8_t data;
+
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		if (UART_RxHead == UART_RxTail) {
+			return UART_NO_DATA;   /* no data available */
+		}
+	}
+	
+	tmptail = (UART_RxTail + 1) & UART_RX0_BUFFER_MASK;
+
+	/* get data from receive buffer */
+	data = UART_RxBuf[tmptail];
+
+	return (UART_LastRxError << 8) + data;
+
+} /* uart0_peek */
+
+/*************************************************************************
+Function: uart0_putc()
+Purpose:  write byte to ringbuffer for transmitting via UART
+Input:    byte to be transmitted
+Returns:  none
+**************************************************************************/
+void uart0_putc(uint8_t data)
+{
+
+#ifdef USART0_LARGE_BUFFER
+	uint16_t tmphead;
+	uint16_t txtail_tmp;
+
+	tmphead = (UART_TxHead + 1) & UART_TX0_BUFFER_MASK;
+
+	do {
+		ATOMIC_BLOCK(ATOMIC_FORCEON) {
+			txtail_tmp = UART_TxTail;
+		}
+	} while (tmphead == txtail_tmp); /* wait for free space in buffer */
+#else
+	uint16_t tmphead;
+	
+	tmphead = (UART_TxHead + 1) & UART_TX0_BUFFER_MASK;
+	
+	while (tmphead == UART_TxTail); /* wait for free space in buffer */
+#endif
+
+	UART_TxBuf[tmphead] = data;
+	UART_TxHead = tmphead;
+
+	/* enable UDRE interrupt */
+	UART0_CONTROL |= _BV(UART0_UDRIE);
+
+} /* uart0_putc */
+
+
+/*************************************************************************
+Function: uart0_puts()
+Purpose:  transmit string to UART
+Input:    string to be transmitted
+Returns:  none
+**************************************************************************/
+void uart0_puts(const char *s)
+{
+	while (*s) {
+		uart0_putc(*s++);
+	}
+
+} /* uart0_puts */
+
+
+/*************************************************************************
+Function: uart0_puts_p()
+Purpose:  transmit string from program memory to UART
+Input:    program memory string to be transmitted
+Returns:  none
+**************************************************************************/
+void uart0_puts_p(const char *progmem_s)
+{
+	register char c;
+
+	while ((c = pgm_read_byte(progmem_s++))) {
+		uart0_putc(c);
+	}
+
+} /* uart0_puts_p */
+
+
+
+/*************************************************************************
+Function: uart0_available()
+Purpose:  Determine the number of bytes waiting in the receive buffer
+Input:    None
+Returns:  Integer number of bytes in the receive buffer
+**************************************************************************/
+uint16_t uart0_available(void)
+{
+	uint16_t ret;
+	
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		ret = (UART_RX0_BUFFER_SIZE + UART_RxHead - UART_RxTail) & UART_RX0_BUFFER_MASK;
+	}
+	return ret;
+} /* uart0_available */
+
+/*************************************************************************
+Function: uart0_flush()
+Purpose:  Flush bytes waiting the receive buffer. Actually ignores them.
+Input:    None
+Returns:  None
+**************************************************************************/
+void uart0_flush(void)
+{
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		UART_RxHead = UART_RxTail;
+	}
+} /* uart0_flush */
+
+#endif
+
+#endif /* defined(USART0_ENABLED) */
+
+#if defined(USART1_ENABLED)
+
+/*
+ * these functions are only for ATmegas with two USART
+ */
+#if defined(ATMEGA_USART1)
+
+ISR(UART1_RECEIVE_INTERRUPT)
+/*************************************************************************
+Function: UART1 Receive Complete interrupt
+Purpose:  called when the UART1 has received a character
+**************************************************************************/
+{
+	uint16_t tmphead;
+	uint8_t data;
+	uint8_t usr;
+	uint8_t 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_RX1_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;
+}
+
+
+ISR(UART1_TRANSMIT_INTERRUPT)
+/*************************************************************************
+Function: UART1 Data Register Empty interrupt
+Purpose:  called when the UART1 is ready to transmit the next byte
+**************************************************************************/
+{
+	uint16_t tmptail;
+
+	if (UART1_TxHead != UART1_TxTail) {
+		/* calculate and store new buffer index */
+		tmptail = (UART1_TxTail + 1) & UART_TX1_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(uint16_t baudrate)
+{
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {	
+		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 = (uint8_t) (baudrate>>8);
+	UBRR1L = (uint8_t) 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
+**************************************************************************/
+uint16_t uart1_getc(void)
+{
+	uint16_t tmptail;
+	uint8_t data;
+
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		if (UART1_RxHead == UART1_RxTail) {
+			return UART_NO_DATA;   /* no data available */
+		}
+
+		/* calculate / store buffer index */
+		tmptail = (UART1_RxTail + 1) & UART_RX1_BUFFER_MASK;
+		UART1_RxTail = tmptail;
+	}
+
+	/* get data from receive buffer */
+	data = UART1_RxBuf[tmptail];
+
+	return (UART1_LastRxError << 8) + data;
+
+} /* uart1_getc */
+
+/*************************************************************************
+Function: uart1_peek()
+Purpose:  Returns the next byte (character) of incoming UART data without
+          removing it from the ring buffer. That is, successive calls to
+		  uartN_peek() will return the same character, as will the next
+		  call to uartN_getc()
+Returns:  lower byte:  next byte in ring buffer
+          higher byte: last receive error
+**************************************************************************/
+uint16_t uart1_peek(void)
+{
+	uint16_t tmptail;
+	uint8_t data;
+
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		if (UART1_RxHead == UART1_RxTail) {
+			return UART_NO_DATA;   /* no data available */
+		}
+	}
+	
+	tmptail = (UART1_RxTail + 1) & UART_RX1_BUFFER_MASK;
+
+	/* get data from receive buffer */
+	data = UART1_RxBuf[tmptail];
+
+	return (UART1_LastRxError << 8) + data;
+
+} /* uart1_peek */
+
+/*************************************************************************
+Function: uart1_putc()
+Purpose:  write byte to ringbuffer for transmitting via UART
+Input:    byte to be transmitted
+Returns:  none
+**************************************************************************/
+void uart1_putc(uint8_t data)
+{
+	
+#ifdef USART1_LARGE_BUFFER
+	uint16_t tmphead;
+	uint16_t txtail_tmp;
+
+	tmphead = (UART1_TxHead + 1) & UART_TX1_BUFFER_MASK;
+
+	do {
+		ATOMIC_BLOCK(ATOMIC_FORCEON) {
+			txtail_tmp = UART1_TxTail;
+		}
+	} while (tmphead == txtail_tmp); /* wait for free space in buffer */
+#else
+	uint16_t tmphead;
+	
+	tmphead = (UART1_TxHead + 1) & UART_TX1_BUFFER_MASK;
+	
+	while (tmphead == UART1_TxTail); /* wait for free space in buffer */
+#endif	
+
+	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 */
+
+
+
+/*************************************************************************
+Function: uart1_available()
+Purpose:  Determine the number of bytes waiting in the receive buffer
+Input:    None
+Returns:  Integer number of bytes in the receive buffer
+**************************************************************************/
+uint16_t uart1_available(void)
+{
+	uint16_t ret;
+	
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		ret = (UART_RX1_BUFFER_SIZE + UART1_RxHead - UART1_RxTail) & UART_RX1_BUFFER_MASK;
+	}
+	return ret;
+} /* uart1_available */
+
+
+
+/*************************************************************************
+Function: uart1_flush()
+Purpose:  Flush bytes waiting the receive buffer. Actually ignores them.
+Input:    None
+Returns:  None
+**************************************************************************/
+void uart1_flush(void)
+{
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		UART1_RxHead = UART1_RxTail;
+	}
+} /* uart1_flush */
+
+#endif
+
+#endif /* defined(USART1_ENABLED) */
+
+#if defined(USART2_ENABLED)
+
+/*
+ * these functions are only for ATmegas with four USART
+ */
+#if defined(ATMEGA_USART2)
+
+ISR(UART2_RECEIVE_INTERRUPT)
+/*************************************************************************
+Function: UART2 Receive Complete interrupt
+Purpose:  called when the UART2 has received a character
+**************************************************************************/
+{
+	uint16_t tmphead;
+	uint8_t data;
+	uint8_t usr;
+	uint8_t lastRxError;
+
+
+	/* read UART status register and UART data register */
+	usr  = UART2_STATUS;
+	data = UART2_DATA;
+
+	/* */
+	lastRxError = (usr & (_BV(FE2)|_BV(DOR2)));
+
+	/* calculate buffer index */
+	tmphead = (UART2_RxHead + 1) & UART_RX2_BUFFER_MASK;
+
+	if (tmphead == UART2_RxTail) {
+		/* error: receive buffer overflow */
+		lastRxError = UART_BUFFER_OVERFLOW >> 8;
+	} else {
+		/* store new index */
+		UART2_RxHead = tmphead;
+		/* store received data in buffer */
+		UART2_RxBuf[tmphead] = data;
+	}
+	UART2_LastRxError = lastRxError;
+}
+
+
+ISR(UART2_TRANSMIT_INTERRUPT)
+/*************************************************************************
+Function: UART2 Data Register Empty interrupt
+Purpose:  called when the UART2 is ready to transmit the next byte
+**************************************************************************/
+{
+	uint16_t tmptail;
+
+
+	if (UART2_TxHead != UART2_TxTail) {
+		/* calculate and store new buffer index */
+		tmptail = (UART2_TxTail + 1) & UART_TX2_BUFFER_MASK;
+		UART2_TxTail = tmptail;
+		/* get one byte from buffer and write it to UART */
+		UART2_DATA = UART2_TxBuf[tmptail];  /* start transmission */
+	} else {
+		/* tx buffer empty, disable UDRE interrupt */
+		UART2_CONTROL &= ~_BV(UART2_UDRIE);
+	}
+}
+
+
+/*************************************************************************
+Function: uart2_init()
+Purpose:  initialize UART2 and set baudrate
+Input:    baudrate using macro UART_BAUD_SELECT()
+Returns:  none
+**************************************************************************/
+void uart2_init(uint16_t baudrate)
+{
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		UART2_TxHead = 0;
+		UART2_TxTail = 0;
+		UART2_RxHead = 0;
+		UART2_RxTail = 0;
+	}
+
+	/* Set baud rate */
+	if (baudrate & 0x8000) {
+		UART2_STATUS = (1<<U2X2);  //Enable 2x speed
+		baudrate &= ~0x8000;
+	}
+	UBRR2H = (uint8_t) (baudrate>>8);
+	UBRR2L = (uint8_t) baudrate;
+
+	/* Enable USART receiver and transmitter and receive complete interrupt */
+	UART2_CONTROL = _BV(RXCIE2)|(1<<RXEN2)|(1<<TXEN2);
+
+	/* Set frame format: asynchronous, 8data, no parity, 1stop bit */
+#ifdef URSEL2
+	UCSR2C = (1<<URSEL2)|(3<<UCSZ20);
+#else
+	UCSR2C = (3<<UCSZ20);
+#endif
+} /* uart_init */
+
+
+/*************************************************************************
+Function: uart2_getc()
+Purpose:  return byte from ringbuffer
+Returns:  lower byte:  received byte from ringbuffer
+          higher byte: last receive error
+**************************************************************************/
+uint16_t uart2_getc(void)
+{
+	uint16_t tmptail;
+	uint8_t data;
+
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		if (UART2_RxHead == UART2_RxTail) {
+			return UART_NO_DATA;   /* no data available */
+		}
+	}
+	
+	/* calculate / store buffer index */
+	
+	tmptail = (UART2_RxTail + 1) & UART_RX2_BUFFER_MASK;
+	UART2_RxTail = tmptail;
+
+	/* get data from receive buffer */
+	data = UART2_RxBuf[tmptail];
+
+	return (UART2_LastRxError << 8) + data;
+
+} /* uart2_getc */
+
+/*************************************************************************
+Function: uart2_peek()
+Purpose:  Returns the next byte (character) of incoming UART data without
+          removing it from the ring buffer. That is, successive calls to
+		  uartN_peek() will return the same character, as will the next
+		  call to uartN_getc()
+Returns:  lower byte:  next byte in ring buffer
+          higher byte: last receive error
+**************************************************************************/
+uint16_t uart2_peek(void)
+{
+	uint16_t tmptail;
+	uint8_t data;
+
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		if (UART2_RxHead == UART2_RxTail) {
+			return UART_NO_DATA;   /* no data available */
+		}
+	}
+	
+	tmptail = (UART2_RxTail + 1) & UART_RX2_BUFFER_MASK;
+
+	/* get data from receive buffer */
+	data = UART2_RxBuf[tmptail];
+
+	return (UART2_LastRxError << 8) + data;
+
+} /* uart2_peek */
+
+/*************************************************************************
+Function: uart2_putc()
+Purpose:  write byte to ringbuffer for transmitting via UART
+Input:    byte to be transmitted
+Returns:  none
+**************************************************************************/
+void uart2_putc(uint8_t data)
+{
+
+#ifdef USART2_LARGE_BUFFER
+	uint16_t tmphead;
+	uint16_t txtail_tmp;
+
+	tmphead = (UART2_TxHead + 1) & UART_TX2_BUFFER_MASK;
+
+	do {
+		ATOMIC_BLOCK(ATOMIC_FORCEON) {
+			txtail_tmp = UART2_TxTail;
+		}
+	} while (tmphead == txtail_tmp); /* wait for free space in buffer */
+#else
+	uint16_t tmphead;
+	
+	tmphead = (UART2_TxHead + 1) & UART_TX2_BUFFER_MASK;
+	
+	while (tmphead == UART2_TxTail); /* wait for free space in buffer */
+#endif		
+
+	UART2_TxBuf[tmphead] = data;
+	UART2_TxHead = tmphead;
+	
+	/* enable UDRE interrupt */
+	UART2_CONTROL |= _BV(UART2_UDRIE);
+
+} /* uart2_putc */
+
+
+/*************************************************************************
+Function: uart2_puts()
+Purpose:  transmit string to UART2
+Input:    string to be transmitted
+Returns:  none
+**************************************************************************/
+void uart2_puts(const char *s)
+{
+	while (*s)
+		uart2_putc(*s++);
+
+} /* uart2_puts */
+
+
+/*************************************************************************
+Function: uart2_puts_p()
+Purpose:  transmit string from program memory to UART2
+Input:    program memory string to be transmitted
+Returns:  none
+**************************************************************************/
+void uart2_puts_p(const char *progmem_s)
+{
+	register char c;
+
+	while ((c = pgm_read_byte(progmem_s++))) {
+		uart2_putc(c);
+	}
+
+} /* uart2_puts_p */
+
+
+
+/*************************************************************************
+Function: uart2_available()
+Purpose:  Determine the number of bytes waiting in the receive buffer
+Input:    None
+Returns:  Integer number of bytes in the receive buffer
+**************************************************************************/
+uint16_t uart2_available(void)
+{
+	uint16_t ret;
+	
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		ret = (UART_RX2_BUFFER_SIZE + UART2_RxHead - UART2_RxTail) & UART_RX2_BUFFER_MASK;
+	}
+	return ret;
+} /* uart2_available */
+
+
+
+/*************************************************************************
+Function: uart2_flush()
+Purpose:  Flush bytes waiting the receive buffer. Actually ignores them.
+Input:    None
+Returns:  None
+**************************************************************************/
+void uart2_flush(void)
+{
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		UART2_RxHead = UART2_RxTail;
+	}
+} /* uart2_flush */
+
+#endif
+
+#endif /* defined(USART2_ENABLED) */
+
+#if defined(USART3_ENABLED)
+
+/*
+ * these functions are only for ATmegas with four USART
+ */
+#if defined(ATMEGA_USART3)
+
+ISR(UART3_RECEIVE_INTERRUPT)
+/*************************************************************************
+Function: UART3 Receive Complete interrupt
+Purpose:  called when the UART3 has received a character
+**************************************************************************/
+{
+	uint16_t tmphead;
+	uint8_t data;
+	uint8_t usr;
+	uint8_t lastRxError;
+
+	/* read UART status register and UART data register */
+	usr  = UART3_STATUS;
+	data = UART3_DATA;
+
+	/* */
+	lastRxError = (usr & (_BV(FE3)|_BV(DOR3)));
+
+	/* calculate buffer index */
+	tmphead = (UART3_RxHead + 1) & UART_RX3_BUFFER_MASK;
+
+	if (tmphead == UART3_RxTail) {
+		/* error: receive buffer overflow */
+		lastRxError = UART_BUFFER_OVERFLOW >> 8;
+	} else {
+		/* store new index */
+		UART3_RxHead = tmphead;
+		/* store received data in buffer */
+		UART3_RxBuf[tmphead] = data;
+	}
+	UART3_LastRxError = lastRxError;
+}
+
+
+ISR(UART3_TRANSMIT_INTERRUPT)
+/*************************************************************************
+Function: UART3 Data Register Empty interrupt
+Purpose:  called when the UART3 is ready to transmit the next byte
+**************************************************************************/
+{
+	uint16_t tmptail;
+
+
+	if (UART3_TxHead != UART3_TxTail) {
+		/* calculate and store new buffer index */
+		tmptail = (UART3_TxTail + 1) & UART_TX3_BUFFER_MASK;
+		UART3_TxTail = tmptail;
+		/* get one byte from buffer and write it to UART */
+		UART3_DATA = UART3_TxBuf[tmptail];  /* start transmission */
+	} else {
+		/* tx buffer empty, disable UDRE interrupt */
+		UART3_CONTROL &= ~_BV(UART3_UDRIE);
+	}
+}
+
+
+/*************************************************************************
+Function: uart3_init()
+Purpose:  initialize UART3 and set baudrate
+Input:    baudrate using macro UART_BAUD_SELECT()
+Returns:  none
+**************************************************************************/
+void uart3_init(uint16_t baudrate)
+{
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		UART3_TxHead = 0;
+		UART3_TxTail = 0;
+		UART3_RxHead = 0;
+		UART3_RxTail = 0;
+	}
+
+	/* Set baud rate */
+	if (baudrate & 0x8000) {
+		UART3_STATUS = (1<<U2X3);  //Enable 2x speed
+		baudrate &= ~0x8000;
+	}
+	UBRR3H = (uint8_t)(baudrate>>8);
+	UBRR3L = (uint8_t) baudrate;
+
+	/* Enable USART receiver and transmitter and receive complete interrupt */
+	UART3_CONTROL = _BV(RXCIE3)|(1<<RXEN3)|(1<<TXEN3);
+
+	/* Set frame format: asynchronous, 8data, no parity, 1stop bit */
+#ifdef URSEL3
+	UCSR3C = (1<<URSEL3)|(3<<UCSZ30);
+#else
+	UCSR3C = (3<<UCSZ30);
+#endif
+} /* uart_init */
+
+
+/*************************************************************************
+Function: uart3_getc()
+Purpose:  return byte from ringbuffer
+Returns:  lower byte:  received byte from ringbuffer
+          higher byte: last receive error
+**************************************************************************/
+uint16_t uart3_getc(void)
+{
+	uint16_t tmptail;
+	uint8_t data;
+
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		if (UART3_RxHead == UART3_RxTail) {
+			return UART_NO_DATA;   /* no data available */
+		}
+	}
+	
+	/* calculate / store buffer index */
+	tmptail = (UART3_RxTail + 1) & UART_RX3_BUFFER_MASK;
+	UART3_RxTail = tmptail;
+
+	/* get data from receive buffer */
+	data = UART3_RxBuf[tmptail];
+
+	return (UART3_LastRxError << 8) + data;
+
+} /* uart3_getc */
+
+/*************************************************************************
+Function: uart3_peek()
+Purpose:  Returns the next byte (character) of incoming UART data without
+          removing it from the ring buffer. That is, successive calls to
+		  uartN_peek() will return the same character, as will the next
+		  call to uartN_getc()
+Returns:  lower byte:  next byte in ring buffer
+          higher byte: last receive error
+**************************************************************************/
+uint16_t uart3_peek(void)
+{
+	uint16_t tmptail;
+	uint8_t data;
+
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		if (UART3_RxHead == UART3_RxTail) {
+			return UART_NO_DATA;   /* no data available */
+		}
+	}
+		
+	tmptail = (UART3_RxTail + 1) & UART_RX3_BUFFER_MASK;
+
+	/* get data from receive buffer */
+	data = UART3_RxBuf[tmptail];
+
+	return (UART3_LastRxError << 8) + data;
+
+} /* uart3_peek */
+
+/*************************************************************************
+Function: uart3_putc()
+Purpose:  write byte to ringbuffer for transmitting via UART
+Input:    byte to be transmitted
+Returns:  none
+**************************************************************************/
+void uart3_putc(uint8_t data)
+{
+	
+#ifdef USART3_LARGE_BUFFER
+	uint16_t tmphead;
+	uint16_t txtail_tmp;
+
+	tmphead = (UART3_TxHead + 1) & UART_TX3_BUFFER_MASK;
+
+	do {
+		ATOMIC_BLOCK(ATOMIC_FORCEON) {
+			txtail_tmp = UART3_TxTail;
+		}
+	} while (tmphead == txtail_tmp); /* wait for free space in buffer */
+#else
+	uint16_t tmphead;
+	
+	tmphead = (UART3_TxHead + 1) & UART_TX3_BUFFER_MASK;
+	
+	while (tmphead == UART3_TxTail); /* wait for free space in buffer */
+#endif	
+
+	UART3_TxBuf[tmphead] = data;
+	UART3_TxHead = tmphead;
+
+	/* enable UDRE interrupt */
+	UART3_CONTROL |= _BV(UART3_UDRIE);
+
+} /* uart3_putc */
+
+
+/*************************************************************************
+Function: uart3_puts()
+Purpose:  transmit string to UART3
+Input:    string to be transmitted
+Returns:  none
+**************************************************************************/
+void uart3_puts(const char *s)
+{
+	while (*s) {
+		uart3_putc(*s++);
+	}
+
+} /* uart3_puts */
+
+
+/*************************************************************************
+Function: uart3_puts_p()
+Purpose:  transmit string from program memory to UART3
+Input:    program memory string to be transmitted
+Returns:  none
+**************************************************************************/
+void uart3_puts_p(const char *progmem_s)
+{
+	register char c;
+
+	while ((c = pgm_read_byte(progmem_s++))) {
+		uart3_putc(c);
+	}
+
+} /* uart3_puts_p */
+
+
+
+/*************************************************************************
+Function: uart3_available()
+Purpose:  Determine the number of bytes waiting in the receive buffer
+Input:    None
+Returns:  Integer number of bytes in the receive buffer
+**************************************************************************/
+uint16_t uart3_available(void)
+{
+	uint16_t ret;
+	
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		ret = (UART_RX3_BUFFER_SIZE + UART3_RxHead - UART3_RxTail) & UART_RX3_BUFFER_MASK;
+	}
+	return ret;
+} /* uart3_available */
+
+
+
+/*************************************************************************
+Function: uart3_flush()
+Purpose:  Flush bytes waiting the receive buffer. Actually ignores them.
+Input:    None
+Returns:  None
+**************************************************************************/
+void uart3_flush(void)
+{
+	ATOMIC_BLOCK(ATOMIC_FORCEON) {
+		UART3_RxHead = UART3_RxTail;
+	}
+} /* uart3_flush */
+
+#endif
+
+#endif /* defined(USART3_ENABLED) */
diff --git a/sw/lib/uart.h b/sw/lib/uart.h
new file mode 100644
index 0000000..0162e7d
--- /dev/null
+++ b/sw/lib/uart.h
@@ -0,0 +1,436 @@
+#ifndef UART_H
+#define UART_H
+
+/************************************************************************
+Title:    Interrupt UART library with receive/transmit circular buffers
+Author:   Andy Gock
+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 README.md and Doxygen manual
+
+Based on original library by Peter Fluery, Tim Sharpe, Nicholas Zambetti.
+
+https://github.com/andygock/avr-uart
+
+LICENSE:
+
+	Copyright (C) 2012 Andy Gock
+	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.
+
+************************************************************************/
+
+/************************************************************************
+uart_available, uart_flush, uart1_available, and uart1_flush functions
+were adapted from the Arduino HardwareSerial.h library by Tim Sharpe on 
+11 Jan 2009.  The license info for HardwareSerial.h is as follows:
+
+  HardwareSerial.h - Hardware serial library for Wiring
+  Copyright (c) 2006 Nicholas Zambetti.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library 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
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+************************************************************************/
+
+/** 
+ *  @defgroup avr-uart UART Library
+ *  @code #include <uart.h> @endcode
+ * 
+ *  @brief Interrupt UART library using the built-in UART with transmit and receive circular buffers.
+ *  @see README.md
+ *
+ *  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_RXn_BUFFER_SIZE and UART_TXn_BUFFER_SIZE constants define
+ *  the size of the circular buffers in bytes. Note that these constants must be a power of 2.
+ *
+ *  You need to define these buffer sizes as a symbol in your compiler settings or in uart.h
+ *
+ *  See README.md for more detailed information. Especially that relating to symbols: USARTn_ENABLED and USARTn_LARGE_BUFFER
+ *
+ *  @author Andy Gock <andy@gock.net>
+ *  @note Based on Atmel Application Note AVR306 and original library by Peter Fleury and Tim Sharpe.
+ */
+ 
+/**@{*/
+#include <stdint.h>
+#include <avr/io.h>
+
+#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
+ */
+
+/* Enable USART 1, 2, 3 as required */
+/* Can be defined in compiler symbol setup with -D option (preferred) */
+#ifndef USART0_ENABLED
+	#define USART0_ENABLED /**< Enable USART0 */
+#endif
+//#define USART1_ENABLED
+//#define USART2_ENABLED 
+//#define USART3_ENABLED
+
+/* Set size of receive and transmit buffers */
+
+#ifndef UART_RX0_BUFFER_SIZE
+	#define UART_RX0_BUFFER_SIZE 128 /**< Size of the circular receive buffer, must be power of 2 */
+#endif
+#ifndef UART_RX1_BUFFER_SIZE
+	#define UART_RX1_BUFFER_SIZE 128 /**< Size of the circular receive buffer, must be power of 2 */
+#endif
+#ifndef UART_RX2_BUFFER_SIZE
+	#define UART_RX2_BUFFER_SIZE 128 /**< Size of the circular receive buffer, must be power of 2 */
+#endif
+#ifndef UART_RX3_BUFFER_SIZE
+	#define UART_RX3_BUFFER_SIZE 128 /**< Size of the circular receive buffer, must be power of 2 */
+#endif
+
+#ifndef UART_TX0_BUFFER_SIZE
+	#define UART_TX0_BUFFER_SIZE 128 /**< Size of the circular transmit buffer, must be power of 2 */
+#endif
+#ifndef UART_TX1_BUFFER_SIZE
+	#define UART_TX1_BUFFER_SIZE 128 /**< Size of the circular transmit buffer, must be power of 2 */
+#endif
+#ifndef UART_TX2_BUFFER_SIZE
+	#define UART_TX2_BUFFER_SIZE 128 /**< Size of the circular transmit buffer, must be power of 2 */
+#endif
+#ifndef UART_TX3_BUFFER_SIZE
+	#define UART_TX3_BUFFER_SIZE 128 /**< Size of the circular transmit buffer, must be power of 2 */
+#endif
+
+/* Check buffer sizes are not too large for 8-bit positioning */
+
+#if (UART_RX0_BUFFER_SIZE > 256 & !defined(USART0_LARGE_BUFFER))
+	#error "Buffer too large, please use -DUSART0_LARGE_BUFFER switch in compiler options"
+#endif
+
+#if (UART_RX1_BUFFER_SIZE > 256 & !defined(USART1_LARGE_BUFFER))
+	#error "Buffer too large, please use -DUSART1_LARGE_BUFFER switch in compiler options"
+#endif
+
+#if (UART_RX2_BUFFER_SIZE > 256 & !defined(USART2_LARGE_BUFFER))
+	#error "Buffer too large, please use -DUSART2_LARGE_BUFFER switch in compiler options"
+#endif
+
+#if (UART_RX3_BUFFER_SIZE > 256 & !defined(USART3_LARGE_BUFFER))
+	#error "Buffer too large, please use -DUSART3_LARGE_BUFFER switch in compiler options"
+#endif
+
+/* Check buffer sizes are not too large for *_LARGE_BUFFER operation (16-bit positioning) */
+
+#if (UART_RX0_BUFFER_SIZE > 32768)
+	#error "Buffer too large, maximum allowed is 32768 bytes"
+#endif
+
+#if (UART_RX1_BUFFER_SIZE > 32768)
+	#error "Buffer too large, maximum allowed is 32768 bytes"
+#endif
+
+#if (UART_RX2_BUFFER_SIZE > 32768)
+	#error "Buffer too large, maximum allowed is 32768 bytes"
+#endif
+
+#if (UART_RX3_BUFFER_SIZE > 32768)
+	#error "Buffer too large, maximum allowed is 32768 bytes"
+#endif
+
+/** @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)+8UL*(baudRate))/(16UL*(baudRate))-1UL)
+
+/** @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)+4UL*(baudRate))/(8UL*(baudRate))-1)|0x8000)
+
+/* test if the size of the circular buffers fits into SRAM */
+
+#if defined(USART0_ENABLED) && ( (UART_RX0_BUFFER_SIZE+UART_TX0_BUFFER_SIZE) >= (RAMEND-0x60))
+	#error "size of UART_RX0_BUFFER_SIZE + UART_TX0_BUFFER_SIZE larger than size of SRAM"
+#endif
+
+#if defined(USART1_ENABLED) && ( (UART_RX1_BUFFER_SIZE+UART_TX1_BUFFER_SIZE) >= (RAMEND-0x60))
+	#error "size of UART_RX1_BUFFER_SIZE + UART_TX1_BUFFER_SIZE larger than size of SRAM"
+#endif
+
+#if defined(USART2_ENABLED) && ( (UART_RX2_BUFFER_SIZE+UART_RX2_BUFFER_SIZE) >= (RAMEND-0x60))
+	#error "size of UART_RX2_BUFFER_SIZE + UART_TX2_BUFFER_SIZE larger than size of SRAM"
+#endif
+
+#if defined(USART3_ENABLED) && ( (UART_RX3_BUFFER_SIZE+UART_RX3_BUFFER_SIZE) >= (RAMEND-0x60))
+	#error "size of UART_RX3_BUFFER_SIZE + UART_TX3_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   */
+
+/* Macros, to allow use of legacy names */
+
+/** @brief Macro to initialize USART0 (only available on selected ATmegas) @see uart0_init */
+#define uart_init(b)      uart0_init(b)
+
+/** @brief Macro to get received byte of USART0 from ringbuffer. (only available on selected ATmega) @see uart0_getc */
+#define uart_getc()       uart0_getc()
+
+/** @brief Macro to peek at next byte in USART0 ringbuffer */
+#define uart_peek()       uart0_peek()
+
+/** @brief Macro to put byte to ringbuffer for transmitting via USART0 (only available on selected ATmega) @see uart0_putc */
+#define uart_putc(d)      uart0_putc(d)
+
+/** @brief Macro to put string to ringbuffer for transmitting via USART0 (only available on selected ATmega) @see uart0_puts */
+#define uart_puts(s)      uart0_puts(s)
+
+/** @brief Macro to put string from program memory to ringbuffer for transmitting via USART0 (only available on selected ATmega) @see uart0_puts_p */
+#define uart_puts_p(s)    uart0_puts_p(s)
+
+/** @brief Macro to return number of bytes waiting in the receive buffer of USART0 @see uart0_available */
+#define uart_available()  uart0_available()
+
+/** @brief Macro to flush bytes waiting in receive buffer of USART0 @see uart0_flush */
+#define uart_flush()      uart0_flush()
+
+/*
+** function prototypes
+*/
+
+/**
+   @brief   Initialize UART and set baudrate 
+   @param   baudrate Specify baudrate using macro UART_BAUD_SELECT()
+   @return  none
+*/
+extern void uart0_init(uint16_t 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.
+ *
+ *  @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 uint16_t uart0_getc(void);
+
+/**
+ *  @brief   Peek at next byte in ringbuffer
+ *
+ * Returns the next byte (character) of incoming UART data without removing it from the
+ * internal ring buffer. That is, successive calls to uartN_peek() will return the same
+ * character, as will the next call to uartN_getc().
+ *
+ * UART_NO_DATA is returned when no data is available.
+ *
+ *  @return  lower byte:  next byte in 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 uint16_t uart0_peek(void);
+
+/**
+ *  @brief   Put byte to ringbuffer for transmitting via UART
+ *  @param   data byte to be transmitted
+ *  @return  none
+ */
+extern void uart0_putc(uint8_t 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 uart0_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      uart0_puts_P
+ */
+extern void uart0_puts_p(const char *s);
+
+/**
+ * @brief    Macro to automatically put a string constant into program memory
+ * \param    __s string in program memory
+ */
+#define uart_puts_P(__s)       uart0_puts_p(PSTR(__s))
+
+/** @brief  Macro to automatically put a string constant into program memory */
+#define uart0_puts_P(__s)      uart0_puts_p(PSTR(__s))
+
+/**
+ *  @brief   Return number of bytes waiting in the receive buffer
+ *  @return  bytes waiting in the receive buffer
+ */
+extern uint16_t uart0_available(void);
+
+/**
+ *  @brief   Flush bytes waiting in receive buffer
+ */
+extern void uart0_flush(void);
+
+
+/** @brief  Initialize USART1 (only available on selected ATmegas) @see uart_init */
+extern void uart1_init(uint16_t baudrate);
+
+/** @brief  Get received byte of USART1 from ringbuffer. (only available on selected ATmega) @see uart_getc */
+extern uint16_t uart1_getc(void);
+
+/** @brief  Peek at next byte in USART1 ringbuffer */
+extern uint16_t uart1_peek(void);
+
+/** @brief  Put byte to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_putc */
+extern void uart1_putc(uint8_t 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 of USART1 @see uart1_puts_p */
+#define uart1_puts_P(__s)       uart1_puts_p(PSTR(__s))
+
+/** @brief  Return number of bytes waiting in the receive buffer of USART1 */
+extern uint16_t uart1_available(void);
+
+/** @brief  Flush bytes waiting in receive buffer of USART1 */
+extern void uart1_flush(void);
+
+
+/** @brief  Initialize USART2 (only available on selected ATmegas) @see uart_init */
+extern void uart2_init(uint16_t baudrate);
+
+/** @brief  Get received byte of USART2 from ringbuffer. (only available on selected ATmega) @see uart_getc */
+extern uint16_t uart2_getc(void);
+
+/** @brief  Peek at next byte in USART2 ringbuffer */
+extern uint16_t uart2_peek(void);
+
+/** @brief  Put byte to ringbuffer for transmitting via USART2 (only available on selected ATmega) @see uart_putc */
+extern void uart2_putc(uint8_t data);
+
+/** @brief  Put string to ringbuffer for transmitting via USART2 (only available on selected ATmega) @see uart_puts */
+extern void uart2_puts(const char *s);
+
+/** @brief  Put string from program memory to ringbuffer for transmitting via USART2 (only available on selected ATmega) @see uart_puts_p */
+extern void uart2_puts_p(const char *s);
+
+/** @brief  Macro to automatically put a string constant into program memory of USART2 @see uart2_puts_p */
+#define uart2_puts_P(__s)       uart2_puts_p(PSTR(__s))
+
+/** @brief  Return number of bytes waiting in the receive buffer of USART2 */
+extern uint16_t uart2_available(void);
+
+/** @brief  Flush bytes waiting in receive buffer of USART2 */
+extern void uart2_flush(void);
+
+
+/** @brief  Initialize USART3 (only available on selected ATmegas) @see uart_init */
+extern void uart3_init(uint16_t baudrate);
+
+/** @brief  Get received byte of USART3 from ringbuffer. (only available on selected ATmega) @see uart_getc */
+extern uint16_t uart3_getc(void);
+
+/** @brief  Peek at next byte in USART3 ringbuffer */
+extern uint16_t uart3_peek(void);
+
+/** @brief  Put byte to ringbuffer for transmitting via USART3 (only available on selected ATmega) @see uart_putc */
+extern void uart3_putc(uint8_t data);
+
+/** @brief  Put string to ringbuffer for transmitting via USART3 (only available on selected ATmega) @see uart_puts */
+extern void uart3_puts(const char *s);
+
+/** @brief  Put string from program memory to ringbuffer for transmitting via USART3 (only available on selected ATmega) @see uart_puts_p */
+extern void uart3_puts_p(const char *s);
+
+/** @brief  Macro to automatically put a string constant into program memory of USART3 @see uart3_puts_p */
+#define uart3_puts_P(__s)       uart3_puts_p(PSTR(__s))
+
+/** @brief  Return number of bytes waiting in the receive buffer of USART3 */
+extern uint16_t uart3_available(void);
+
+/** @brief  Flush bytes waiting in receive buffer of USART3 */
+extern void uart3_flush(void);
+
+/**@}*/
+
+#endif // UART_H 
+
diff --git a/sw/lib/OneWire/util/OneWire_direct_gpio.h b/sw/lib/util/OneWire_direct_gpio.h
index 0771367..0771367 100644
--- a/sw/lib/OneWire/util/OneWire_direct_gpio.h
+++ b/sw/lib/util/OneWire_direct_gpio.h
diff --git a/sw/lib/OneWire/util/OneWire_direct_regtype.h b/sw/lib/util/OneWire_direct_regtype.h
index 21c4634..21c4634 100644
--- a/sw/lib/OneWire/util/OneWire_direct_regtype.h
+++ b/sw/lib/util/OneWire_direct_regtype.h
diff --git a/sw/main.cpp b/sw/main.cpp
index 48871ec..562c4e6 100644
--- a/sw/main.cpp
+++ b/sw/main.cpp
@@ -24,6 +24,7 @@
 
 #include <stdlib.h>
 #include <stdint.h>
+#include <stdio.h>
 
 #include <avr/pgmspace.h>
 #include <avr/io.h>
@@ -32,9 +33,16 @@
 #include <avr/eeprom.h>
 #include <avr/wdt.h>
 
+extern "C" {
+#include "uart.h"
+}
+
 // Definitions allocation pin
 #define PIN(x) (1 << x)
 
+// UART endline is usually CR LF
+#define ENDL "\r\n"
+
 /* All relay signals PINx_Kx have external pulldown.
  * All pins whose name ends in 'n' are active low */
 
@@ -86,15 +94,7 @@ uint32_t last_store_time; /* In seconds */
 
 uint32_t current_capacity;
 
-/* Assuming F_CPU at 16MHz / 8:
- *
- * overflow for 100ms: F_CPU [ticks/s] / prescaler [unit-less] * interval [s] = [ticks/s*s] = [ticks]
- * interval [s] = 0.1 = 1 / 10
- *
- * Actual interval after rounding:
- * interval [s] = overflow [ticks] / (F_CPU [ticks/s] / prescaler [unit-less])
- *              = 99.84 ms
- */
+/* Timer at approximately 100ms */
 volatile uint8_t timer_counter; /* Timer in 100ms steps */
 volatile uint32_t timer_seconds; /* Timer in seconds */
 
@@ -118,9 +118,7 @@ enum class error_type_t {
     EEPROM_WRITE_ERROR,
 };
 
-static void flag_error(error_type_t e) {
-    // TODO output error
-}
+static void flag_error(const error_type_t e);
 
 static void load_capacity_from_eeprom()
 {
@@ -165,6 +163,32 @@ static void store_capacity_to_eeprom()
     }
 }
 
+static char timestamp_buf[16];
+static void send_message(const char *message)
+{
+    snprintf(timestamp_buf, 15, "TEXT,%ld,", timer_seconds);
+    uart_puts(timestamp_buf);
+    uart_puts(message);
+    uart_puts_P(ENDL);
+}
+
+static void flag_error(const error_type_t e)
+{
+    snprintf(timestamp_buf, 15, "ERROR,%ld,", timer_seconds);
+    uart_puts(timestamp_buf);
+    switch (e) {
+        case error_type_t::EEPROM_READ_WARNING:
+            uart_puts_P("EEPRON read warning" ENDL);
+            break;
+        case error_type_t::EEPROM_READ_ERROR:
+            uart_puts_P("EEPRON read error" ENDL);
+            break;
+        case error_type_t::EEPROM_WRITE_ERROR:
+            uart_puts_P("EEPRON write error" ENDL);
+            break;
+    }
+}
+
 int main()
 {
     /* Save the reset source for debugging, then enable the watchdog.
@@ -186,7 +210,33 @@ int main()
     DDRC = PINC_OUTPUTS;
     DDRD = PIND_OUTPUTS;
 
-    /* Setup 100Hz timer */
+    /* Setup UART */
+    uart_init(UART_BAUD_SELECT(9600, F_CPU));
+    if (mcusr_mirror & WDRF) {
+        send_message("Startup after WDT reset");
+    }
+    else if (mcusr_mirror & BORF) {
+        send_message("Startup after brown-out");
+    }
+    else if (mcusr_mirror & EXTRF) {
+        send_message("Startup after external reset");
+    }
+    else if (mcusr_mirror & PORF) {
+        send_message("Startup after power-on reset");
+    }
+    else {
+        send_message("Startup");
+    }
+
+    /* Setup 100Hz timer, assuming F_CPU at 16MHz / 8:
+     *
+     * overflow for 100ms: F_CPU [ticks/s] / prescaler [unit-less] * interval [s] = [ticks/s*s] = [ticks]
+     * interval [s] = 0.1 = 1 / 10
+     *
+     * Actual interval after rounding:
+     * interval [s] = overflow [ticks] / (F_CPU [ticks/s] / prescaler [unit-less])
+     *              = 99.84 ms
+     */
     timer_seconds = 0;
     timer_counter = 0;
     TCCR0B |= (1 << WGM02); // Set timer mode to CTC (datasheet 15.7.2)