/**************************************************************************** * * Copyright (c) 2006 Dave Hylands * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * Alternatively, this software may be distributed under the terms of BSD * license. * * See README and COPYING for more details. * ****************************************************************************/ /** * * @file UART.h * * @brief This file implements the interrupt drive UART class. * ****************************************************************************/ #if !defined( UART_H ) #define UART_H ///< Include Guard // ---- Include Files ------------------------------------------------------- #include #include #include "CBUF.h" #include "Config.h" #if defined( __AVR_LIBC_VERSION__ ) # include #endif #if defined( __cplusplus ) extern "C" { #endif //--------------------------------------------------------------------------- // // To use this header file the following #defines should be made in Config.h // Replace the x by a 0 or a 1. // // CFG_USE_UARTx 0 or 1 Controls if anything relating to that UART is generated // // CFG_UARTx_RX_BUFFER_SIZE How many bytes to put in the Rx buffer. // Setting the buffer size to zero, means that // no buffers will be alllocated and a callback // must be provided to deal with each received // character. // // CFG_UARTx_TX_BUFFER_SIZE How many bytes to put in the Tx buffer. // Setting this to zero will cause polled routines // to be used. // // CFG_UARTx_ECHO_INPUT causes data received by UARTx_GetChar to be // echoed. This is useful if the uart is connected // to s termnal program and being used to prompt // the user for input. // // CFG_UARTx_CR_TO_LF Translate received CRs to LFs. This allows // the input to be compatible with fgets // // CFG_UARTx_LF_TO_CRLF Translate sent LFs to CRLFs. Useful when // using a terminal program. // // API Provided: // // int UARTx_GetChar( void ); // int UARTx_IsCharAvailable(); // void UARTx_SetRxHandler( void (*rxHandler)( uint8_t ch )); // int UARTx_PutChar( char ch ); // void UARTx_PutStr( const char *s ); // void UARTx_Write( const void *data, uint8_t len ); // // Note: To allow the code to be compatible with single UART processors // CFG_USE_UART can be defined instead of CFG_USE_UARTx and then // The x (the uart number) can be dropped. // //--------------------------------------------------------------------------- #if defined( CFG_USE_UART ) # if defined( CFG_USE_UART0 ) || defined( CFG_USE_UART1 ) # error CFG_USE_UART is incompatible with CFG_USE_UART0 or CFG_USE_UART1 # endif # if !defined( CFG_UART_RX_BUFFER_SIZE ) # error CFG_UART_RX_BUFFER_SIZE isnt defined. # endif # if !defined( CFG_UART_TX_BUFFER_SIZE ) # error CFG_UART_TX_BUFFER_SIZE isnt declared. # endif # define CFG_USE_UART0 CFG_USE_UART # define CFG_UART0_RX_BUFFER_SIZE CFG_UART_RX_BUFFER_SIZE # define CFG_UART0_TX_BUFFER_SIZE CFG_UART_TX_BUFFER_SIZE # define CFG_UART0_LF_TO_CRLF CFG_UART_LF_TO_CRLF # define CFG_UART0_ECHO_INPUT CFG_UART_ECHO_INPUT # define CFG_UART0_CR_TO_LF CFG_UART_CR_TO_LF # define UART_GetChar UART0_GetChar # define UART_IsCharAvailable UART0_IsCharAvailable # define UART_SetRxHandler UART0_SetRxHandler # define UART_PutChar UART0_PutChar # define UART_PutStr UART0_PutStr # define UART_Write UART0_Write # define UART_GetCharStdio UART0_GetCharStdio # define UART_PutCharStdio UART0_PutCharStdio #endif // CFG_USE_UART #if !defined( CFG_USE_UART0 ) && !defined( CFG_USE_UART1 ) # error Expecting one of CFG_USE_UART0 or CFG_USE_UART1 to be defined #endif #if CFG_USE_UART0 // These defines allow this file to work with AVRs which only have one UART // (i.e ATMega8, 16, 32) #if !defined( UCSR0A ) #define UCSR0A UCSRA #define UCSR0B UCSRB #define UCSR0C UCSRC #define UBRR0H UBRRH #define UBRR0L UBRRL #define UDR0 UDR #define UDRIE0 UDRIE #define UDRE0 UDRE #endif #if defined( SIG_UART_RECV ) # define SIG_USART0_RECV SIG_UART_RECV # define SIG_USART0_DATA SIG_UART_DATA #elif defined( SIG_USART_RECV ) # define SIG_USART0_RECV SIG_USART_RECV # define SIG_USART0_DATA SIG_USART_DATA #elif !defined( SIG_USART0_RECV ) # define SIG_USART0_RECV SIG_USART_RECV # define SIG_USART0_DATA SIG_USART_DATA #endif //--------------------------------------------------------------------------- #if !defined( CFG_UART0_RX_BUFFER_SIZE ) # error CFG_UART0_RX_BUFFER_SIZE isnt defined. #endif #if (( CFG_UART0_RX_BUFFER_SIZE > 0 ) && (( CFG_UART0_RX_BUFFER_SIZE & ( CFG_UART0_RX_BUFFER_SIZE - 1 )) != 0 )) # error CFG_UART0_RX_BUFFER_SIZE isnt a power of 2. #endif #if ( CFG_UART0_RX_BUFFER_SIZE > 128 ) typedef uint16_t UART0_RxIndex_t; #else typedef uint8_t UART0_RxIndex_t; #endif #if ( CFG_UART0_RX_BUFFER_SIZE > 0 ) typedef struct { UART0_RxIndex_t m_getIdx; UART0_RxIndex_t m_putIdx; uint8_t m_entry[ CFG_UART0_RX_BUFFER_SIZE ]; } UART0_RxBuffer_t; #if defined( __AVR_LIBC_VERSION__ ) int UART0_GetCharStdio( FILE *fs ); #else #define UART0_GetCharStdio UART0_GetChar #endif int UART0_GetChar( void ); #define gUart0RxBuf_SIZE sizeof( gUart0RxBuf.m_entry ) extern volatile UART0_RxBuffer_t gUart0RxBuf; #define UART0_IsCharAvailable() (!CBUF_IsEmpty( gUart0RxBuf )) #else void UART0_SetRxHandler( void (*rxHandler)( uint8_t ch )); #endif //--------------------------------------------------------------------------- #if !defined( CFG_UART0_TX_BUFFER_SIZE ) # error CFG_UART0_TX_BUFFER_SIZE isnt declared. #endif #if (( CFG_UART0_TX_BUFFER_SIZE & ( CFG_UART0_TX_BUFFER_SIZE - 1 )) != 0 ) # error CFG_UART0_TX_BUFFER_SIZE isnt a power of 2. #endif #if ( CFG_UART0_TX_BUFFER_SIZE > 128 ) typedef uint16_t UART0_TxIndex_t; #else typedef uint8_t UART0_TxIndex_t; #endif #if ( CFG_UART0_TX_BUFFER_SIZE > 0 ) typedef struct { UART0_TxIndex_t m_getIdx; UART0_TxIndex_t m_putIdx; uint8_t m_entry[ CFG_UART0_TX_BUFFER_SIZE ]; } UART0_TxBuffer_t; #define gUart0TxBuf_SIZE sizeof( gUart0TxBuf.m_entry ) extern volatile UART0_TxBuffer_t gUart0TxBuf; #endif //--------------------------------------------------------------------------- #if defined( __AVR_LIBC_VERSION__ ) int UART0_PutCharStdio( char ch, FILE *fs ); #else #define UART0_PutCharStdio UART0_PutChar #endif int UART0_PutChar( char ch ); void UART0_PutStr( const char *s ); void UART0_Write( const void *data, uint8_t len ); #endif // CFG_USE_UART0 //=========================================================================== #if CFG_USE_UART1 //--------------------------------------------------------------------------- #if !defined( CFG_UART1_RX_BUFFER_SIZE ) # error CFG_UART1_RX_BUFFER_SIZE isnt defined. #endif #if (( CFG_UART1_RX_BUFFER_SIZE > 0 ) && (( CFG_UART1_RX_BUFFER_SIZE & ( CFG_UART1_RX_BUFFER_SIZE - 1 )) != 0 )) # error CFG_UART1_RX_BUFFER_SIZE isnt a power of 2. #endif #if ( CFG_UART1_RX_BUFFER_SIZE > 128 ) typedef uint16_t UART1_RxIndex_t; #else typedef uint8_t UART1_RxIndex_t; #endif #if ( CFG_UART1_RX_BUFFER_SIZE > 0 ) typedef struct { UART1_RxIndex_t m_getIdx; UART1_RxIndex_t m_putIdx; uint8_t m_entry[ CFG_UART1_RX_BUFFER_SIZE ]; } UART1_RxBuffer_t; #if defined( __AVR_LIBC_VERSION__ ) int UART1_GetCharStdio( FILE *fs ); #else #define UART1_GetCharStdio UART1_GetChar #endif int UART1_GetChar( void ); #define gUart1RxBuf_SIZE sizeof( gUart1RxBuf.m_entry ) extern volatile UART1_RxBuffer_t gUart1RxBuf; #define UART1_IsCharAvailable() (!CBUF_IsEmpty( gUart1RxBuf )) #else void UART1_SetRxHandler( void (*rxHandler)( uint8_t ch )); #endif //--------------------------------------------------------------------------- #if !defined( CFG_UART1_TX_BUFFER_SIZE ) # error CFG_UART1_TX_BUFFER_SIZE isnt declared. #endif #if (( CFG_UART1_TX_BUFFER_SIZE & ( CFG_UART1_TX_BUFFER_SIZE - 1 )) != 0 ) # error CFG_UART1_TX_BUFFER_SIZE isnt a power of 2. #endif #if ( CFG_UART1_TX_BUFFER_SIZE > 128 ) typedef uint16_t UART1_TxIndex_t; #else typedef uint8_t UART1_TxIndex_t; #endif #if ( CFG_UART1_TX_BUFFER_SIZE > 0 ) typedef struct { UART1_TxIndex_t m_getIdx; UART1_TxIndex_t m_putIdx; uint8_t m_entry[ CFG_UART1_TX_BUFFER_SIZE ]; } UART1_TxBuffer_t; #define gUart1TxBuf_SIZE sizeof( gUart1TxBuf.m_entry ) extern volatile UART1_TxBuffer_t gUart1TxBuf; #endif //--------------------------------------------------------------------------- #if defined( __AVR_LIBC_VERSION__ ) int UART1_PutCharStdio( char ch, FILE *fs ); #else #define UART1_PutCharStdio UART1_PutChar #endif int UART1_PutChar( char ch ); void UART1_PutStr( const char *s ); void UART1_Write( const void *data, uint8_t len ); #endif // CFG_USE_UART1 #if defined( __cplusplus ) } #endif /** @} */ #endif // UART_H