Subversion Repositories Projects

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

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.

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

//############################################################################

//# HISTORY  uart1.c

//#

//# 08.08.2015 CB

//# - chg: Umbau ISR(USART1_RX_vect) um Behandlung der NMEA Datensätze

//#

//# 06.08.2015 CB

//# - add: uint8_t receiveNMEA              // Flag zur Empfangssteuerung in ISR(USART1_RX_vect)

//# - add: Erweiterung ISR(USART1_RX_vect) um Behandlung der NMEA Datensätze

//#

//# 26.06.2014 OG

//# - del: receiveNMEA

//#

//# 04.07.2013 Cebra

//# - add: neue Funktion uart1_peek

//############################################################################

#include <avr/io.h>

#include <avr/interrupt.h>

#include <avr/pgmspace.h>

#include <string.h>

#include <stdbool.h>

#include "uart1.h"

#include "usart.h"

#include "../main.h"

#include "../bluetooth/bluetooth.h"

#include "../tracking/tracking.h"

#include "../avr-nmea-gps-library/nmea.h"

//

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

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

//

#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_RxTmpHead;

static volatile unsigned char UART1_RxTail;

static volatile unsigned char UART1_LastRxError;

static volatile unsigned char UART1_RxTmpHead;;

volatile uint16_t UART1_RxError;

#endif

volatile uint8_t UART1_receiveNMEA = false;

void SetBaudUart1(uint8_t Baudrate)

{

  switch (Baudrate)

  {

  case Baud_2400: uart1_init( UART_BAUD_SELECT(2400,F_CPU) );  break;

  case Baud_4800: uart1_init( UART_BAUD_SELECT(4800,F_CPU) );  break;

//  case Baud_9600: uart1_init( UART_BAUD_SELECT(9600,F_CPU) );  break;

  case Baud_9600: uart1_init( 129);  break;

  case Baud_19200: uart1_init( UART_BAUD_SELECT(19200,F_CPU) );  break;

  case Baud_38400: uart1_init( UART_BAUD_SELECT(38400,F_CPU) );  break;

  case Baud_57600: uart1_init( UART_BAUD_SELECT(57600,F_CPU) );  break;

//  case Baud_57600: uart1_init( 21);  break;

//  case Baud_115200: uart1_init( UART_BAUD_SELECT(115200,F_CPU) );  break;

  case Baud_115200: uart1_init( 10 );  break;

  }

}

//

// these functions are only for ATmegas with two USART

//

#if defined( ATMEGA_USART1 )

#if 0

//--------------------------------------------------------------

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

        UART1_RxError++;

    }

    else

    {

        // store new index

        UART1_RxHead = tmphead;

        // store received data in buffer

        UART1_RxBuf[tmphead] = data;

    }

    UART1_LastRxError = lastRxError;

}

#else

#warning Test neue UART ISR für NMEA

//--------------------------------------------------------------

// Function: UART1 Receive Complete interrupt, decode NMEA GPGGA

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

    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;

        UART1_RxError++;

    }

        else

          {

           if (UART1_receiveNMEA)

              {

               fusedata(data);                  // NMEA Daten bearbeiten

              }

          else  // if (UART1_receiveNMEA)

            {

                // store new index

                UART1_RxHead = tmphead;

                // store received data in buffer

                UART1_RxBuf[tmphead] = data;

            }

    }

    UART1_LastRxError = lastRxError;

}

////--------------------------------------------------------------

//// Function: UART1 Receive Complete interrupt, decode NMEA GPGGA

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

//

//    static volatile uint8_t GGA;

//    static char buffer[6];

//    static volatile uint8_t bufferindex;

//    static volatile uint8_t NMEAstart,NMEAend = false;

//

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

//        UART1_RxError++;

//    }

//    else

//      {

//        if (UART1_receiveNMEA)

//          {

//            cli();

//            switch(data)

//              {

//                case '$':                       //start of a packet

//

//                  if (!NMEAstart && GGA)         // falls mitten im  Datensatz eine neuer kommt, warum auch immer

//                    {

//                      // restore index, war kein GPGGA Datensatz

//                      UART1_RxHead = UART1_RxTmpHead;

//                      memset(buffer,0,6);

//                      bufferindex=0;                //wipe all these so they can be reused

//                    }

//                  NMEAstart = true;

//                  NMEAend = false;

//                  GGA=false;

//                  bufferindex=0;                //wipe all these so they can be reused

//

//                  UART1_RxTmpHead = tmphead-1;       // erstmal sichern, Start des NMEA Datensatzes

//                  // store new index, erstam in den Buffer schreiben

//                  UART1_RxHead = tmphead;

//                  // store received data in buffer

//                  UART1_RxBuf[tmphead] = data;

////                  USART_putc(data);

//                  sei();

//                  break;

//

//                default:                        //we have some of the CSV data

//                  if(bufferindex<6)             //dont mess up ! Dont overflow

//                  {

//                        buffer[bufferindex]=data;  //stick the character in our buffer

//                  }

//

//                  if(GGA)

//                    {

//                      // store new index, erstam in den Buffer schreiben

//                      UART1_RxHead = tmphead;

//                      // store received data in buffer

//                      UART1_RxBuf[tmphead] = data;

////                      USART_putc(data);

//

//

//                      switch ( data)

//                        {

//                         case '\r' :

//                             GGA = false;

//                             bufferindex=0;                //wipe all these so they can be reused

//                             NMEAstart = false;

//                             NMEAend = true;

//                             UART1_GPGGA++;

//                             memset(buffer,0,6);

//                             break;          // Ende mit NMEA Datensatz

//

//                         case '\n' :

//                             GGA = false;

//                             bufferindex=0;                //wipe all these so they can be reused

//                             NMEAstart = false;

//                             NMEAend = true;

//                             UART1_GPGGA++;

//                             memset(buffer,0,6);

//                             break;          // Ende mit NMEA Datensatz

//                        }

//

//                    }

//

//                  else if(NMEAstart)                  //the header, erstes Komma noch nicht gekommen

//

//                    {

//                      if(bufferindex<4)

//

//                        {

//                         bufferindex++;          //increase the position in the buffer

//

//                         // store new index, erstmal in den Buffer schreiben

//                         UART1_RxHead = tmphead;

//                         // store received data in buffer

//                         UART1_RxBuf[tmphead] = data;

////                         USART_putc(data);

//

//

//                        }

//                      else

//

//                        {

////                          cli();

//                          if(!strcmp(buffer,"GPGGA"))    //the last character will be a 0(end of string)

//

//                            {

//                             GGA=true;

//                             NMEAstart = false;

//                             // store new index, erstmal in den Buffer schreiben

//                             UART1_RxHead = tmphead;

//                             // store received data in buffer

//                             UART1_RxBuf[tmphead] = data;

////                             USART_putc(data);

////                             sei();

//                            }

//

//                          else

//

//                            {

//                             // restore index, war kein GPGGA Datensatz

//

//                             UART1_RxHead = UART1_RxTmpHead;

////                             commacount=0;

//                             memset(buffer,0,6);

//                             bufferindex=0;                //wipe all these so they can be reused

//                             NMEAstart = false;

////                             sei();

//                            }

//                        }

//                    }

//                      else if (!NMEAend && !GGA) UART1_RxHead = UART1_RxTmpHead; // Zeichen verwerfen

//

//              } // end switch (data)

//          }

//

//        else  // if (UART1_receiveNMEA)

//

//          {

//              // store new index

//              UART1_RxHead = tmphead;

//              // store received data in buffer

//              UART1_RxBuf[tmphead] = data;

//          }

//      }

//    UART1_LastRxError = lastRxError;

//}

#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;

    UART1_RxError = 0;

    UART1_receiveNMEA = false;  //Empfang von NMEA Daten aus

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

//  UCSR1C = (1<<UCSZ11) | (1<<UCSZ10); // 8data Bit

#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;

}/* uart1_getc */

//--------------------------------------------------------------

// Function: uart1_peek()

// Purpose:  Returns the next byte (character) of incoming serial data without removing it from the internal serial buffer

// Returns:  lower byte:  received byte from ringbuffer

//           higher byte: last receive error

//--------------------------------------------------------------

int uart1_peek(void)

{

        unsigned char tmptail;

        unsigned char data;

        if ( UART1_RxHead == UART1_RxTail )

        {

                return -1;   // no data available

        }

        // calculate /store buffer index

        tmptail = (UART1_RxTail + 1) & UART_RX_BUFFER_MASK;

        // get data from receive buffer

        data = UART1_RxBuf[tmptail];

        return (UART1_LastRxError << 8) + data;

}/* uart1_getc */

//int HardwareSerial::peek(void)

//{

//  if (_rx_buffer->head == _rx_buffer->tail) {

//    return -1;

//  } else {

//    return _rx_buffer->buffer[_rx_buffer->tail];

//  }

//}

//--------------------------------------------------------------

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

//--------------------------------------------------------------

uint16_t 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;

}

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

Function: utoa()

Purpose:  convert unsigned integer to ascii

Input:    string_buffer, string_buffer_size, unsigned integer value

Returns:  first ascii character

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

char *utoa1(char* buffer, const unsigned int size, unsigned int value)

{

  char *p;

  // p points to last char

  p = buffer+size-1;

  // Set terminating Zero

  *p='\0';

  do

  {

    *--p = value%10 + '0';

    value = value/10;

  } while (value!=0 && p>buffer);

  return p;

}/* utoa */

#endif

//#endif