BIOI keyboards: use core UART driver (#21879)

7 files changed, 16 insertions, 2019 deletions

diff --git a/keyboards/bioi/ble.h b/keyboards/bioi/ble.h
deleted file mode 100644
index 529ebf5241..0000000000
--- a/keyboards/bioi/ble.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
-Copyright 2019 Basic I/O Instruments(Scott Wei) <scot.wei@gmail.com>
-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
-(at your option) 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.
-You should have received a copy of the GNU General Public License
-along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#pragma once
-
-#include <stdbool.h>
-
-typedef union {
-  uint32_t raw;
-  struct {
-    bool init : 1;
-  };
-} keyboard_config_t;
-
-extern keyboard_config_t ble_config;
-
-void send_str(const char *str);
-void usart_init(void);
-void module_reset(void);
diff --git a/keyboards/bioi/ble.c b/keyboards/bioi/bluetooth_custom.c
index 12c180966a..7d88a837d1 100644
--- a/keyboards/bioi/ble.c
+++ b/keyboards/bioi/bluetooth_custom.c
@@ -13,23 +13,18 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "bluetooth.h"
-#include "ble.h"
-#include "usart.h"
+#include "uart.h"
 #include "progmem.h"
 #include "wait.h"
 #include "debug.h"
 #include "usb_descriptor.h"
 #include "report.h"
 
-keyboard_config_t ble_config;
-
-static void bluefruit_serial_send(uint8_t);
-
 void send_str(const char *str)
 {
     uint8_t c;
     while ((c = pgm_read_byte(str++)))
-        uart1_putc(c);
+        uart_write(c);
 }
 
 void serial_send(uint8_t data)
@@ -43,7 +38,7 @@ void send_bytes(uint8_t data)
     sprintf(hexStr, "%02X", data);
     for (int j = 0; j < sizeof(hexStr) - 1; j++)
     {
-        uart1_putc(hexStr[j]);
+        uart_write(hexStr[j]);
     }
 }
 
@@ -72,7 +67,12 @@ static void bluefruit_serial_send(uint8_t data)
 }
 
 void bluetooth_init(void) {
-    usart_init();
+    uart_init(76800);
+    wait_ms(250);
+
+    send_str(PSTR("\r\n"));
+    send_str(PSTR("\r\n"));
+    send_str(PSTR("\r\n"));
 }
 
 void bluetooth_task(void) {}
@@ -162,13 +162,3 @@ void bluetooth_send_consumer(uint16_t usage)
     bluefruit_trace_footer();
 #endif
 }
-
-void usart_init(void)
-{
-    uart1_init(UART_BAUD_SELECT_DOUBLE_SPEED(76800, 8000000L));
-    wait_ms(250);
-
-    send_str(PSTR("\r\n"));
-    send_str(PSTR("\r\n"));
-    send_str(PSTR("\r\n"));
-}
diff --git a/keyboards/bioi/g60/rules.mk b/keyboards/bioi/g60/rules.mk
index 2b955ce793..f4532628ae 100644
--- a/keyboards/bioi/g60/rules.mk
+++ b/keyboards/bioi/g60/rules.mk
@@ -18,7 +18,5 @@ BLUETOOTH_ENABLE = yes
 
 VIA_ENABLE = yes            # VIA support should be enabled here due to the main() loop will be compiled first.
 
-SRC += usart.c ble.c
-
-OPT_DEFS += -DUART_RX1_BUFFER_SIZE=16 -DUART_TX1_BUFFER_SIZE=16
-OPT_DEFS += -DUSART1_ENABLED
+QUANTUM_LIB_SRC += uart.c
+SRC += bluetooth_custom.c
diff --git a/keyboards/bioi/g60ble/rules.mk b/keyboards/bioi/g60ble/rules.mk
index 31cc2c22b6..2e79ce77a5 100644
--- a/keyboards/bioi/g60ble/rules.mk
+++ b/keyboards/bioi/g60ble/rules.mk
@@ -13,8 +13,7 @@ BACKLIGHT_ENABLE = yes     # Enable keyboard backlight functionality
 RGBLIGHT_ENABLE = yes
 LTO_ENABLE = yes
 
-# these lines are all for bluetooth
 BLUETOOTH_ENABLE = yes
-SRC += usart.c ble.c
-OPT_DEFS += -DUART_RX1_BUFFER_SIZE=16 -DUART_TX1_BUFFER_SIZE=16
-OPT_DEFS += -DUSART1_ENABLED
+
+QUANTUM_LIB_SRC += uart.c
+SRC += bluetooth_custom.c
diff --git a/keyboards/bioi/morgan65/rules.mk b/keyboards/bioi/morgan65/rules.mk
index 2b955ce793..f4532628ae 100644
--- a/keyboards/bioi/morgan65/rules.mk
+++ b/keyboards/bioi/morgan65/rules.mk
@@ -18,7 +18,5 @@ BLUETOOTH_ENABLE = yes
 
 VIA_ENABLE = yes            # VIA support should be enabled here due to the main() loop will be compiled first.
 
-SRC += usart.c ble.c
-
-OPT_DEFS += -DUART_RX1_BUFFER_SIZE=16 -DUART_TX1_BUFFER_SIZE=16
-OPT_DEFS += -DUSART1_ENABLED
+QUANTUM_LIB_SRC += uart.c
+SRC += bluetooth_custom.c
diff --git a/keyboards/bioi/usart.c b/keyboards/bioi/usart.c
deleted file mode 100644
index f37845e5c6..0000000000
--- a/keyboards/bioi/usart.c
+++ /dev/null
@@ -1,1522 +0,0 @@
-/*************************************************************************
-
-	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 "usart.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/keyboards/bioi/usart.h b/keyboards/bioi/usart.h
deleted file mode 100644
index cc59c7236b..0000000000
--- a/keyboards/bioi/usart.h
+++ /dev/null
@@ -1,436 +0,0 @@
-#ifndef USART_H
-#define USART_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 
-