Subversion Repositories Projects

Rev

Blame | Last modification | View Log | RSS feed

/*************************************************************************
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.6.2.2 2009/11/29 08:56:12 Peter Exp $
Software: AVR-GCC 4.1, AVR Libc 1.4.6 or higher
Hardware: any AVR with built-in UART,
License:  GNU General Public License

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

LICENSE:
    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.

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


#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <string.h>
#include <stdbool.h>
#include "uart1.h"
#include "main.h"
#include "bluetooth.h"
#include "tracking.h"
//
//  constants and macros
//
#if defined HWVERSION1_3W || defined HWVERSION3_9

// 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


// ATmega with two USART

#define ATMEGA_USART1

#define UART1_STATUS   UCSR1A
#define UART1_CONTROL  UCSR1B
#define UART1_DATA     UDR1
#define UART1_UDRIE    UDRIE1



//
//  module global variables
//

uint8_t receiveNMEA = false;


#if defined( ATMEGA_USART1 )
static volatile unsigned char UART1_TxBuf[UART_TX_BUFFER_SIZE];
static volatile unsigned char UART1_RxBuf[UART_RX_BUFFER_SIZE];
static volatile unsigned char UART1_TxHead;
static volatile unsigned char UART1_TxTail;
static volatile unsigned char UART1_RxHead;
static volatile unsigned char UART1_RxTail;
static volatile unsigned char UART1_LastRxError;
#endif




//
// these functions are only for ATmegas with two USART
//


#if defined( ATMEGA_USART1 )

//--------------------------------------------------------------
// Function: UART1 Receive Complete interrupt
// Purpose:  called when the UART1 has received a character
//--------------------------------------------------------------
ISR(USART1_RX_vect)
{
        unsigned char tmphead;
        unsigned char data;
        unsigned char usr;
        unsigned char 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_RX_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;

#if defined HWVERSION3_9

        if (receiveNMEA==true)
          {
            if (bt_receiveNMEA()) Tracking_NMEA();

          }
#endif
}


//--------------------------------------------------------------
// Function: UART1 Data Register Empty interrupt
// Purpose:  called when the UART1 is ready to transmit the next byte
//--------------------------------------------------------------
ISR(USART1_UDRE_vect)
{
        unsigned char tmptail;


        if ( UART1_TxHead != UART1_TxTail)
        {
                // calculate and store new buffer index
                tmptail = (UART1_TxTail + 1) & UART_TX_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(unsigned int baudrate)
{
        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 = (unsigned char)(baudrate>>8);
        UBRR1L = (unsigned char) 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
}


//--------------------------------------------------------------
// Function: uart1_getc()
// Purpose:  return byte from ringbuffer
// Returns:  lower byte:  received byte from ringbuffer
//           higher byte: last receive error
//--------------------------------------------------------------
unsigned int uart1_getc(void)
{
        unsigned char tmptail;
        unsigned char data;


        if ( UART1_RxHead == UART1_RxTail )
        {
                return UART_NO_DATA;   // no data available
        }

        // calculate /store buffer index
        tmptail = (UART1_RxTail + 1) & UART_RX_BUFFER_MASK;
        UART1_RxTail = tmptail;

        // get data from receive buffer
        data = UART1_RxBuf[tmptail];

        return (UART1_LastRxError << 8) + data;

}


//--------------------------------------------------------------
// Function: uart1_putc()
// Purpose:  write byte to ringbuffer for transmitting via UART
// Input:    byte to be transmitted
// Returns:  1 on succes, 0 if remote not ready
//--------------------------------------------------------------
int uart1_putc(unsigned char data)
{
        unsigned char tmphead;


        tmphead = (UART1_TxHead + 1) & UART_TX_BUFFER_MASK;

        while ( tmphead == UART1_TxTail )
        {;}  // wait for free space in buffer

        UART1_TxBuf[tmphead] = data;
        UART1_TxHead = tmphead;

        // enable UDRE interrupt
        UART1_CONTROL |= _BV(UART1_UDRIE);
        return (UART1_LastRxError << 8) + data;
}


//--------------------------------------------------------------
// 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++);
}


//--------------------------------------------------------------
// 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);
}


//--------------------------------------------------------------
// 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
//--------------------------------------------------------------
int uart1_available(void)
{
        return (UART_RX_BUFFER_MASK + UART1_RxHead - UART1_RxTail) % UART_RX_BUFFER_MASK;
}



//--------------------------------------------------------------
// Function: uart1_flush()
// Purpose:  Flush bytes waiting the receive buffer.  Acutally ignores them.
// Input:    None
// Returns:  None
//--------------------------------------------------------------
void uart1_flush(void)
{
        UART1_RxHead = UART1_RxTail;
}









#endif
#endif