---

uart.c

Go to the documentation of this file.

//*****************************************************************
//
// File Name    : 'uart.c'
// Title                        : UART driver with buffer support
// Author               : Pascal Stang - Copyright (C) 2000-2002
// Created              : 11/22/2000
// Revised              : 11/01/2001
// Version              : 1.3
// Target MCU   : ATMEL AVR Series
// Editor Tabs  : 3
//
// This code is distributed under the GNU Public License
//              which can be found at http://www.gnu.org/licenses/gpl.txt
//
//*****************************************************************

#include <io.h>
#include <interrupt.h>
#include <sig-avr.h>

#include "buffer.h"
#include "uart.h"

// UART global variables
// flag variables
volatile u08   uartReadyTx;
volatile u08   uartBufferedTx;
// receive and transmit buffers
cBuffer uartRxBuffer;
cBuffer uartTxBuffer;

// UART Transmit Complete Interrupt Function
SIGNAL(SIG_UART_TRANS)      
{
        // check if buffered tx is enabled
        if(uartBufferedTx)
        {
                // check if there's data left in the buffer
                if(uartTxBuffer.datalength)
                {
                        // send byte from top of buffer
                        outp( bufferGetFromFront(&uartTxBuffer), UDR );
                }
                else
                {
                        // no data left
                        uartBufferedTx = FALSE;
                        // return to ready state
                        uartReadyTx = TRUE;
                }
        }
        else
        {
                // we're using single-byte tx mode
                // indicate transmit complete, back to ready
                uartReadyTx = TRUE;
        }
}

// UART Receive Complete Interrupt Function
SIGNAL(SIG_UART_RECV)      
{
        // put received char in buffer
        // check if there's space
        if( !bufferAddToEnd(&uartRxBuffer, inp(UDR)) )
        {
                // no space - do something to signal an overflow
                //printfProgStrM("UART RX OVFL");
        }
}

void uartInitBuffers(void)
{
        // initialize the UART receive buffer
        bufferInit(&uartRxBuffer, (u08*) UART_RX_BUFFER_ADDR, UART_RX_BUFFER_SIZE);
        // initialize the UART transmit buffer
        bufferInit(&uartTxBuffer, (u08*) UART_TX_BUFFER_ADDR, UART_TX_BUFFER_SIZE);
}

void uartSetBaudRate(u16 baudrate)
{
        // calculate division factor for requested baud rate, and set it
        outp( (u08)((F_CPU+(baudrate*8L))/(baudrate*16L)-1), UBRR);
}

void uartInit(void)
{
        // initialize the buffers
        uartInitBuffers();

        // enable RxD/TxD and interrupts
        // this line for AT90S8515,8535,ATmega103,etc
        //outp(BV(RXCIE)|BV(TXCIE)|BV(RXEN)|BV(TXEN),UCR);
        // this line for the Mega163
        outp(BV(RXCIE)|BV(TXCIE)|BV(RXEN)|BV(TXEN),UCSRB);

        // set default baud rate
        uartSetBaudRate(UART_BAUD_RATE);  
        // enable interrupts
        sei();
        // initialize states
        uartReadyTx = TRUE;
}

cBuffer* uartGetRxBuffer(void)
{
        // return rx buffer pointer
        return &uartRxBuffer;
}

cBuffer* uartGetTxBuffer(void)
{
        // return tx buffer pointer
        return &uartTxBuffer;
}

void uartSendByte(u08 txData)
{
        // wait for the transmitter to be ready
        while(!uartReadyTx);
        // send byte
        outp( txData, UDR );
        // set ready state to FALSE
        uartReadyTx = FALSE;
}

u08 uartReceiveByte(u08* rxData)
{
        // make sure we have a receive buffer
        if(uartRxBuffer.size)
        {
                // make sure we have data
                if(uartRxBuffer.datalength)
                {
                        // get byte from beginning of buffer
                        *rxData = bufferGetFromFront(&uartRxBuffer);
                        return TRUE;
                }
                else
                {
                        // no data
                        return FALSE;
                }
        }
        else
        {
                // no buffer
                return FALSE;
        }
}

void uartFlushReceiveBuffer(void)
{
        // flush all data from receive buffer
        bufferFlush(&uartRxBuffer);
        // same effect as above
        // uartRxBuffer.datalength = 0;
}

u08 uartReceiveBufferIsEmpty(void)
{
        if(uartRxBuffer.datalength == 0)
        {
                return TRUE;
        }
        else
        {
                return FALSE;
        }
}

void uartSendTxBuffer(void)
{
        // turn on buffered transmit
        uartBufferedTx = TRUE;
        // send the first byte to get things going by interrupts
        uartSendByte(bufferGetFromFront(&uartTxBuffer));
}

u08 uartSendBuffer(char *buffer, u16 nBytes)
{
        register u08 first;
        register u16 i;

        // check if there's space (and that we have any bytes to send at all)
        if((uartTxBuffer.datalength + nBytes < uartTxBuffer.size) && nBytes)
        {
                // grab first character
                first = *buffer++;
                // copy user buffer to uart transmit buffer
                for(i = 0; i < nBytes-1; i++)
                {
                        // put data bytes at end of buffer
                        uartTxBuffer.dataptr[(uartTxBuffer.dataindex + uartTxBuffer.datalength) % uartTxBuffer.size] = *buffer++;
                        // increment the length
                        uartTxBuffer.datalength++;
                }

                // send the first byte to get things going by interrupts
                uartBufferedTx = TRUE;
                uartSendByte(first);
                // return success
                return TRUE;
        }
        else
        {
                // return failure
                return FALSE;
        }
}

---