avr/uart
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Ran clang-format

Browse Source
This commit is contained in:
BlackMark
2019-07-30 20:29:15 +02:00
parent 470eb06345
commit c03196493a
2 changed files with 538 additions and 577 deletions
Download Patch File Download Diff File Expand all files Collapse all files

714
uart.cpp
View File

@@ -36,306 +36,304 @@ LICENSE:
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
*************************************************************************/ *************************************************************************/
#include "uart.h" #include "uart.h"
#include <avr/interrupt.h> #include <avr/interrupt.h>
#include <avr/io.h> #include <avr/io.h>
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#define UART_RX_BUFFER_MASK ( UART_RX_BUFFER_SIZE - 1) /*
#define UART_TX_BUFFER_MASK ( UART_TX_BUFFER_SIZE - 1) * constants and macros
*/ */
#if ( UART_RX_BUFFER_SIZE & UART_RX_BUFFER_MASK )
/* size of RX/TX buffers */ /* size of RX/TX buffers */
#define UART_RX_BUFFER_MASK (UART_RX_BUFFER_SIZE - 1) #define UART_RX_BUFFER_MASK (UART_RX_BUFFER_SIZE - 1)
#if ( UART_TX_BUFFER_SIZE & UART_TX_BUFFER_MASK ) #define UART_TX_BUFFER_MASK (UART_TX_BUFFER_SIZE - 1)
#if (UART_RX_BUFFER_SIZE & UART_RX_BUFFER_MASK) #if (UART_RX_BUFFER_SIZE & UART_RX_BUFFER_MASK)
#error RX buffer size is not a power of 2 #error RX buffer size is not a power of 2
#endif #endif
defined(__AVR_AT90S4434__) || defined(__AVR_AT90S8535__) || \ #if (UART_TX_BUFFER_SIZE & UART_TX_BUFFER_MASK)
defined(__AVR_ATmega103__) #error TX buffer size is not a power of 2
/* old AVR classic or ATmega103 with one UART */ #endif
#define UART0_RECEIVE_INTERRUPT UART_RX_vect
#define UART0_TRANSMIT_INTERRUPT UART_UDRE_vect #if defined(__AVR_AT90S2313__) || defined(__AVR_AT90S4414__) || defined(__AVR_AT90S8515__) || \
#define UART0_STATUS USR defined(__AVR_AT90S4434__) || defined(__AVR_AT90S8535__) || defined(__AVR_ATmega103__)
#define UART0_CONTROL UCR /* old AVR classic or ATmega103 with one UART */
#define UART0_DATA UDR #define UART0_RECEIVE_INTERRUPT UART_RX_vect
#define UART0_UDRIE UDRIE #define UART0_TRANSMIT_INTERRUPT UART_UDRE_vect
#define UART0_UBRRL UBRR #define UART0_STATUS USR
#define UART0_BIT_U2X U2X #define UART0_CONTROL UCR
#define UART0_BIT_RXCIE RXCIE #define UART0_DATA UDR
#define UART0_BIT_RXEN RXEN #define UART0_UDRIE UDRIE
#define UART0_BIT_TXEN TXEN
#define UART0_UBRRL UBRR #define UART0_UBRRL UBRR
/* old AVR classic with one UART */ #define UART0_BIT_U2X U2X
#define UART0_RECEIVE_INTERRUPT UART_RX_vect #define UART0_BIT_RXCIE RXCIE
#define UART0_TRANSMIT_INTERRUPT UART_UDRE_vect #define UART0_BIT_RXEN RXEN
#define UART0_STATUS UCSRA #define UART0_BIT_TXEN TXEN
#define UART0_CONTROL UCSRB #elif defined(__AVR_AT90S2333__) || defined(__AVR_AT90S4433__)
#define UART0_DATA UDR /* old AVR classic with one UART */
#define UART0_UDRIE UDRIE #define UART0_RECEIVE_INTERRUPT UART_RX_vect
#define UART0_UBRRL UBRR #define UART0_TRANSMIT_INTERRUPT UART_UDRE_vect
#define UART0_BIT_U2X U2X #define UART0_STATUS UCSRA
#define UART0_BIT_RXCIE RXCIE #define UART0_CONTROL UCSRB
#define UART0_BIT_RXEN RXEN #define UART0_DATA UDR
#define UART0_BIT_TXEN TXEN #define UART0_UDRIE UDRIE
#define UART0_UBRRL UBRR #define UART0_UBRRL UBRR
/* AT90PWN216/316 with one USART */ #define UART0_BIT_U2X U2X
#define UART0_RECEIVE_INTERRUPT USART_RX_vect #define UART0_BIT_RXCIE RXCIE
#define UART0_TRANSMIT_INTERRUPT USART_UDRE_vect #define UART0_BIT_RXEN RXEN
#define UART0_STATUS UCSRA #define UART0_BIT_TXEN TXEN
#define UART0_CONTROL UCSRB #elif defined(__AVR_AT90PWM216__) || defined(__AVR_AT90PWM316__)
#define UART0_CONTROLC UCSRC /* AT90PWN216/316 with one USART */
#define UART0_DATA UDR #define UART0_RECEIVE_INTERRUPT USART_RX_vect
#define UART0_UDRIE UDRIE #define UART0_TRANSMIT_INTERRUPT USART_UDRE_vect
#define UART0_UBRRL UBRRL #define UART0_STATUS UCSRA
#define UART0_UBRRH UBRRH #define UART0_CONTROL UCSRB
#define UART0_BIT_U2X U2X #define UART0_CONTROLC UCSRC
#define UART0_BIT_RXCIE RXCIE #define UART0_DATA UDR
#define UART0_BIT_RXEN RXEN #define UART0_UDRIE UDRIE
#define UART0_BIT_TXEN TXEN #define UART0_UBRRL UBRRL
#define UART0_BIT_UCSZ0 UCSZ0 #define UART0_UBRRH UBRRH
#define UART0_BIT_UCSZ1 UCSZ1 #define UART0_BIT_U2X U2X
#elif defined(__AVR_ATmega8__) || defined(__AVR_ATmega8A__) || \ #define UART0_BIT_RXCIE RXCIE
defined(__AVR_ATmega16__) || defined(__AVR_ATmega16A__) || \ #define UART0_BIT_RXEN RXEN
defined(__AVR_ATmega32__) || defined(__AVR_ATmega32A__) || \
#define UART0_BIT_TXEN TXEN #define UART0_BIT_TXEN TXEN
/* ATmega with one USART */ #define UART0_BIT_UCSZ0 UCSZ0
#define UART0_RECEIVE_INTERRUPT USART_RXC_vect #define UART0_BIT_UCSZ1 UCSZ1
#define UART0_TRANSMIT_INTERRUPT USART_UDRE_vect #elif defined(__AVR_ATmega8__) || defined(__AVR_ATmega8A__) || defined(__AVR_ATmega16__) || \
#define UART0_STATUS UCSRA defined(__AVR_ATmega16A__) || defined(__AVR_ATmega32__) || defined(__AVR_ATmega32A__) || \
#define UART0_CONTROL UCSRB defined(__AVR_ATmega323__)
#define UART0_CONTROLC UCSRC /* ATmega with one USART */
#define UART0_DATA UDR #define UART0_RECEIVE_INTERRUPT USART_RXC_vect
#define UART0_UDRIE UDRIE #define UART0_TRANSMIT_INTERRUPT USART_UDRE_vect
#define UART0_UBRRL UBRRL #define UART0_STATUS UCSRA
#define UART0_UBRRH UBRRH #define UART0_CONTROL UCSRB
#define UART0_BIT_U2X U2X #define UART0_CONTROLC UCSRC
#define UART0_BIT_RXCIE RXCIE #define UART0_DATA UDR
#define UART0_BIT_RXEN RXEN #define UART0_UDRIE UDRIE
#define UART0_BIT_TXEN TXEN #define UART0_UBRRL UBRRL
#define UART0_BIT_UCSZ0 UCSZ0 #define UART0_UBRRH UBRRH
#define UART0_BIT_UCSZ1 UCSZ1 #define UART0_BIT_U2X U2X
#define UART0_BIT_URSEL URSEL #define UART0_BIT_RXCIE RXCIE
#elif defined (__AVR_ATmega8515__) || defined(__AVR_ATmega8535__) #define UART0_BIT_RXEN RXEN
#define UART0_RECEIVE_INTERRUPT USART_RX_vect #define UART0_BIT_TXEN TXEN
#define UART0_TRANSMIT_INTERRUPT USART_UDRE_vect #define UART0_BIT_UCSZ0 UCSZ0
#define UART0_STATUS UCSRA #define UART0_BIT_UCSZ1 UCSZ1
#define UART0_CONTROL UCSRB #define UART0_BIT_URSEL URSEL
#define UART0_CONTROLC UCSRC #elif defined(__AVR_ATmega8515__) || defined(__AVR_ATmega8535__)
#define UART0_DATA UDR #define UART0_RECEIVE_INTERRUPT USART_RX_vect
#define UART0_UDRIE UDRIE #define UART0_TRANSMIT_INTERRUPT USART_UDRE_vect
#define UART0_UBRRL UBRRL #define UART0_STATUS UCSRA
#define UART0_UBRRH UBRRH #define UART0_CONTROL UCSRB
#define UART0_BIT_U2X U2X #define UART0_CONTROLC UCSRC
#define UART0_BIT_RXCIE RXCIE #define UART0_DATA UDR
#define UART0_BIT_RXEN RXEN #define UART0_UDRIE UDRIE
#define UART0_BIT_TXEN TXEN #define UART0_UBRRL UBRRL
#define UART0_BIT_UCSZ0 UCSZ0 #define UART0_UBRRH UBRRH
#define UART0_BIT_UCSZ1 UCSZ1 #define UART0_BIT_U2X U2X
#define UART0_BIT_URSEL URSEL #define UART0_BIT_RXCIE RXCIE
#define UART0_BIT_RXEN RXEN #define UART0_BIT_RXEN RXEN
/* ATmega163 with one UART */ #define UART0_BIT_TXEN TXEN
#define UART0_RECEIVE_INTERRUPT UART_RX_vect #define UART0_BIT_UCSZ0 UCSZ0
#define UART0_TRANSMIT_INTERRUPT UART_UDRE_vect #define UART0_BIT_UCSZ1 UCSZ1
#define UART0_STATUS UCSRA #define UART0_BIT_URSEL URSEL
#define UART0_CONTROL UCSRB #elif defined(__AVR_ATmega163__)
#define UART0_DATA UDR /* ATmega163 with one UART */
#define UART0_UDRIE UDRIE #define UART0_RECEIVE_INTERRUPT UART_RX_vect
#define UART0_UBRRL UBRR #define UART0_TRANSMIT_INTERRUPT UART_UDRE_vect
#define UART0_UBRRH UBRRHI #define UART0_STATUS UCSRA
#define UART0_BIT_U2X U2X #define UART0_CONTROL UCSRB
#define UART0_BIT_RXCIE RXCIE #define UART0_DATA UDR
#define UART0_BIT_RXEN RXEN #define UART0_UDRIE UDRIE
#define UART0_BIT_TXEN TXEN #define UART0_UBRRL UBRR
#define UART0_UBRRH UBRRHI #define UART0_UBRRH UBRRHI
/* ATmega with two USART */ #define UART0_BIT_U2X U2X
#define ATMEGA_USART1 #define UART0_BIT_RXCIE RXCIE
#define UART0_RECEIVE_INTERRUPT USART0_RXC_vect #define UART0_BIT_RXEN RXEN
#define UART1_RECEIVE_INTERRUPT USART1_RXC_vect #define UART0_BIT_TXEN TXEN
#define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect #elif defined(__AVR_ATmega162__)
#define UART1_TRANSMIT_INTERRUPT USART1_UDRE_vect /* ATmega with two USART */
#define UART0_STATUS UCSR0A #define ATMEGA_USART1
#define UART0_CONTROL UCSR0B #define UART0_RECEIVE_INTERRUPT USART0_RXC_vect
#define UART0_CONTROLC UCSR0C #define UART1_RECEIVE_INTERRUPT USART1_RXC_vect
#define UART0_DATA UDR0 #define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect
#define UART0_UDRIE UDRIE0 #define UART1_TRANSMIT_INTERRUPT USART1_UDRE_vect
#define UART0_UBRRL UBRR0L #define UART0_STATUS UCSR0A
#define UART0_UBRRH UBRR0H #define UART0_CONTROL UCSR0B
#define UART0_BIT_URSEL URSEL0 #define UART0_CONTROLC UCSR0C
#define UART0_BIT_U2X U2X0 #define UART0_DATA UDR0
#define UART0_BIT_RXCIE RXCIE0 #define UART0_UDRIE UDRIE0
#define UART0_BIT_RXEN RXEN0 #define UART0_UBRRL UBRR0L
#define UART0_BIT_TXEN TXEN0 #define UART0_UBRRH UBRR0H
#define UART0_BIT_UCSZ0 UCSZ00 #define UART0_BIT_URSEL URSEL0
#define UART0_BIT_UCSZ1 UCSZ01 #define UART0_BIT_U2X U2X0
#define UART1_STATUS UCSR1A #define UART0_BIT_RXCIE RXCIE0
#define UART1_CONTROL UCSR1B #define UART0_BIT_RXEN RXEN0
#define UART1_CONTROLC UCSR1C #define UART0_BIT_TXEN TXEN0
#define UART1_DATA UDR1 #define UART0_BIT_UCSZ0 UCSZ00
#define UART1_UDRIE UDRIE1 #define UART0_BIT_UCSZ1 UCSZ01
#define UART1_UBRRL UBRR1L #define UART1_STATUS UCSR1A
#define UART1_UBRRH UBRR1H #define UART1_CONTROL UCSR1B
#define UART1_BIT_URSEL URSEL1 #define UART1_CONTROLC UCSR1C
#define UART1_BIT_U2X U2X1 #define UART1_DATA UDR1
#define UART1_BIT_RXCIE RXCIE1 #define UART1_UDRIE UDRIE1
#define UART1_BIT_RXEN RXEN1 #define UART1_UBRRL UBRR1L
#define UART1_BIT_TXEN TXEN1 #define UART1_UBRRH UBRR1H
#define UART1_BIT_UCSZ0 UCSZ10 #define UART1_BIT_URSEL URSEL1
#define UART1_BIT_UCSZ1 UCSZ11 #define UART1_BIT_U2X U2X1
#define UART1_BIT_RXCIE RXCIE1 #define UART1_BIT_RXCIE RXCIE1
/* ATmega with UART */ #define UART1_BIT_RXEN RXEN1
#error "AVR ATmega161 currently not supported by this libaray !" #define UART1_BIT_TXEN TXEN1
#define UART1_BIT_UCSZ0 UCSZ10 #define UART1_BIT_UCSZ0 UCSZ10
/* ATmega with one USART */ #define UART1_BIT_UCSZ1 UCSZ11
#define UART0_RECEIVE_INTERRUPT USART0_RX_vect #elif defined(__AVR_ATmega161__)
#define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect /* ATmega with UART */
#define UART0_STATUS UCSRA #error "AVR ATmega161 currently not supported by this libaray !"
#define UART0_CONTROL UCSRB #elif defined(__AVR_ATmega169__)
#define UART0_CONTROLC UCSRC /* ATmega with one USART */
#define UART0_DATA UDR #define UART0_RECEIVE_INTERRUPT USART0_RX_vect
#define UART0_UDRIE UDRIE #define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect
#define UART0_UBRRL UBRRL #define UART0_STATUS UCSRA
#define UART0_UBRRH UBRRH #define UART0_CONTROL UCSRB
#define UART0_BIT_U2X U2X #define UART0_CONTROLC UCSRC
#define UART0_BIT_RXCIE RXCIE #define UART0_DATA UDR
#define UART0_BIT_RXEN RXEN #define UART0_UDRIE UDRIE
#define UART0_BIT_TXEN TXEN #define UART0_UBRRL UBRRL
#define UART0_BIT_UCSZ0 UCSZ0 #define UART0_UBRRH UBRRH
#define UART0_BIT_UCSZ1 UCSZ1 #define UART0_BIT_U2X U2X
#elif defined(__AVR_ATmega48__) || defined(__AVR_ATmega48A__) || defined(__AVR_ATmega48P__) || defined(__AVR_ATmega48PA__) || defined(__AVR_ATmega48PB__) || \ #define UART0_BIT_RXCIE RXCIE
defined(__AVR_ATmega88__) || defined(__AVR_ATmega88A__) || defined(__AVR_ATmega88P__) || defined(__AVR_ATmega88PA__) || defined(__AVR_ATmega88PB__) || \ #define UART0_BIT_RXEN RXEN
defined(__AVR_ATmega168__) || defined(__AVR_ATmega168A__)|| defined(__AVR_ATmega168P__)|| defined(__AVR_ATmega168PA__) || defined(__AVR_ATmega168PB__) || \ #define UART0_BIT_TXEN TXEN
defined(__AVR_ATmega328__) || defined(__AVR_ATmega328P__) || \ #define UART0_BIT_UCSZ0 UCSZ0
defined(__AVR_ATmega3250__) || defined(__AVR_ATmega3290__) ||defined(__AVR_ATmega6450__) || defined(__AVR_ATmega6490__) #define UART0_BIT_UCSZ1 UCSZ1
/* ATmega with one USART */ #elif defined(__AVR_ATmega48__) || defined(__AVR_ATmega48A__) || defined(__AVR_ATmega48P__) || \
#define UART0_RECEIVE_INTERRUPT USART_RX_vect defined(__AVR_ATmega48PA__) || defined(__AVR_ATmega48PB__) || defined(__AVR_ATmega88__) || \
#define UART0_TRANSMIT_INTERRUPT USART_UDRE_vect defined(__AVR_ATmega88A__) || defined(__AVR_ATmega88P__) || defined(__AVR_ATmega88PA__) || \
#define UART0_STATUS UCSR0A defined(__AVR_ATmega88PB__) || defined(__AVR_ATmega168__) || defined(__AVR_ATmega168A__) || \
#define UART0_CONTROL UCSR0B defined(__AVR_ATmega168P__) || defined(__AVR_ATmega168PA__) || defined(__AVR_ATmega168PB__) || \
#define UART0_CONTROLC UCSR0C defined(__AVR_ATmega328__) || defined(__AVR_ATmega328P__) || defined(__AVR_ATmega3250__) || \
#define UART0_DATA UDR0 defined(__AVR_ATmega3290__) || defined(__AVR_ATmega6450__) || defined(__AVR_ATmega6490__)
#define UART0_UDRIE UDRIE0 /* ATmega with one USART */
#define UART0_UBRRL UBRR0L #define UART0_RECEIVE_INTERRUPT USART_RX_vect
#define UART0_UBRRH UBRR0H #define UART0_TRANSMIT_INTERRUPT USART_UDRE_vect
#define UART0_BIT_U2X U2X0 #define UART0_STATUS UCSR0A
#define UART0_BIT_RXCIE RXCIE0 #define UART0_CONTROL UCSR0B
#define UART0_BIT_RXEN RXEN0 #define UART0_CONTROLC UCSR0C
#define UART0_BIT_TXEN TXEN0 #define UART0_DATA UDR0
#define UART0_BIT_UCSZ0 UCSZ00 #define UART0_UDRIE UDRIE0
#define UART0_BIT_UCSZ1 UCSZ01 #define UART0_UBRRL UBRR0L
#define UART0_UBRRH UBRR0H
#define UART0_BIT_U2X U2X0
#define UART0_BIT_RXCIE RXCIE0 #define UART0_BIT_RXCIE RXCIE0
/* ATtiny with one USART */ #define UART0_BIT_RXEN RXEN0
#define UART0_RECEIVE_INTERRUPT USART_RX_vect #define UART0_BIT_TXEN TXEN0
#define UART0_TRANSMIT_INTERRUPT USART_UDRE_vect #define UART0_BIT_UCSZ0 UCSZ00
#define UART0_STATUS UCSRA #define UART0_BIT_UCSZ1 UCSZ01
#define UART0_CONTROL UCSRB #elif defined(__AVR_ATtiny2313__) || defined(__AVR_ATtiny2313A__) || defined(__AVR_ATtiny4313__)
#define UART0_CONTROLC UCSRC /* ATtiny with one USART */
#define UART0_DATA UDR #define UART0_RECEIVE_INTERRUPT USART_RX_vect
#define UART0_UDRIE UDRIE #define UART0_TRANSMIT_INTERRUPT USART_UDRE_vect
#define UART0_UBRRL UBRRL #define UART0_STATUS UCSRA
#define UART0_UBRRH UBRRH #define UART0_CONTROL UCSRB
#define UART0_BIT_U2X U2X #define UART0_CONTROLC UCSRC
#define UART0_BIT_RXCIE RXCIE #define UART0_DATA UDR
#define UART0_BIT_RXEN RXEN #define UART0_UDRIE UDRIE
#define UART0_BIT_TXEN TXEN #define UART0_UBRRL UBRRL
#define UART0_BIT_UCSZ0 UCSZ0 #define UART0_UBRRH UBRRH
#define UART0_BIT_UCSZ1 UCSZ1 #define UART0_BIT_U2X U2X
#elif defined(__AVR_ATmega329__) || defined(__AVR_ATmega649__) || defined(__AVR_ATmega3290__) || defined(__AVR_ATmega6490__) ||\ #define UART0_BIT_RXCIE RXCIE
defined(__AVR_ATmega169A__) || defined(__AVR_ATmega169PA__) || \ #define UART0_BIT_RXEN RXEN
defined(__AVR_ATmega329A__) || defined(__AVR_ATmega329PA__) || defined(__AVR_ATmega3290A__) || defined(__AVR_ATmega3290PA__) || \ #define UART0_BIT_TXEN TXEN
defined(__AVR_ATmega649A__) || defined(__AVR_ATmega649P__) || defined(__AVR_ATmega6490A__) || defined(__AVR_ATmega6490P__) || \ #define UART0_BIT_UCSZ0 UCSZ0
defined(__AVR_ATmega165__) || defined(__AVR_ATmega325__) || defined(__AVR_ATmega645__) || defined(__AVR_ATmega3250__) || defined(__AVR_ATmega6450__) || \ #define UART0_BIT_UCSZ1 UCSZ1
defined(__AVR_ATmega165A__) || defined(__AVR_ATmega165PA__) || \ #elif defined(__AVR_ATmega329__) || defined(__AVR_ATmega649__) || defined(__AVR_ATmega3290__) || \
defined(__AVR_ATmega325A__) || defined(__AVR_ATmega325PA__) || defined(__AVR_ATmega3250A__) || defined(__AVR_ATmega3250PA__) ||\ defined(__AVR_ATmega6490__) || defined(__AVR_ATmega169A__) || defined(__AVR_ATmega169PA__) || \
defined(__AVR_ATmega645A__) || defined(__AVR_ATmega645PA__) || defined(__AVR_ATmega6450A__) || defined(__AVR_ATmega6450PA__) || \ defined(__AVR_ATmega329A__) || defined(__AVR_ATmega329PA__) || defined(__AVR_ATmega3290A__) || \
defined(__AVR_ATmega644__) defined(__AVR_ATmega3290PA__) || defined(__AVR_ATmega649A__) || defined(__AVR_ATmega649P__) || \
/* ATmega with one USART */ defined(__AVR_ATmega6490A__) || defined(__AVR_ATmega6490P__) || defined(__AVR_ATmega165__) || \
#define UART0_RECEIVE_INTERRUPT USART0_RX_vect defined(__AVR_ATmega325__) || defined(__AVR_ATmega645__) || defined(__AVR_ATmega3250__) || \
#define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect defined(__AVR_ATmega6450__) || defined(__AVR_ATmega165A__) || defined(__AVR_ATmega165PA__) || \
#define UART0_STATUS UCSR0A defined(__AVR_ATmega325A__) || defined(__AVR_ATmega325PA__) || defined(__AVR_ATmega3250A__) || \
#define UART0_CONTROL UCSR0B defined(__AVR_ATmega3250PA__) || defined(__AVR_ATmega645A__) || defined(__AVR_ATmega645PA__) || \
#define UART0_CONTROLC UCSR0C defined(__AVR_ATmega6450A__) || defined(__AVR_ATmega6450PA__) || defined(__AVR_ATmega644__)
#define UART0_DATA UDR0 /* ATmega with one USART */
#define UART0_UDRIE UDRIE0 #define UART0_RECEIVE_INTERRUPT USART0_RX_vect
#define UART0_UBRRL UBRR0L #define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect
#define UART0_UBRRH UBRR0H #define UART0_STATUS UCSR0A
#define UART0_BIT_U2X U2X0 #define UART0_CONTROL UCSR0B
#define UART0_BIT_RXCIE RXCIE0 #define UART0_CONTROLC UCSR0C
#define UART0_BIT_RXEN RXEN0 #define UART0_DATA UDR0
#define UART0_BIT_TXEN TXEN0 #define UART0_UDRIE UDRIE0
#define UART0_BIT_UCSZ0 UCSZ00 #define UART0_UBRRL UBRR0L
#define UART0_BIT_UCSZ1 UCSZ01 #define UART0_UBRRH UBRR0H
#elif defined(__AVR_ATmega64__) || defined(__AVR_ATmega128__) || defined(__AVR_ATmega128A__) ||\ #define UART0_BIT_U2X U2X0
defined(__AVR_ATmega640__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2560__) || defined(__AVR_ATmega2561__) || \ #define UART0_BIT_RXCIE RXCIE0
defined(__AVR_ATmega164P__) || defined(__AVR_ATmega324P__) || defined(__AVR_ATmega644P__) || \ #define UART0_BIT_RXEN RXEN0
defined(__AVR_ATmega164A__) || defined(__AVR_ATmega164PA__) || defined(__AVR_ATmega324A__) || defined(__AVR_ATmega324PA__) || \ #define UART0_BIT_TXEN TXEN0
defined(__AVR_ATmega644A__) || defined(__AVR_ATmega644PA__) || defined(__AVR_ATmega1284__) || defined(__AVR_ATmega1284P__) ||\ #define UART0_BIT_UCSZ0 UCSZ00
defined(__AVR_ATtiny1634__) #define UART0_BIT_UCSZ1 UCSZ01
/* ATmega with two USART */ #elif defined(__AVR_ATmega64__) || defined(__AVR_ATmega128__) || defined(__AVR_ATmega128A__) || \
#define ATMEGA_USART1 defined(__AVR_ATmega640__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega1281__) || \
#define UART0_RECEIVE_INTERRUPT USART0_RX_vect defined(__AVR_ATmega2560__) || defined(__AVR_ATmega2561__) || defined(__AVR_ATmega164P__) || \
#define UART1_RECEIVE_INTERRUPT USART1_RX_vect defined(__AVR_ATmega324P__) || defined(__AVR_ATmega644P__) || defined(__AVR_ATmega164A__) || \
#define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect defined(__AVR_ATmega164PA__) || defined(__AVR_ATmega324A__) || defined(__AVR_ATmega324PA__) || \
#define UART1_TRANSMIT_INTERRUPT USART1_UDRE_vect defined(__AVR_ATmega644A__) || defined(__AVR_ATmega644PA__) || defined(__AVR_ATmega1284__) || \
#define UART0_STATUS UCSR0A defined(__AVR_ATmega1284P__) || defined(__AVR_ATtiny1634__)
#define UART0_CONTROL UCSR0B /* ATmega with two USART */
#define UART0_CONTROLC UCSR0C #define ATMEGA_USART1
#define UART0_DATA UDR0 #define UART0_RECEIVE_INTERRUPT USART0_RX_vect
#define UART0_UDRIE UDRIE0 #define UART1_RECEIVE_INTERRUPT USART1_RX_vect
#define UART0_UBRRL UBRR0L #define UART0_TRANSMIT_INTERRUPT USART0_UDRE_vect
#define UART0_UBRRH UBRR0H #define UART1_TRANSMIT_INTERRUPT USART1_UDRE_vect
#define UART0_BIT_U2X U2X0 #define UART0_STATUS UCSR0A
#define UART0_BIT_RXCIE RXCIE0 #define UART0_CONTROL UCSR0B
#define UART0_BIT_RXEN RXEN0 #define UART0_CONTROLC UCSR0C
#define UART0_BIT_TXEN TXEN0 #define UART0_DATA UDR0
#define UART0_BIT_UCSZ0 UCSZ00 #define UART0_UDRIE UDRIE0
#define UART0_BIT_UCSZ1 UCSZ01 #define UART0_UBRRL UBRR0L
#define UART1_STATUS UCSR1A #define UART0_UBRRH UBRR0H
#define UART1_CONTROL UCSR1B #define UART0_BIT_U2X U2X0
#define UART1_CONTROLC UCSR1C #define UART0_BIT_RXCIE RXCIE0
#define UART1_DATA UDR1 #define UART0_BIT_RXEN RXEN0
#define UART1_UDRIE UDRIE1 #define UART0_BIT_TXEN TXEN0
#define UART1_UBRRL UBRR1L #define UART0_BIT_UCSZ0 UCSZ00
#define UART1_UBRRH UBRR1H #define UART0_BIT_UCSZ1 UCSZ01
#define UART1_BIT_U2X U2X1 #define UART1_STATUS UCSR1A
#define UART1_BIT_RXCIE RXCIE1 #define UART1_CONTROL UCSR1B
#define UART1_BIT_RXEN RXEN1 #define UART1_CONTROLC UCSR1C
#define UART1_BIT_TXEN TXEN1 #define UART1_DATA UDR1
#define UART1_BIT_UCSZ0 UCSZ10 #define UART1_UDRIE UDRIE1
#define UART1_BIT_UCSZ1 UCSZ11 #define UART1_UBRRL UBRR1L
#define UART1_UBRRH UBRR1H
#define UART1_BIT_U2X U2X1
#define UART1_BIT_RXCIE RXCIE1 #define UART1_BIT_RXCIE RXCIE1
defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__) || \ #define UART1_BIT_RXEN RXEN1
defined(__AVR_AT90USB82__) || defined(__AVR_AT90USB162__) || \ #define UART1_BIT_TXEN TXEN1
defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__) || defined(__AVR_AT90USB647__) || defined(__AVR_AT90USB1287__) #define UART1_BIT_UCSZ0 UCSZ10
#define UART0_RECEIVE_INTERRUPT USART1_RX_vect #define UART1_BIT_UCSZ1 UCSZ11
#define UART0_TRANSMIT_INTERRUPT USART1_UDRE_vect #elif defined(__AVR_ATmega8U2__) || defined(__AVR_ATmega16U2__) || defined(__AVR_ATmega32U2__) || \
#define UART0_STATUS UCSR1A defined(__AVR_ATmega16U4__) || defined(__AVR_ATmega32U4__) || defined(__AVR_AT90USB82__) || \
#define UART0_CONTROL UCSR1B defined(__AVR_AT90USB162__) || defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__) || \
#define UART0_CONTROLC UCSR1C defined(__AVR_AT90USB647__) || defined(__AVR_AT90USB1287__)
#define UART0_DATA UDR1 #define UART0_RECEIVE_INTERRUPT USART1_RX_vect
#define UART0_UDRIE UDRIE1 #define UART0_TRANSMIT_INTERRUPT USART1_UDRE_vect
#define UART0_UBRRL UBRR1L #define UART0_STATUS UCSR1A
#define UART0_UBRRH UBRR1H #define UART0_CONTROL UCSR1B
#define UART0_BIT_U2X U2X1 #define UART0_CONTROLC UCSR1C
#define UART0_BIT_RXCIE RXCIE1 #define UART0_DATA UDR1
#define UART0_BIT_RXEN RXEN1 #define UART0_UDRIE UDRIE1
#define UART0_BIT_TXEN TXEN1 #define UART0_UBRRL UBRR1L
#define UART0_BIT_UCSZ0 UCSZ10 #define UART0_UBRRH UBRR1H
#define UART0_BIT_UCSZ1 UCSZ11 #define UART0_BIT_U2X U2X1
#define UART0_BIT_RXCIE RXCIE1 #define UART0_BIT_RXCIE RXCIE1
#error "no UART definition for MCU available" #define UART0_BIT_RXEN RXEN1
#define UART0_BIT_TXEN TXEN1 #define UART0_BIT_TXEN TXEN1
#define UART0_BIT_UCSZ0 UCSZ10 #define UART0_BIT_UCSZ0 UCSZ10
#define UART0_BIT_UCSZ1 UCSZ11 #define UART0_BIT_UCSZ1 UCSZ11
#else #else
#error "no UART definition for MCU available" #error "no UART definition for MCU available"
@@ -347,7 +345,7 @@ static volatile unsigned char UART_RxHead;
static volatile unsigned char UART_TxBuf[UART_TX_BUFFER_SIZE]; static volatile unsigned char UART_TxBuf[UART_TX_BUFFER_SIZE];
static volatile unsigned char UART_RxBuf[UART_RX_BUFFER_SIZE]; static volatile unsigned char UART_RxBuf[UART_RX_BUFFER_SIZE];
static volatile unsigned char UART_TxHead; static volatile unsigned char UART_TxHead;
#if defined( ATMEGA_USART1 ) static volatile unsigned char UART_TxTail;
static volatile unsigned char UART_RxHead; static volatile unsigned char UART_RxHead;
static volatile unsigned char UART_RxTail; static volatile unsigned char UART_RxTail;
static volatile unsigned char UART_LastRxError; static volatile unsigned char UART_LastRxError;
@@ -357,9 +355,7 @@ static volatile unsigned char UART1_RxTail;
static volatile unsigned char UART1_RxBuf[UART_RX_BUFFER_SIZE]; static volatile unsigned char UART1_RxBuf[UART_RX_BUFFER_SIZE];
static volatile unsigned char UART1_TxHead; static volatile unsigned char UART1_TxHead;
static volatile unsigned char UART1_TxTail; static volatile unsigned char UART1_TxTail;
static volatile unsigned char UART1_RxHead;
ISR (UART0_RECEIVE_INTERRUPT)
static volatile unsigned char UART1_RxTail; static volatile unsigned char UART1_RxTail;
static volatile unsigned char UART1_LastRxError; static volatile unsigned char UART1_LastRxError;
#endif #endif
@@ -370,29 +366,28 @@ Purpose: called when the UART has received a character
Purpose: called when the UART has received a character Purpose: called when the UART has received a character
**************************************************************************/ **************************************************************************/
{ {
unsigned char tmphead; unsigned char tmphead;
unsigned char data; unsigned char data;
unsigned char usr; unsigned char usr;
unsigned char lastRxError; unsigned char lastRxError;
/* read UART status register and UART data register */ /* read UART status register and UART data register */
lastRxError = usr & (_BV(FE)|_BV(DOR)|_BV(UPE) ); usr = UART0_STATUS;
data = UART0_DATA; data = UART0_DATA;
lastRxError = usr & (_BV(FE0)|_BV(DOR0)|_BV(UPE0) );
/* get FEn (Frame Error) DORn (Data OverRun) UPEn (USART Parity Error) bits */ /* get FEn (Frame Error) DORn (Data OverRun) UPEn (USART Parity Error) bits */
lastRxError = usr & (_BV(FE1)|_BV(DOR1)|_BV(UPE1) ); #if defined(FE) && defined(DOR) && defined(UPE)
lastRxError = usr & (_BV(FE) | _BV(DOR) | _BV(UPE)); lastRxError = usr & (_BV(FE) | _BV(DOR) | _BV(UPE));
lastRxError = usr & (_BV(FE)|_BV(DOR) ); #elif defined(FE0) && defined(DOR0) && defined(UPE0)
lastRxError = usr & (_BV(FE0) | _BV(DOR0) | _BV(UPE0)); lastRxError = usr & (_BV(FE0) | _BV(DOR0) | _BV(UPE0));
#elif defined(FE1) && defined(DOR1) && defined(UPE1) #elif defined(FE1) && defined(DOR1) && defined(UPE1)
lastRxError = usr & (_BV(FE1) | _BV(DOR1) | _BV(UPE1)); lastRxError = usr & (_BV(FE1) | _BV(DOR1) | _BV(UPE1));
tmphead = ( UART_RxHead + 1) & UART_RX_BUFFER_MASK; #elif defined(FE) && defined(DOR)
lastRxError = usr & (_BV(FE) | _BV(DOR)); lastRxError = usr & (_BV(FE) | _BV(DOR));
if ( tmphead == UART_RxTail ) { #endif
/* calculate buffer index */ /* calculate buffer index */
}else{ tmphead = (UART_RxHead + 1) & UART_RX_BUFFER_MASK;
if (tmphead == UART_RxTail) { if (tmphead == UART_RxTail) {
/* error: receive buffer overflow */ /* error: receive buffer overflow */
@@ -401,8 +396,7 @@ Purpose: called when the UART has received a character
/* store new index */ /* store new index */
UART_RxHead = tmphead; UART_RxHead = tmphead;
/* store received data in buffer */ /* store received data in buffer */
UART_RxBuf[tmphead] = data;
ISR (UART0_TRANSMIT_INTERRUPT)
} }
UART_LastRxError |= lastRxError; UART_LastRxError |= lastRxError;
} }
@@ -410,20 +404,18 @@ Purpose: called when the UART is ready to transmit the next byte
ISR(UART0_TRANSMIT_INTERRUPT) ISR(UART0_TRANSMIT_INTERRUPT)
/************************************************************************* /*************************************************************************
Function: UART Data Register Empty interrupt Function: UART Data Register Empty interrupt
Purpose: called when the UART is ready to transmit the next byte
if ( UART_TxHead != UART_TxTail) {
**************************************************************************/ **************************************************************************/
{ {
unsigned char tmptail; unsigned char tmptail;
if (UART_TxHead != UART_TxTail) { if (UART_TxHead != UART_TxTail) {
}else{ /* calculate and store new buffer index */
tmptail = (UART_TxTail + 1) & UART_TX_BUFFER_MASK; tmptail = (UART_TxTail + 1) & UART_TX_BUFFER_MASK;
UART_TxTail = tmptail; UART_TxTail = tmptail;
/* get one byte from buffer and write it to UART */ /* get one byte from buffer and write it to UART */
UART0_DATA = UART_TxBuf[tmptail]; /* start transmission */ UART0_DATA = UART_TxBuf[tmptail]; /* start transmission */
} else { } else {
/* tx buffer empty, disable UDRE interrupt */ /* tx buffer empty, disable UDRE interrupt */
UART0_CONTROL &= ~_BV(UART0_UDRIE); UART0_CONTROL &= ~_BV(UART0_UDRIE);
} }
@@ -455,31 +447,29 @@ void uart_init(unsigned int baudrate)
#if defined(URSEL) || defined(URSEL0) #if defined(URSEL) || defined(URSEL0)
#ifndef UART0_BIT_URSEL #ifndef UART0_BIT_URSEL
#warning "UART0_BIT_URSEL not defined" #warning "UART0_BIT_URSEL not defined"
if ( baudrate & 0x8000 ) #endif
{ #endif
#if UART0_BIT_U2X #endif
UART0_STATUS = (1<<UART0_BIT_U2X); //Enable 2x speed
#endif
/* Set baud rate */ /* Set baud rate */
#if defined(UART0_UBRRH) if (baudrate & 0x8000) {
UART0_UBRRH = (unsigned char)((baudrate>>8)&0x80) ; #if UART0_BIT_U2X
#endif UART0_STATUS = (1 << UART0_BIT_U2X); // Enable 2x speed
UART0_UBRRL = (unsigned char) (baudrate&0x00FF); #endif
} }
#if defined(UART0_UBRRH) #if defined(UART0_UBRRH)
UART0_CONTROL = _BV(UART0_BIT_RXCIE)|(1<<UART0_BIT_RXEN)|(1<<UART0_BIT_TXEN); UART0_UBRRH = (unsigned char)((baudrate >> 8) & 0x80);
#endif #endif
/* Set frame format: asynchronous, 8data, no parity, 1stop bit */ UART0_UBRRL = (unsigned char)(baudrate & 0x00FF);
#ifdef UART0_CONTROLC
#ifdef UART0_BIT_URSEL /* Enable USART receiver and transmitter and receive complete interrupt */
UART0_CONTROLC = (1<<UART0_BIT_URSEL)|(1<<UART0_BIT_UCSZ1)|(1<<UART0_BIT_UCSZ0); UART0_CONTROL = _BV(UART0_BIT_RXCIE) | (1 << UART0_BIT_RXEN) | (1 << UART0_BIT_TXEN);
#else
UART0_CONTROLC = (1<<UART0_BIT_UCSZ1)|(1<<UART0_BIT_UCSZ0); /* Set frame format: asynchronous, 8data, no parity, 1stop bit */
#endif #ifdef UART0_CONTROLC
#endif #ifdef UART0_BIT_URSEL
}/* uart_init */
UART0_CONTROLC = (1 << UART0_BIT_URSEL) | (1 << UART0_BIT_UCSZ1) | (1 << UART0_BIT_UCSZ0); UART0_CONTROLC = (1 << UART0_BIT_URSEL) | (1 << UART0_BIT_UCSZ1) | (1 << UART0_BIT_UCSZ0);
#else
UART0_CONTROLC = (1 << UART0_BIT_UCSZ1) | (1 << UART0_BIT_UCSZ0); UART0_CONTROLC = (1 << UART0_BIT_UCSZ1) | (1 << UART0_BIT_UCSZ0);
#endif #endif
#endif #endif
@@ -493,8 +483,7 @@ unsigned int uart_getc(void)
higher byte: last receive error higher byte: last receive error
**************************************************************************/ **************************************************************************/
unsigned int uart_getc(void) unsigned int uart_getc(void)
{
if ( UART_RxHead == UART_RxTail ) {
unsigned char tmptail; unsigned char tmptail;
unsigned char data; unsigned char data;
unsigned char lastRxError; unsigned char lastRxError;
@@ -511,8 +500,7 @@ unsigned int uart_getc(void)
lastRxError = UART_LastRxError; lastRxError = UART_LastRxError;
/* store buffer index */ /* store buffer index */
}/* uart_getc */ UART_RxTail = tmptail;
UART_LastRxError = 0; UART_LastRxError = 0;
return (lastRxError << 8) + data; return (lastRxError << 8) + data;
@@ -524,11 +512,10 @@ void uart_putc(unsigned char data)
Purpose: write byte to ringbuffer for transmitting via UART Purpose: write byte to ringbuffer for transmitting via UART
Input: byte to be transmitted Input: byte to be transmitted
Returns: none Returns: none
**************************************************************************/ **************************************************************************/
void uart_putc(unsigned char data) void uart_putc(unsigned char data)
while ( tmphead == UART_TxTail ){ {
;/* wait for free space in buffer */ unsigned char tmphead;
tmphead = (UART_TxHead + 1) & UART_TX_BUFFER_MASK; tmphead = (UART_TxHead + 1) & UART_TX_BUFFER_MASK;
@@ -537,8 +524,7 @@ void uart_putc(unsigned char data)
} }
UART_TxBuf[tmphead] = data; UART_TxBuf[tmphead] = data;
}/* uart_putc */ UART_TxHead = tmphead;
/* enable UDRE interrupt */ /* enable UDRE interrupt */
UART0_CONTROL |= _BV(UART0_UDRIE); UART0_CONTROL |= _BV(UART0_UDRIE);
@@ -546,13 +532,12 @@ Purpose: transmit string to UART
} /* uart_putc */ } /* uart_putc */
/************************************************************************* /*************************************************************************
void uart_puts(const char *s ) Function: uart_puts()
Purpose: transmit string to UART Purpose: transmit string to UART
Input: string to be transmitted Input: string to be transmitted
Returns: none Returns: none
**************************************************************************/ **************************************************************************/
}/* uart_puts */ void uart_puts(const char *s)
{ {
while (*s) while (*s)
uart_putc(*s++); uart_putc(*s++);
@@ -560,20 +545,19 @@ Purpose: transmit string from program memory to UART
} /* uart_puts */ } /* uart_puts */
/************************************************************************* /*************************************************************************
void uart_puts_p(const char *progmem_s ) Function: uart_puts_p()
Purpose: transmit string from program memory to UART Purpose: transmit string from program memory to UART
Input: program memory string to be transmitted Input: program memory string to be transmitted
Returns: none Returns: none
while ( (c = pgm_read_byte(progmem_s++)) ) **************************************************************************/
void uart_puts_p(const char *progmem_s) void uart_puts_p(const char *progmem_s)
{ {
}/* uart_puts_p */ register char c;
while ((c = pgm_read_byte(progmem_s++))) while ((c = pgm_read_byte(progmem_s++)))
uart_putc(c); uart_putc(c);
#if defined( ATMEGA_USART1 ) } /* uart_puts_p */
/* /*
* these functions are only for ATmegas with two USART * these functions are only for ATmegas with two USART
@@ -586,21 +570,20 @@ Purpose: called when the UART1 has received a character
Purpose: called when the UART1 has received a character Purpose: called when the UART1 has received a character
**************************************************************************/ **************************************************************************/
{ {
unsigned char tmphead; unsigned char tmphead;
unsigned char data; unsigned char data;
unsigned char usr; unsigned char usr;
unsigned char lastRxError; unsigned char lastRxError;
lastRxError = usr & (_BV(FE1)|_BV(DOR1)|_BV(UPE1) ); /* read UART status register and UART data register */
usr = UART1_STATUS; usr = UART1_STATUS;
data = UART1_DATA; data = UART1_DATA;
tmphead = ( UART1_RxHead + 1) & UART_RX_BUFFER_MASK;
/* get FEn (Frame Error) DORn (Data OverRun) UPEn (USART Parity Error) bits */ /* get FEn (Frame Error) DORn (Data OverRun) UPEn (USART Parity Error) bits */
if ( tmphead == UART1_RxTail ) { lastRxError = usr & (_BV(FE1) | _BV(DOR1) | _BV(UPE1));
/* calculate buffer index */ /* calculate buffer index */
}else{ tmphead = (UART1_RxHead + 1) & UART_RX_BUFFER_MASK;
if (tmphead == UART1_RxTail) { if (tmphead == UART1_RxTail) {
/* error: receive buffer overflow */ /* error: receive buffer overflow */
@@ -609,7 +592,6 @@ Purpose: called when the UART1 has received a character
/* store new index */ /* store new index */
UART1_RxHead = tmphead; UART1_RxHead = tmphead;
/* store received data in buffer */ /* store received data in buffer */
UART1_RxBuf[tmphead] = data; UART1_RxBuf[tmphead] = data;
} }
UART1_LastRxError |= lastRxError; UART1_LastRxError |= lastRxError;
@@ -618,20 +600,18 @@ Purpose: called when the UART1 is ready to transmit the next byte
ISR(UART1_TRANSMIT_INTERRUPT) ISR(UART1_TRANSMIT_INTERRUPT)
/************************************************************************* /*************************************************************************
Function: UART1 Data Register Empty interrupt Function: UART1 Data Register Empty interrupt
Purpose: called when the UART1 is ready to transmit the next byte
if ( UART1_TxHead != UART1_TxTail) {
**************************************************************************/ **************************************************************************/
{ {
unsigned char tmptail; unsigned char tmptail;
if (UART1_TxHead != UART1_TxTail) { if (UART1_TxHead != UART1_TxTail) {
}else{ /* calculate and store new buffer index */
tmptail = (UART1_TxTail + 1) & UART_TX_BUFFER_MASK; tmptail = (UART1_TxTail + 1) & UART_TX_BUFFER_MASK;
UART1_TxTail = tmptail; UART1_TxTail = tmptail;
/* get one byte from buffer and write it to UART */ /* get one byte from buffer and write it to UART */
UART1_DATA = UART1_TxBuf[tmptail]; /* start transmission */ UART1_DATA = UART1_TxBuf[tmptail]; /* start transmission */
} else { } else {
/* tx buffer empty, disable UDRE interrupt */ /* tx buffer empty, disable UDRE interrupt */
UART1_CONTROL &= ~_BV(UART1_UDRIE); UART1_CONTROL &= ~_BV(UART1_UDRIE);
} }
@@ -663,27 +643,25 @@ void uart1_init(unsigned int baudrate)
#if defined(URSEL) || defined(URSEL1) #if defined(URSEL) || defined(URSEL1)
#ifndef UART1_BIT_URSEL #ifndef UART1_BIT_URSEL
#warning "UART1_BIT_URSEL not defined" #warning "UART1_BIT_URSEL not defined"
if ( baudrate & 0x8000 ) #endif
{ #endif
#if UART1_BIT_U2X #endif
UART1_STATUS = (1<<UART1_BIT_U2X); //Enable 2x speed
#endif
/* Set baud rate */ /* Set baud rate */
UART1_UBRRH = (unsigned char)((baudrate>>8)&0x80) ; if (baudrate & 0x8000) {
UART1_UBRRL = (unsigned char) baudrate; #if UART1_BIT_U2X
UART1_STATUS = (1 << UART1_BIT_U2X); // Enable 2x speed UART1_STATUS = (1 << UART1_BIT_U2X); // Enable 2x speed
#endif #endif
UART1_CONTROL = _BV(UART1_BIT_RXCIE)|(1<<UART1_BIT_RXEN)|(1<<UART1_BIT_TXEN); }
UART1_UBRRH = (unsigned char)((baudrate >> 8) & 0x80); UART1_UBRRH = (unsigned char)((baudrate >> 8) & 0x80);
/* Set frame format: asynchronous, 8data, no parity, 1stop bit */ UART1_UBRRL = (unsigned char)baudrate;
#ifdef UART1_BIT_URSEL
UART1_CONTROLC = (1<<UART1_BIT_URSEL)|(1<<UART1_BIT_UCSZ1)|(1<<UART1_BIT_UCSZ0); /* Enable USART receiver and transmitter and receive complete interrupt */
#else UART1_CONTROL = _BV(UART1_BIT_RXCIE) | (1 << UART1_BIT_RXEN) | (1 << UART1_BIT_TXEN);
UART1_CONTROLC = (1<<UART1_BIT_UCSZ1)|(1<<UART1_BIT_UCSZ0);
#endif /* Set frame format: asynchronous, 8data, no parity, 1stop bit */
}/* uart_init */
#ifdef UART1_BIT_URSEL #ifdef UART1_BIT_URSEL
UART1_CONTROLC = (1 << UART1_BIT_URSEL) | (1 << UART1_BIT_UCSZ1) | (1 << UART1_BIT_UCSZ0);
#else #else
UART1_CONTROLC = (1 << UART1_BIT_UCSZ1) | (1 << UART1_BIT_UCSZ0); UART1_CONTROLC = (1 << UART1_BIT_UCSZ1) | (1 << UART1_BIT_UCSZ0);
#endif #endif
@@ -697,8 +675,7 @@ unsigned int uart1_getc(void)
higher byte: last receive error higher byte: last receive error
**************************************************************************/ **************************************************************************/
unsigned int uart1_getc(void) unsigned int uart1_getc(void)
{
if ( UART1_RxHead == UART1_RxTail ) {
unsigned char tmptail; unsigned char tmptail;
unsigned int data; unsigned int data;
unsigned char lastRxError; unsigned char lastRxError;
@@ -715,8 +692,7 @@ unsigned int uart1_getc(void)
lastRxError = UART1_LastRxError; lastRxError = UART1_LastRxError;
/* store buffer index */ /* store buffer index */
}/* uart1_getc */ UART1_RxTail = tmptail;
UART1_LastRxError = 0; UART1_LastRxError = 0;
return (lastRxError << 8) + data; return (lastRxError << 8) + data;
@@ -728,11 +704,10 @@ void uart1_putc(unsigned char data)
Purpose: write byte to ringbuffer for transmitting via UART Purpose: write byte to ringbuffer for transmitting via UART
Input: byte to be transmitted Input: byte to be transmitted
Returns: none Returns: none
**************************************************************************/ **************************************************************************/
void uart1_putc(unsigned char data) void uart1_putc(unsigned char data)
while ( tmphead == UART1_TxTail ){ {
;/* wait for free space in buffer */ unsigned char tmphead;
tmphead = (UART1_TxHead + 1) & UART_TX_BUFFER_MASK; tmphead = (UART1_TxHead + 1) & UART_TX_BUFFER_MASK;
@@ -741,8 +716,7 @@ void uart1_putc(unsigned char data)
} }
UART1_TxBuf[tmphead] = data; UART1_TxBuf[tmphead] = data;
}/* uart1_putc */ UART1_TxHead = tmphead;
/* enable UDRE interrupt */ /* enable UDRE interrupt */
UART1_CONTROL |= _BV(UART1_UDRIE); UART1_CONTROL |= _BV(UART1_UDRIE);
@@ -750,13 +724,12 @@ Purpose: transmit string to UART1
} /* uart1_putc */ } /* uart1_putc */
/************************************************************************* /*************************************************************************
void uart1_puts(const char *s ) Function: uart1_puts()
Purpose: transmit string to UART1 Purpose: transmit string to UART1
Input: string to be transmitted Input: string to be transmitted
Returns: none Returns: none
**************************************************************************/ **************************************************************************/
}/* uart1_puts */ void uart1_puts(const char *s)
{ {
while (*s) while (*s)
uart1_putc(*s++); uart1_putc(*s++);
@@ -764,14 +737,13 @@ Purpose: transmit string from program memory to UART1
} /* uart1_puts */ } /* uart1_puts */
/************************************************************************* /*************************************************************************
void uart1_puts_p(const char *progmem_s ) Function: uart1_puts_p()
Purpose: transmit string from program memory to UART1 Purpose: transmit string from program memory to UART1
Input: program memory string to be transmitted Input: program memory string to be transmitted
Returns: none Returns: none
while ( (c = pgm_read_byte(progmem_s++)) ) **************************************************************************/
void uart1_puts_p(const char *progmem_s) void uart1_puts_p(const char *progmem_s)
{ {
}/* uart1_puts_p */ register char c;
while ((c = pgm_read_byte(progmem_s++))) while ((c = pgm_read_byte(progmem_s++)))

31
uart.h
View File

@@ -46,33 +46,30 @@ LICENSE:
* @copyright (C) 2015 Peter Fleury, GNU General Public License Version 3 * @copyright (C) 2015 Peter Fleury, GNU General Public License Version 3
*/ */
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#if (__GNUC__ * 100 + __GNUC_MINOR__) < 405 #if (__GNUC__ * 100 + __GNUC_MINOR__) < 405
#error "This library requires AVR-GCC 4.5 or later, update to newer AVR-GCC compiler !" #error "This library requires AVR-GCC 4.5 or later, update to newer AVR-GCC compiler !"
#endif #endif
/**@{*/ /**@{*/
/* /*
** constants and macros ** constants and macros
*/ */
/** @brief UART Baudrate Expression /** @brief UART Baudrate Expression
* @param xtalCpu system clock in Mhz, e.g. 4000000UL for 4Mhz * @param xtalCpu system clock in Mhz, e.g. 4000000UL for 4Mhz
* @param baudRate baudrate in bps, e.g. 1200, 2400, 9600 * @param baudRate baudrate in bps, e.g. 1200, 2400, 9600
*/ */
#define UART_BAUD_SELECT(baudRate,xtalCpu) (((xtalCpu) + 8UL * (baudRate)) / (16UL * (baudRate)) -1UL) #define UART_BAUD_SELECT(baudRate, xtalCpu) (((xtalCpu) + 8UL * (baudRate)) / (16UL * (baudRate)) - 1UL)
/** @brief UART Baudrate Expression for ATmega double speed mode /** @brief UART Baudrate Expression for ATmega double speed mode
* @param xtalCpu system clock in Mhz, e.g. 4000000UL for 4Mhz * @param xtalCpu system clock in Mhz, e.g. 4000000UL for 4Mhz
* @param baudRate baudrate in bps, e.g. 1200, 2400, 9600 * @param baudRate baudrate in bps, e.g. 1200, 2400, 9600
*/ */
#define UART_BAUD_SELECT_DOUBLE_SPEED(baudRate,xtalCpu) ( ((((xtalCpu) + 4UL * (baudRate)) / (8UL * (baudRate)) -1UL)) | 0x8000) #define UART_BAUD_SELECT_DOUBLE_SPEED(baudRate, xtalCpu) \
(((((xtalCpu) + 4UL * (baudRate)) / (8UL * (baudRate)) - 1UL)) | 0x8000)
/** @brief Size of the circular receive buffer, must be power of 2 /** @brief Size of the circular receive buffer, must be power of 2
* *
@@ -93,7 +90,7 @@ LICENSE:
#endif #endif
/* test if the size of the circular buffers fits into SRAM */ /* test if the size of the circular buffers fits into SRAM */
#if ( (UART_RX_BUFFER_SIZE+UART_TX_BUFFER_SIZE) >= (RAMEND-0x60 ) ) #if ((UART_RX_BUFFER_SIZE + UART_TX_BUFFER_SIZE) >= (RAMEND - 0x60))
#error "size of UART_RX_BUFFER_SIZE + UART_TX_BUFFER_SIZE larger than size of SRAM" #error "size of UART_RX_BUFFER_SIZE + UART_TX_BUFFER_SIZE larger than size of SRAM"
#endif #endif
@@ -106,7 +103,6 @@ LICENSE:
#define UART_BUFFER_OVERFLOW 0x0200 /**< @brief receive ringbuffer overflow */ #define UART_BUFFER_OVERFLOW 0x0200 /**< @brief receive ringbuffer overflow */
#define UART_NO_DATA 0x0100 /**< @brief no receive data available */ #define UART_NO_DATA 0x0100 /**< @brief no receive data available */
/* /*
** function prototypes ** function prototypes
*/ */
@@ -118,7 +114,6 @@ LICENSE:
*/ */
extern void uart_init(unsigned int baudrate); extern void uart_init(unsigned int baudrate);
/** /**
* @brief Get received byte from ringbuffer * @brief Get received byte from ringbuffer
* *
@@ -145,7 +140,6 @@ extern void uart_init(unsigned int baudrate);
*/ */
extern unsigned int uart_getc(void); extern unsigned int uart_getc(void);
/** /**
* @brief Put byte to ringbuffer for transmitting via UART * @brief Put byte to ringbuffer for transmitting via UART
* @param data byte to be transmitted * @param data byte to be transmitted
@@ -153,7 +147,6 @@ extern unsigned int uart_getc(void);
*/ */
extern void uart_putc(unsigned char data); extern void uart_putc(unsigned char data);
/** /**
* @brief Put string to ringbuffer for transmitting via UART * @brief Put string to ringbuffer for transmitting via UART
* *
@@ -164,8 +157,7 @@ extern void uart_putc(unsigned char data);
* @param s string to be transmitted * @param s string to be transmitted
* @return none * @return none
*/ */
extern void uart_puts(const char *s ); extern void uart_puts(const char *s);
/** /**
* @brief Put string from program memory to ringbuffer for transmitting via UART. * @brief Put string from program memory to ringbuffer for transmitting via UART.
@@ -178,15 +170,13 @@ extern void uart_puts(const char *s );
* @return none * @return none
* @see uart_puts_P * @see uart_puts_P
*/ */
extern void uart_puts_p(const char *s ); extern void uart_puts_p(const char *s);
/** /**
* @brief Macro to automatically put a string constant into program memory * @brief Macro to automatically put a string constant into program memory
*/ */
#define uart_puts_P(__s) uart_puts_p(PSTR(__s)) #define uart_puts_P(__s) uart_puts_p(PSTR(__s))
/** @brief Initialize USART1 (only available on selected ATmegas) @see uart_init */ /** @brief Initialize USART1 (only available on selected ATmegas) @see uart_init */
extern void uart1_init(unsigned int baudrate); extern void uart1_init(unsigned int baudrate);
/** @brief Get received byte of USART1 from ringbuffer. (only available on selected ATmega) @see uart_getc */ /** @brief Get received byte of USART1 from ringbuffer. (only available on selected ATmega) @see uart_getc */
@@ -194,14 +184,13 @@ extern unsigned int uart1_getc(void);
/** @brief Put byte to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_putc */ /** @brief Put byte to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_putc */
extern void uart1_putc(unsigned char data); extern void uart1_putc(unsigned char data);
/** @brief Put string to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_puts */ /** @brief Put string to ringbuffer for transmitting via USART1 (only available on selected ATmega) @see uart_puts */
extern void uart1_puts(const char *s ); 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 */ /** @brief Put string from program memory to ringbuffer for transmitting via USART1 (only available on selected ATmega)
extern void uart1_puts_p(const char *s ); * @see uart_puts_p */
extern void uart1_puts_p(const char *s);
/** @brief Macro to automatically put a string constant into program memory */ /** @brief Macro to automatically put a string constant into program memory */
#define uart1_puts_P(__s) uart1_puts_p(PSTR(__s)) #define uart1_puts_P(__s) uart1_puts_p(PSTR(__s))
/**@}*/ /**@}*/
#endif // UART_H #endif // UART_H