Subversion Repositories svnkaklik

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

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

//

// File Name	: 'uart2.h'

// Title		: Dual UART driver with buffer support

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

// Created		: 11/20/2000

// Revised		: 07/04/2004

// Version		: 1.0

// 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 uart2 UART Driver/Function Library for dual-UART processors (uart2.c)

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

/// \par Overview

///		This is a UART driver for AVR-series processors with two hardware

///		UARTs such as the mega161 and mega128. 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 UARTs,

///		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 UARTs (serial ports)

/// uartSetBaudRate(0, 9600);	// set UART0 speed to 9600 baud

/// uartSetBaudRate(1, 115200);	// set UART1 speed to 115200 baud

///

/// rprintfInit(uart0SendByte);	// configure rprintf to use UART0 for output

/// rprintf("Hello UART0\r\n");	// send "hello world" message via UART0

///

/// rprintfInit(uart1SendByte);	// configure rprintf to use UART1 for output

/// rprintf("Hello UART1\r\n");	// send "hello world" message via UART1

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

#define UART2_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 UART0_DEFAULT_BAUD_RATE		9600	///< default baud rate for UART0

#define UART1_DEFAULT_BAUD_RATE		9600	///< default baud rate for UART1

// buffer memory allocation defines

// buffer sizes

#ifndef UART0_TX_BUFFER_SIZE

#define UART0_TX_BUFFER_SIZE		0x0010	///< number of bytes for uart0 transmit buffer

#endif

#ifndef UART0_RX_BUFFER_SIZE

#define UART0_RX_BUFFER_SIZE		0x0080	///< number of bytes for uart0 receive buffer

#endif

#ifndef UART1_TX_BUFFER_SIZE

#define UART1_TX_BUFFER_SIZE		0x0010	///< number of bytes for uart1 transmit buffer

#endif

#ifndef UART1_RX_BUFFER_SIZE

#define UART1_RX_BUFFER_SIZE		0x0080	///< number of bytes for uart1 receive buffer

#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 uart0 buffers

	#define UART0_TX_BUFFER_ADDR	0x1000

	#define UART0_RX_BUFFER_ADDR	0x1100

	// absolute address of uart1 buffers

	#define UART1_TX_BUFFER_ADDR	0x1200

	#define UART1_RX_BUFFER_ADDR	0x1300

#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 for the mega161

#ifndef RXCIE

	#define RXCIE	RXCIE0

	#define TXCIE	TXCIE0

	#define UDRIE	UDRIE0

	#define RXEN	RXEN0

	#define TXEN	TXEN0

	#define CHR9	CHR90

	#define RXB8	RXB80

	#define TXB8	TXB80

#endif

#ifndef UBRR0L

	#define UBRR0L	UBRR0

	#define UBRR1L	UBRR1

#endif

// functions

//! Initializes UARTs.

/// \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 UART0 only.

void uart0Init(void);

//! Initializes UART1 only.

void uart1Init(void);

//! Initializes transmit and receive buffers.

/// Automatically called from uartInit()

void uart0InitBuffers(void);

void uart1InitBuffers(void);

//! Redirects received data to a user function.

///

void uartSetRxHandler(u08 nUart, void (*rx_func)(unsigned char c));

//! Sets the uart baud rate.

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

void uartSetBaudRate(u08 nUart, u32 baudrate);

//! Returns pointer to the receive buffer structure.

///

cBuffer* uartGetRxBuffer(u08 nUart);

//! Returns pointer to the transmit buffer structure.

///

cBuffer* uartGetTxBuffer(u08 nUart);

//! Sends a single byte over the uart.

///

void uartSendByte(u08 nUart, u08 data);

//! SendByte commands with the UART number hardcoded

/// Use these with printfInit() - example: \c printfInit(uart0SendByte);

void uart0SendByte(u08 data);

void uart1SendByte(u08 data);

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

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

int uart0GetByte(void);

int uart1GetByte(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(0, &myReceivedByte );

/// \endcode

u08 uartReceiveByte(u08 nUart, u08* data);

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

///

u08 uartReceiveBufferIsEmpty(u08 nUart);

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

///

void uartFlushReceiveBuffer(u08 nUart);

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

///

void uartAddToTxBuffer(u08 nUart, u08 data);

//! AddToTxBuffer commands with the UART number hardcoded

/// Use this with printfInit() - example: \c printfInit(uart0AddToTxBuffer);

void uart0AddToTxBuffer(u08 data);

void uart1AddToTxBuffer(u08 data);

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

///

void uartSendTxBuffer(u08 nUart);

//! sends a buffer of length nBytes via the uart using interrupt control.

///

u08 uartSendBuffer(u08 nUart, char *buffer, u16 nBytes);

//! interrupt service handlers

void uartTransmitService(u08 nUart);

void uartReceiveService(u08 nUart);

#endif