Subversion Repositories svnkaklik

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

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

//

// File Name	: 'uart.h'

// Title		: UART driver with buffer support

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

// Created		: 11/22/2000

// Revised		: 02/01/2004

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

//

///	\ingroup driver_avr

/// \defgroup uart UART Driver/Function Library (uart.c)

/// \code #include "uart.h" \endcode

/// \par Overview

///		This library provides both buffered and unbuffered transmit and receive

///		functions for the AVR processor UART.� Buffered access means that the

///		UART can transmit and receive data in the "background", while your code

///		continues executing.� Also included are functions to initialize the

///		UART, set the baud rate, flush the buffers, and check buffer status.

///

/// \note	For full text output functionality, you may wish to use the rprintf

///		functions along with this driver.

///

/// \par About UART operations

///		Most Atmel AVR-series processors contain one or more hardware UARTs

///		(aka, serial ports).  UART serial ports can communicate with other 

///		serial ports of the same type, like those used on PCs.  In general,

///		UARTs are used to communicate with devices that are RS-232 compatible

///		(RS-232 is a certain kind of serial port).

///	\par

///		By far, the most common use for serial communications on AVR processors

///		is for sending information and data to a PC running a terminal program.

///		Here is an exmaple:

///	\code

/// uartInit();					// initialize UART (serial port)

/// uartSetBaudRate(9600);		// set UART speed to 9600 baud

/// rprintfInit(uartSendByte);  // configure rprintf to use UART for output

/// rprintf("Hello World\r\n");	// send "hello world" message via serial port

/// \endcode

///

/// \warning The CPU frequency (F_CPU) must be set correctly in \c global.h

///		for the UART library to calculate correct baud rates.  Furthermore,

///		certain CPU frequencies will not produce exact baud rates due to

///		integer frequency division round-off.  See your AVR processor's

///		 datasheet for full details.

//

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

//@{

#ifndef UART_H

#define UART_H

#include "global.h"

#include "buffer.h"

//! Default uart baud rate.

/// This is the default speed after a uartInit() command,

/// and can be changed by using uartSetBaudRate().

#define UART_DEFAULT_BAUD_RATE	9600

// buffer memory allocation defines

// buffer sizes

#ifndef UART_TX_BUFFER_SIZE

//! Number of bytes for uart transmit buffer.

/// Do not change this value in uart.h, but rather override

/// it with the desired value defined in your project's global.h

#define UART_TX_BUFFER_SIZE		0x0040

#endif

#ifndef UART_RX_BUFFER_SIZE

//! Number of bytes for uart receive buffer.

/// Do not change this value in uart.h, but rather override

/// it with the desired value defined in your project's global.h

#define UART_RX_BUFFER_SIZE		0x0040

#endif

// define this key if you wish to use

// external RAM for the	UART buffers

//#define UART_BUFFER_EXTERNAL_RAM

#ifdef UART_BUFFER_EXTERNAL_RAM

	// absolute address of uart buffers

	#define UART_TX_BUFFER_ADDR	0x1000

	#define UART_RX_BUFFER_ADDR	0x1100

#endif

//! Type of interrupt handler to use for uart interrupts.

/// Value may be SIGNAL or INTERRUPT.

/// \warning Do not change unless you know what you're doing.

#ifndef UART_INTERRUPT_HANDLER

#define UART_INTERRUPT_HANDLER	SIGNAL

#endif

// compatibility with most newer processors

#ifdef UCSRB

	#define UCR					UCSRB

#endif

// compatibility with old Mega processors

#if defined(UBRR) && !defined(UBRRL)

	#define	UBRRL				UBRR

#endif

// compatibility with megaXX8 processors

#if	defined(__AVR_ATmega88__)	|| \

	defined(__AVR_ATmega168__)	|| \

	defined(__AVR_ATmega644__)

	#define UDR					UDR0

	#define UCR					UCSR0B

	#define RXCIE				RXCIE0

	#define TXCIE				TXCIE0

	#define RXC					RXC0

	#define TXC					TXC0

	#define RXEN				RXEN0

	#define TXEN				TXEN0

	#define UBRRL				UBRR0L

	#define UBRRH				UBRR0H

	#define SIG_UART_TRANS		SIG_USART_TRANS

	#define SIG_UART_RECV		SIG_USART_RECV

	#define SIG_UART_DATA		SIG_USART_DATA

#endif

// compatibility with mega169 processors

#if	defined(__AVR_ATmega169__)

	#define SIG_UART_TRANS		SIG_USART_TRANS

	#define SIG_UART_RECV		SIG_USART_RECV

	#define SIG_UART_DATA		SIG_USART_DATA

#endif

// compatibility with dual-uart processors

// (if you need to use both uarts, please use the uart2 library)

#if defined(__AVR_ATmega161__)

	#define UDR					UDR0

	#define UCR					UCSR0B

	#define UBRRL				UBRR0

	#define SIG_UART_TRANS		SIG_UART0_TRANS

	#define SIG_UART_RECV		SIG_UART0_RECV

	#define SIG_UART_DATA		SIG_UART0_DATA

#endif

#if defined(__AVR_ATmega128__)

#ifdef UART_USE_UART1

	#define UDR					UDR1

	#define UCR					UCSR1B

	#define UBRRL				UBRR1L

	#define UBRRH				UBRR1H

	#define SIG_UART_TRANS		SIG_UART1_TRANS

	#define SIG_UART_RECV		SIG_UART1_RECV

	#define SIG_UART_DATA		SIG_UART1_DATA

#else

	#define UDR					UDR0

	#define UCR					UCSR0B

	#define UBRRL				UBRR0L

	#define UBRRH				UBRR0H

	#define SIG_UART_TRANS		SIG_UART0_TRANS

	#define SIG_UART_RECV		SIG_UART0_RECV

	#define SIG_UART_DATA		SIG_UART0_DATA

#endif

#endif

// functions

//! Initializes uart.

/// \note	After running this init function, the processor

/// I/O pins that used for uart communications (RXD, TXD)

/// are no long available for general purpose I/O.

void uartInit(void);

//! Initializes transmit and receive buffers.

/// Automatically called from uartInit()

void uartInitBuffers(void);

//! Redirects received data to a user function.

///

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

//! Sets the uart baud rate.

/// Argument should be in bits-per-second, like \c uartSetBaudRate(9600);

void uartSetBaudRate(u32 baudrate);

//! Returns pointer to the receive buffer structure.

///

cBuffer* uartGetRxBuffer(void);

//! Returns pointer to the transmit buffer structure.

///

cBuffer* uartGetTxBuffer(void);

//! Sends a single byte over the uart.

/// \note This function waits for the uart to be ready,

/// therefore, consecutive calls to uartSendByte() will

/// go only as fast as the data can be sent over the

/// serial port.

void uartSendByte(u08 data);

//! Gets a single byte from the uart receive buffer.

/// Returns the byte, or -1 if no byte is available (getchar-style).

int uartGetByte(void);

//! Gets a single byte from the uart receive buffer.

/// Function returns TRUE if data was available, FALSE if not.

/// Actual data is returned in variable pointed to by "data".

/// Example usage:

/// \code

/// char myReceivedByte;

/// uartReceiveByte( &myReceivedByte );

/// \endcode

u08 uartReceiveByte(u08* data);

//! Returns TRUE/FALSE if receive buffer is empty/not-empty.

///

u08 uartReceiveBufferIsEmpty(void);

//! Flushes (deletes) all data from receive buffer.

///

void uartFlushReceiveBuffer(void);

//! Add byte to end of uart Tx buffer.

///	Returns TRUE if successful, FALSE if failed (no room left in buffer).

u08 uartAddToTxBuffer(u08 data);

//! Begins transmission of the transmit buffer under interrupt control.

///

void uartSendTxBuffer(void);

//! Sends a block of data via the uart using interrupt control.

/// \param buffer	pointer to data to be sent

///	\param nBytes	length of data (number of bytes to sent)

u08  uartSendBuffer(char *buffer, u16 nBytes);

#endif

//@}