Subversion Repositories svnkaklik

/*! \file uart.c \brief UART driver with buffer support. */

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

//

// File Name	: 'uart.c'

// Title		: UART driver with buffer support

// Author		: Pascal Stang - Copyright (C) 2000-2002

// Created		: 11/22/2000

// Revised		: 06/09/2003

// Version		: 1.3

// Target MCU	: ATMEL AVR Series

// Editor Tabs	: 4

//

// This code is distributed under the GNU Public License

//		which can be found at http://www.gnu.org/licenses/gpl.txt

//

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

#include <avr/io.h>

#include <avr/interrupt.h>

#include "buffer.h"

#include "uart.h"

// UART global variables

// flag variables

volatile u08   uartReadyTx;			///< uartReadyTx flag

volatile u08   uartBufferedTx;		///< uartBufferedTx flag

// receive and transmit buffers

cBuffer uartRxBuffer;				///< uart receive buffer

cBuffer uartTxBuffer;				///< uart transmit buffer

unsigned short uartRxOverflow;		///< receive overflow counter

#ifndef UART_BUFFERS_EXTERNAL_RAM

	// using internal ram,

	// automatically allocate space in ram for each buffer

	static char uartRxData[UART_RX_BUFFER_SIZE];

	static char uartTxData[UART_TX_BUFFER_SIZE];

#endif

typedef void (*voidFuncPtru08)(unsigned char);

volatile static voidFuncPtru08 UartRxFunc;

// enable and initialize the uart

void uartInit(void)

{

	// initialize the buffers

	uartInitBuffers();

	// initialize user receive handler

	UartRxFunc = 0;

	// enable RxD/TxD and interrupts

	outb(UCR, BV(RXCIE)|BV(TXCIE)|BV(RXEN)|BV(TXEN));

	// set default baud rate

	uartSetBaudRate(UART_DEFAULT_BAUD_RATE);  

	// initialize states

	uartReadyTx = TRUE;

	uartBufferedTx = FALSE;

	// clear overflow count

	uartRxOverflow = 0;

	// enable interrupts

	sei();

}

// create and initialize the uart transmit and receive buffers

void uartInitBuffers(void)

{

	#ifndef UART_BUFFERS_EXTERNAL_RAM

		// initialize the UART receive buffer

		bufferInit(&uartRxBuffer, uartRxData, UART_RX_BUFFER_SIZE);

		// initialize the UART transmit buffer

		bufferInit(&uartTxBuffer, uartTxData, UART_TX_BUFFER_SIZE);

	#else

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

	#endif

}

// redirects received data to a user function

void uartSetRxHandler(void (*rx_func)(unsigned char c))

{

	// set the receive interrupt to run the supplied user function

	UartRxFunc = rx_func;

}

// set the uart baud rate

void uartSetBaudRate(u32 baudrate)

{

	// calculate division factor for requested baud rate, and set it

	u16 bauddiv = ((F_CPU+(baudrate*8L))/(baudrate*16L)-1);

	outb(UBRRL, bauddiv);

	#ifdef UBRRH

	outb(UBRRH, bauddiv>>8);

	#endif

}

// returns the receive buffer structure 

cBuffer* uartGetRxBuffer(void)

{

	// return rx buffer pointer

	return &uartRxBuffer;

}

// returns the transmit buffer structure 

cBuffer* uartGetTxBuffer(void)

{

	// return tx buffer pointer

	return &uartTxBuffer;

}

// transmits a byte over the uart

void uartSendByte(u08 txData)

{

	// wait for the transmitter to be ready

	while(!uartReadyTx);

	// send byte

	outb(UDR, txData);

	// set ready state to FALSE

	uartReadyTx = FALSE;

}

// gets a single byte from the uart receive buffer (getchar-style)

int uartGetByte(void)

{

	u08 c;

	if(uartReceiveByte(&c))

		return c;

	else

		return -1;

}

// gets a byte (if available) from the uart receive buffer

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;

	}

}

// flush all data out of the receive buffer

void uartFlushReceiveBuffer(void)

{

	// flush all data from receive buffer

	//bufferFlush(&uartRxBuffer);

	// same effect as above

	uartRxBuffer.datalength = 0;

}

// return true if uart receive buffer is empty

u08 uartReceiveBufferIsEmpty(void)

{

	if(uartRxBuffer.datalength == 0)

	{

		return TRUE;

	}

	else

	{

		return FALSE;

	}

}

// add byte to end of uart Tx buffer

u08 uartAddToTxBuffer(u08 data)

{

	// add data byte to the end of the tx buffer

	return bufferAddToEnd(&uartTxBuffer, data);

}

// start transmission of the current uart Tx buffer contents

void uartSendTxBuffer(void)

{

	// turn on buffered transmit

	uartBufferedTx = TRUE;

	// send the first byte to get things going by interrupts

	uartSendByte(bufferGetFromFront(&uartTxBuffer));

}

/*

// transmit nBytes from buffer out the uart

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

			bufferAddToEnd(&uartTxBuffer, *buffer++);

		}

		// send the first byte to get things going by interrupts

		uartBufferedTx = TRUE;

		uartSendByte(first);

		// return success

		return TRUE;

	}

	else

	{

		// return failure

		return FALSE;

	}

}

*/

// UART Transmit Complete Interrupt Handler

UART_INTERRUPT_HANDLER(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

			outb(UDR, bufferGetFromFront(&uartTxBuffer));

		}

		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 Handler

UART_INTERRUPT_HANDLER(SIG_UART_RECV)

{

	u08 c;

	// get received char

	c = inb(UDR);

	// if there's a user function to handle this receive event

	if(UartRxFunc)

	{

		// call it and pass the received data

		UartRxFunc(c);

	}

	else

	{

		// otherwise do default processing

		// put received char in buffer

		// check if there's space

		if( !bufferAddToEnd(&uartRxBuffer, c) )

		{

			// no space in buffer

			// count overflow

			uartRxOverflow++;

		}

	}

}