Subversion Repositories HomeAutomation

/*************************************************************************

Title:     Interrupt UART library with receive/transmit circular buffers

Author:    Peter Fleury <pfleury@gmx.ch>   http://jump.to/fleury

File:      $Id: uart.c,v 1.5.2.2 2004/02/27 22:00:28 peter Exp $

Software:  AVR-GCC 3.3

Hardware:  any AVR with built-in UART,

           tested on AT90S8515 at 4 Mhz and ATmega at 1Mhz

Extensions:- uart_puti by M. Thomas 9/2004

           - uart_puthex_nibble and _byte by M.T. 9/2004

           - uart_putbin_byte by M.T. 1/2005

DESCRIPTION:

    An interrupt is generated when the UART has finished transmitting or

    receiving a byte. The interrupt handling routines use circular buffers

    for buffering received and transmitted data.

    The UART_RX_BUFFER_SIZE and UART_TX_BUFFER_SIZE variables define

    the buffer size in bytes. Note that these variables must be a

    power of 2.

USAGE:

    Refere to the header file uart.h for a description of the routines.

    See also example test_uart.c.

NOTES:

    Based on Atmel Application Note AVR306

*************************************************************************/

#include <stdlib.h>

#include <stdio.h>

#include <avr/io.h>

#include <avr/interrupt.h>

#include <avr/pgmspace.h>

#include <uart.h>

static int uart_putchar(char c, FILE *stream);

static FILE myStdOut = FDEV_SETUP_STREAM(uart_putchar, NULL,_FDEV_SETUP_WRITE);

static int uart_putchar(char c, FILE *stream) {

    if (c == '\n') uart_putchar('\r', stream);

    uart_putc(c);

    return 0;

}

/*

 *  constants and macros

 */

/* size of RX/TX buffers */

#define UART_RX_BUFFER_MASK ( UART_RX_BUFFER_SIZE - 1)

#define UART_TX_BUFFER_MASK ( UART_TX_BUFFER_SIZE - 1)

#if ( UART_RX_BUFFER_SIZE & UART_RX_BUFFER_MASK )

#error RX buffer size is not a power of 2

#endif

#if ( UART_TX_BUFFER_SIZE & UART_TX_BUFFER_MASK )

#error TX buffer size is not a power of 2

#endif

#if defined(__AVR_AT90S2313__) \

 || defined(__AVR_AT90S4414__) || defined(__AVR_AT90S4434__) \

 || defined(__AVR_AT90S8515__) || defined(__AVR_AT90S8535__)

 /* old AVR classic with one UART */

 #define AT90_UART

 #define UART0_RECEIVE_INTERRUPT   SIG_UART_RECV

 #define UART0_TRANSMIT_INTERRUPT  SIG_UART_DATA

 #define UART0_STATUS   USR

 #define UART0_CONTROL  UCR

 #define UART0_DATA     UDR  

 #define UART0_UDRIE    UDRIE

#elif defined(__AVR_AT90S2333__) || defined(__AVR_AT90S4433__)

 /* old AVR classic with one UART */

 #define AT90_UART

 #define UART0_RECEIVE_INTERRUPT   SIG_UART_RECV

 #define UART0_TRANSMIT_INTERRUPT  SIG_UART_DATA

 #define UART0_STATUS   UCSRA

 #define UART0_CONTROL  UCSRB

 #define UART0_DATA     UDR 

 #define UART0_UDRIE    UDRIE

#elif  defined(__AVR_ATmega8__)  || defined(__AVR_ATmega16__) || defined(__AVR_ATmega32__) \

  || defined(__AVR_ATmega8515__) || defined(__AVR_ATmega8535__) \

  || defined(__AVR_ATmega323__) 

  /* ATMega with one USART */

 #define ATMEGA_USART

 #define UART0_RECEIVE_INTERRUPT   SIG_UART_RECV

 #define UART0_TRANSMIT_INTERRUPT  SIG_UART_DATA

 #define UART0_STATUS   UCSRA

 #define UART0_CONTROL  UCSRB

 #define UART0_DATA     UDR

 #define UART0_UDRIE    UDRIE

#elif defined(__AVR_ATmega163__) 

  /* ATMega163 with one UART */

 #define ATMEGA_UART

 #define UART0_RECEIVE_INTERRUPT   SIG_UART_RECV

 #define UART0_TRANSMIT_INTERRUPT  SIG_UART_DATA

 #define UART0_STATUS   UCSRA

 #define UART0_CONTROL  UCSRB

 #define UART0_DATA     UDR

 #define UART0_UDRIE    UDRIE

#elif defined(__AVR_ATmega162__)

 /* ATMega with two USART */

 #define ATMEGA_USART0

 #define ATMEGA_USART1

 #define UART0_RECEIVE_INTERRUPT   SIG_USART0_RECV

 #define UART1_RECEIVE_INTERRUPT   SIG_USART1_RECV

 #define UART0_TRANSMIT_INTERRUPT  SIG_USART0_DATA

 #define UART1_TRANSMIT_INTERRUPT  SIG_USART1_DATA

 #define UART0_STATUS   UCSR0A

 #define UART0_CONTROL  UCSR0B

 #define UART0_DATA     UDR0

 #define UART0_UDRIE    UDRIE0

 #define UART1_STATUS   UCSR1A

 #define UART1_CONTROL  UCSR1B

 #define UART1_DATA     UDR1

 #define UART1_UDRIE    UDRIE1

#elif defined(__AVR_ATmega64__) || defined(__AVR_ATmega128__) 

 /* ATMega with two USART */

 #define ATMEGA_USART0

 #define ATMEGA_USART1

 #define UART0_RECEIVE_INTERRUPT   SIG_UART0_RECV

 #define UART1_RECEIVE_INTERRUPT   SIG_UART1_RECV

 #define UART0_TRANSMIT_INTERRUPT  SIG_UART0_DATA

 #define UART1_TRANSMIT_INTERRUPT  SIG_UART1_DATA

 #define UART0_STATUS   UCSR0A

 #define UART0_CONTROL  UCSR0B

 #define UART0_DATA     UDR0

 #define UART0_UDRIE    UDRIE0

 #define UART1_STATUS   UCSR1A

 #define UART1_CONTROL  UCSR1B

 #define UART1_DATA     UDR1

 #define UART1_UDRIE    UDRIE1

#elif defined(__AVR_ATmega103__)

 /* ATMega with one UART */

 #error "AVR ATmega103 currently not supported by this libaray !"

#elif defined(__AVR_ATmega161__)

 /* ATmega with UART */

 #error "AVR ATmega161 currently not supported by this libaray !"

#elif defined(__AVR_ATmega169__)

 #error "AVR ATmega169 currently not supported by this libaray !"

#endif

/*

 *  module global variables

 */

static volatile unsigned char UART_TxBuf[UART_TX_BUFFER_SIZE];

static volatile unsigned char UART_RxBuf[UART_RX_BUFFER_SIZE];

static volatile unsigned char UART_TxHead;

static volatile unsigned char UART_TxTail;

static volatile unsigned char UART_RxHead;

static volatile unsigned char UART_RxTail;

static volatile unsigned char UART_LastRxError;

ISR(UART0_RECEIVE_INTERRUPT)

/*************************************************************************

Function: UART Receive Complete interrupt

Purpose:  called when the UART has received a character

**************************************************************************/

{

    unsigned char tmphead;

    unsigned char data;

    unsigned char usr;

    unsigned char lastRxError;

    /* read UART status register and UART data register */

    usr  = UART0_STATUS;

    data = UART0_DATA;

    /* */

#if defined( AT90_UART )

    lastRxError = (usr & (_BV(FE)|_BV(DOR)) );

#elif defined( ATMEGA_USART )

    lastRxError = (usr & (_BV(FE)|_BV(DOR)) );

#elif defined( ATMEGA_USART0 )

    lastRxError = (usr & (_BV(FE0)|_BV(DOR0)) );

#elif defined ( ATMEGA_UART )

    lastRxError = (usr & (_BV(FE)|_BV(DOR)) );

#endif

    /* calculate buffer index */

    tmphead = ( UART_RxHead + 1) & UART_RX_BUFFER_MASK;

    if ( tmphead == UART_RxTail ) {

        /* error: receive buffer overflow */

        lastRxError = UART_BUFFER_OVERFLOW >> 8;

    }else{

        /* store new index */

        UART_RxHead = tmphead;

        /* store received data in buffer */

        UART_RxBuf[tmphead] = data;

    }

    UART_LastRxError = lastRxError;

}

ISR(UART0_TRANSMIT_INTERRUPT)

/*************************************************************************

Function: UART Data Register Empty interrupt

Purpose:  called when the UART is ready to transmit the next byte

**************************************************************************/

{

    unsigned char tmptail;

    if ( UART_TxHead != UART_TxTail) {

        /* calculate and store new buffer index */

        tmptail = (UART_TxTail + 1) & UART_TX_BUFFER_MASK;

        UART_TxTail = tmptail;

        /* get one byte from buffer and write it to UART */

        UART0_DATA = UART_TxBuf[tmptail];  /* start transmission */

    }else{

        /* tx buffer empty, disable UDRE interrupt */

        UART0_CONTROL &= ~_BV(UART0_UDRIE);

    }

}

/**

 * Wrapper function for uart_init.

 */

void UartInit() {

    uart_init((UART_BAUD_SELECT((BAUD),F_OSC)));

    stdout = &myStdOut;

}

/*************************************************************************

Function: uart_init()

Purpose:  initialize UART and set baudrate

Input:    baudrate using macro UART_BAUD_SELECT()

Returns:  none

**************************************************************************/

void uart_init(unsigned int baudrate)

{

    UART_TxHead = 0;

    UART_TxTail = 0;

    UART_RxHead = 0;

    UART_RxTail = 0;

#if defined( AT90_UART )

    /* set baud rate */

    UBRR = (unsigned char)baudrate;

    /* enable UART receiver and transmmitter and receive complete interrupt */

    UART0_CONTROL = _BV(RXCIE)|_BV(RXEN)|BV(TXEN);

#elif defined (ATMEGA_USART)

    /* Set baud rate */

    UBRRH = (unsigned char)(baudrate>>8);

    UBRRL = (unsigned char) baudrate;

    /* Enable USART receiver and transmitter and receive complete interrupt */

    UART0_CONTROL = _BV(RXCIE)|(1<<RXEN)|(1<<TXEN);

    /* Set frame format: asynchronous, 8data, no parity, 1stop bit */

    #ifdef URSEL

    UCSRC = (1<<URSEL)|(3<<UCSZ0);

    #else

    UCSRC = (3<<UCSZ0);

    #endif 

#elif defined (ATMEGA_USART0 )

    /* Set baud rate */

    UBRR0H = (unsigned char)(baudrate>>8);

    UBRR0L = (unsigned char) baudrate;

    /* Enable USART receiver and transmitter and receive complete interrupt */

    UART0_CONTROL = _BV(RXCIE0)|(1<<RXEN0)|(1<<TXEN0);

    /* Set frame format: asynchronous, 8data, no parity, 1stop bit */

    #ifdef URSEL0

    UCSR0C = (1<<URSEL0)|(3<<UCSZ00);

    #else

    UCSR0C = (3<<UCSZ00);

    #endif 

#elif defined ( ATMEGA_UART )

    /* set baud rate */

    UBRRHI = (unsigned char)(baudrate>>8);

    UBRR   = (unsigned char) baudrate;

    /* Enable UART receiver and transmitter and receive complete interrupt */

    UART0_CONTROL = _BV(RXCIE)|(1<<RXEN)|(1<<TXEN);

#endif

}/* uart_init */

/*************************************************************************

Function: uart_getc()

Purpose:  return byte from ringbuffer  

Returns:  lower byte:  received byte from ringbuffer

          higher byte: last receive error

**************************************************************************/

unsigned int uart_getc(void)

{    

    unsigned char tmptail;

    unsigned char data;

    if ( UART_RxHead == UART_RxTail ) {

        return UART_NO_DATA;   /* no data available */

    }

    /* calculate /store buffer index */

    tmptail = (UART_RxTail + 1) & UART_RX_BUFFER_MASK;

    UART_RxTail = tmptail;

    /* get data from receive buffer */

    data = UART_RxBuf[tmptail];

    return (UART_LastRxError << 8) + data;

}/* uart_getc */

/*************************************************************************

Function: uart_putc()

Purpose:  write byte to ringbuffer for transmitting via UART

Input:    byte to be transmitted

Returns:  none          

**************************************************************************/

void uart_putc(unsigned char data)

{

    unsigned char tmphead;

    tmphead  = (UART_TxHead + 1) & UART_TX_BUFFER_MASK;

    while ( tmphead == UART_TxTail ){

        ;/* wait for free space in buffer */

    }

    UART_TxBuf[tmphead] = data;

    UART_TxHead = tmphead;

    /* enable UDRE interrupt */

    UART0_CONTROL    |= _BV(UART0_UDRIE);

}/* uart_putc */

/*************************************************************************

Function: uart_puts()

Purpose:  transmit string to UART

Input:    string to be transmitted

Returns:  none          

**************************************************************************/

void uart_puts(const char *s )

{

    while (*s)

      uart_putc(*s++);

}/* uart_puts */

/*************************************************************************

Function: uart_puts_p()

Purpose:  transmit string from program memory to UART

Input:    program memory string to be transmitted

Returns:  none

**************************************************************************/

void uart_puts_p(const char *progmem_s )

{

    register char c;

    while ( (c = pgm_read_byte(progmem_s++)) )

      uart_putc(c);

}/* uart_puts_p */

/*************************************************************************

Function: uart_puti()

Purpose:  transmit integer as ASCII to UART

Input:    integer value

Returns:  none

This functions has been added by Martin Thomas <eversmith@heizung-thomas.de>

Don't blame P. Fleury if it doesn't work ;-)

**************************************************************************/

void uart_puti( const int val )

{

    char buffer[sizeof(int)*8+1];

    uart_puts( itoa(val, buffer, 10) );

}/* uart_puti */

/*************************************************************************

Function: uart_puthex_nibble()

Purpose:  transmit lower nibble as ASCII-hex to UART

Input:    byte value

Returns:  none

This functions has been added by Martin Thomas <eversmith@heizung-thomas.de>

Don't blame P. Fleury if it doesn't work ;-)

**************************************************************************/

void uart_puthex_nibble(const unsigned char b)

{

    unsigned char  c = b & 0x0f;

    if (c>9) c += 'A'-10;

    else c += '0';

    uart_putc(c);

} /* uart_puthex_nibble */

/*************************************************************************

Function: uart_puthex_byte()

Purpose:  transmit upper and lower nibble as ASCII-hex to UART

Input:    byte value

Returns:  none

This functions has been added by Martin Thomas <eversmith@heizung-thomas.de>

Don't blame P. Fleury if it doesn't work ;-)

**************************************************************************/

void uart_puthex_byte(const unsigned char  b)

{

    uart_puthex_nibble(b>>4);

    uart_puthex_nibble(b);

} /* uart_puthex_byte */

/*************************************************************************

Function: uart_putbin_byte()

Purpose:  transmit byte as ASCII-bin to UART

Input:    byte value

Returns:  none

This functions has been added by Martin Thomas <eversmith@heizung-thomas.de>

Don't blame P. Fleury if it doesn't work ;-)

**************************************************************************/

void uart_putbin_byte(const unsigned char b)

{

#if 0

    char buffer[sizeof(int)*8+1];

    uart_puts( itoa(b, buffer, 2) );

#else

    signed char i;

    for (i=7;i>=0;i--) {

        if (b & (1<<i)) {

            uart_putc('1');

        }

        else {

            uart_putc('0');

        }

    }

#endif

} /* uart_putbin_byte */