usart.c File Reference


Detailed Description

USART driver for AVR32 UC3.

This file contains basic functions for the AVR32 USART, with support for all modes, settings and clock speeds.

Author:
Atmel Corporation: http://www.atmel.com
Support and FAQ: http://support.atmel.no/

Definition in file usart.c.

#include "compiler.h"
#include "usart.h"

Go to the source code of this file.

Functions

Transmit/Receive Functions
int usart_get_echo_line (volatile avr32_usart_t *usart)
 Gets and echoes characters until end of line.
int usart_getchar (volatile avr32_usart_t *usart)
 Waits until a character is received, and returns it.
int usart_putchar (volatile avr32_usart_t *usart, int c)
 Sends a character with the USART.
int usart_read_char (volatile avr32_usart_t *usart, int *c)
 Checks the RX buffer for a received character, and stores it at the given memory location.
int usart_send_address (volatile avr32_usart_t *usart, int address)
 Addresses a receiver.
int usart_write_char (volatile avr32_usart_t *usart, int c)
 Writes the given character to the TX buffer if the transmitter is ready.
void usart_write_line (volatile avr32_usart_t *usart, const char *string)
 Writes one character string to the USART.
Initialization Functions
int usart_init_hw_handshaking (volatile avr32_usart_t *usart, const usart_options_t *opt, long pba_hz)
 Sets up the USART to use hardware handshaking.
int usart_init_IrDA (volatile avr32_usart_t *usart, const usart_options_t *opt, long pba_hz, unsigned char irda_filter)
 Sets up the USART to use the IrDA protocol.
int usart_init_iso7816 (volatile avr32_usart_t *usart, const usart_iso7816_options_t *opt, int t, long pba_hz)
 Sets up the USART to use the ISO7816 T=0 or T=1 smartcard protocols.
int usart_init_modem (volatile avr32_usart_t *usart, const usart_options_t *opt, long pba_hz)
 Sets up the USART to use the modem protocol, activating dedicated inputs/outputs.
int usart_init_rs232 (volatile avr32_usart_t *usart, const usart_options_t *opt, long pba_hz)
 Sets up the USART to use the standard RS232 protocol.
int usart_init_rs232_tx_only (volatile avr32_usart_t *usart, const usart_options_t *opt, long pba_hz)
 Sets up the USART to use the standard RS232 protocol in TX-only mode.
int usart_init_rs485 (volatile avr32_usart_t *usart, const usart_options_t *opt, long pba_hz)
 Sets up the USART to use the RS485 protocol.
int usart_init_sync_master (volatile avr32_usart_t *usart, const usart_options_t *opt, long pba_hz)
 Sets up the USART to use a synchronous RS232-like protocol in master mode.
int usart_init_sync_slave (volatile avr32_usart_t *usart, const usart_options_t *opt, long pba_hz)
 Sets up the USART to use a synchronous RS232-like protocol in slave mode.
void usart_reset (volatile avr32_usart_t *usart)
 Resets the USART and disables TX and RX.
Private Functions
static __inline__ int usart_mode_is_multidrop (volatile avr32_usart_t *usart)
 Checks if the USART is in multidrop mode.
static int usart_set_async_baudrate (volatile avr32_usart_t *usart, unsigned int baudrate, unsigned long pba_hz)
 Calculates a clock divider (CD) and a fractional part (FP) for the USART asynchronous modes to generate a baud rate as close as possible to the baud rate set point.
static int usart_set_iso7816_clock (volatile avr32_usart_t *usart, unsigned int clock, unsigned long pba_hz)
 Calculates a clock divider (CD) for the USART ISO7816 mode to generate an ISO7816 clock as close as possible to the clock set point.
static int usart_set_sync_master_baudrate (volatile avr32_usart_t *usart, unsigned int baudrate, unsigned long pba_hz)
 Calculates a clock divider (CD) for the USART synchronous master modes to generate a baud rate as close as possible to the baud rate set point.
static int usart_set_sync_slave_baudrate (volatile avr32_usart_t *usart)
 Selects the SCK pin as the source of baud rate for the USART synchronous slave modes.


Function Documentation

int usart_get_echo_line ( volatile avr32_usart_t *  usart  ) 

Gets and echoes characters until end of line.

Parameters:
usart Base address of the USART instance.
Return values:
USART_SUCCESS Success.
USART_FAILURE ETX character received.

Definition at line 869 of file usart.c.

References USART_FAILURE, usart_getchar(), usart_putchar(), USART_SUCCESS, and usart_write_line().

Referenced by main().

00870 {
00871   int rx_char;
00872   int retval = USART_SUCCESS;
00873 
00874   while (1)
00875   {
00876     rx_char = usart_getchar(usart);
00877     if (rx_char == USART_FAILURE)
00878     {
00879       usart_write_line(usart, "Error!!!\n");
00880       break;
00881     }
00882     if (rx_char == '\x03')
00883     {
00884       retval = USART_FAILURE;
00885       break;
00886     }
00887     usart_putchar(usart, rx_char);
00888     if (rx_char == '\r')
00889     {
00890       usart_putchar(usart, '\n');
00891       break;
00892     }
00893   }
00894 
00895   return retval;
00896 }

int usart_getchar ( volatile avr32_usart_t *  usart  ) 

Waits until a character is received, and returns it.

Parameters:
usart Base address of the USART instance.
Returns:
The received character, or USART_FAILURE upon error.

Definition at line 849 of file usart.c.

References USART_FAILURE, usart_read_char(), USART_RX_EMPTY, and USART_RX_ERROR.

Referenced by usart_get_echo_line().

00850 {
00851   int c, ret;
00852 
00853   while ((ret = usart_read_char(usart, &c)) == USART_RX_EMPTY);
00854 
00855   if (ret == USART_RX_ERROR)
00856     return USART_FAILURE;
00857 
00858   return c;
00859 }

int usart_init_hw_handshaking ( volatile avr32_usart_t *  usart,
const usart_options_t opt,
long  pba_hz 
)

Sets up the USART to use hardware handshaking.

Parameters:
usart Base address of the USART instance.
opt Options needed to set up RS232 communication (see usart_options_t).
pba_hz USART module input clock frequency (PBA clock, Hz).
Return values:
USART_SUCCESS Mode successfully initialized.
USART_INVALID_INPUT One or more of the arguments is out of valid range.
Note:
usart_init_rs232 does not need to be invoked before this function.

Definition at line 383 of file usart.c.

References usart_init_rs232(), USART_INVALID_INPUT, and USART_SUCCESS.

00384 {
00385   // First: Setup standard RS232.
00386   if (usart_init_rs232(usart, opt, pba_hz) == USART_INVALID_INPUT)
00387     return USART_INVALID_INPUT;
00388 
00389   // Set hardware handshaking mode.
00390   usart->mr = (usart->mr & ~AVR32_USART_MR_MODE_MASK) |
00391               AVR32_USART_MR_MODE_HARDWARE << AVR32_USART_MR_MODE_OFFSET;
00392 
00393   return USART_SUCCESS;
00394 }

int usart_init_IrDA ( volatile avr32_usart_t *  usart,
const usart_options_t opt,
long  pba_hz,
unsigned char  irda_filter 
)

Sets up the USART to use the IrDA protocol.

Parameters:
usart Base address of the USART instance.
opt Options needed to set up RS232 communication (see usart_options_t).
pba_hz USART module input clock frequency (PBA clock, Hz).
irda_filter Counter used to distinguish received ones from zeros.
Return values:
USART_SUCCESS Mode successfully initialized.
USART_INVALID_INPUT One or more of the arguments is out of valid range.

Definition at line 530 of file usart.c.

References usart_init_rs232(), USART_INVALID_INPUT, and USART_SUCCESS.

00532 {
00533   // First: Setup standard RS232.
00534   if (usart_init_rs232(usart, opt, pba_hz) == USART_INVALID_INPUT)
00535     return USART_INVALID_INPUT;
00536 
00537   // Set IrDA filter.
00538   usart->ifr = irda_filter;
00539 
00540   // Set IrDA mode and activate filtering of input.
00541   usart->mr = (usart->mr & ~AVR32_USART_MR_MODE_MASK) |
00542               AVR32_USART_MODE_IRDA << AVR32_USART_MR_MODE_OFFSET |
00543               AVR32_USART_MR_FILTER_MASK;
00544 
00545   return USART_SUCCESS;
00546 }

int usart_init_iso7816 ( volatile avr32_usart_t *  usart,
const usart_iso7816_options_t opt,
int  t,
long  pba_hz 
)

Sets up the USART to use the ISO7816 T=0 or T=1 smartcard protocols.

The receiver is enabled by default. usart_iso7816_enable_receiver and usart_iso7816_enable_transmitter can be called to change the half-duplex communication direction.

Parameters:
usart Base address of the USART instance.
opt Options needed to set up ISO7816 communication (see usart_iso7816_options_t).
t ISO7816 mode to use (T=0 or T=1).
pba_hz USART module input clock frequency (PBA clock, Hz).
Return values:
USART_SUCCESS Mode successfully initialized.
USART_INVALID_INPUT One or more of the arguments is out of valid range.

Definition at line 549 of file usart.c.

References usart_iso7816_options_t::bit_order, usart_iso7816_options_t::dis_suc_nack, usart_iso7816_options_t::fidi_ratio, usart_iso7816_options_t::inhibit_nack, usart_iso7816_options_t::iso7816_hz, usart_iso7816_options_t::max_iterations, usart_iso7816_options_t::paritytype, USART_INVALID_INPUT, usart_iso7816_enable_receiver(), usart_reset(), usart_set_iso7816_clock(), and USART_SUCCESS.

00550 {
00551   // Reset the USART and shutdown TX and RX.
00552   usart_reset(usart);
00553 
00554   // Check input values.
00555   if (!opt || // Null pointer.
00556       opt->paritytype > 1)
00557     return USART_INVALID_INPUT;
00558 
00559   if (t == 0)
00560   {
00561     // Set USART mode to ISO7816, T=0.
00562     // The T=0 protocol always uses 2 stop bits.
00563     usart->mr = AVR32_USART_MR_MODE_ISO7816_T0 << AVR32_USART_MR_MODE_OFFSET |
00564                 AVR32_USART_MR_NBSTOP_2 << AVR32_USART_MR_NBSTOP_OFFSET |
00565                 opt->bit_order << AVR32_USART_MR_MSBF_OFFSET; // Allow MSBF in T=0.
00566   }
00567   else if (t == 1)
00568   {
00569     // Only LSB first in the T=1 protocol.
00570     // max_iterations field is only used in T=0 mode.
00571     if (opt->bit_order != 0 ||
00572         opt->max_iterations != 0)
00573       return USART_INVALID_INPUT;
00574 
00575     // Set USART mode to ISO7816, T=1.
00576     // The T=1 protocol always uses 1 stop bit.
00577     usart->mr = AVR32_USART_MR_MODE_ISO7816_T1 << AVR32_USART_MR_MODE_OFFSET |
00578                 AVR32_USART_MR_NBSTOP_1 << AVR32_USART_MR_NBSTOP_OFFSET;
00579   }
00580   else
00581     return USART_INVALID_INPUT;
00582 
00583   if (usart_set_iso7816_clock(usart, opt->iso7816_hz, pba_hz) == USART_INVALID_INPUT)
00584     return USART_INVALID_INPUT;
00585 
00586   // Set FIDI register: bit rate = selected clock/FI_DI_ratio/16.
00587   usart->fidi = opt->fidi_ratio;
00588 
00589   // Set ISO7816 spesific options in the MODE register.
00590   usart->mr |= opt->paritytype << AVR32_USART_MR_PAR_OFFSET |
00591                AVR32_USART_MR_CLKO_MASK | // Enable clock output.
00592                opt->inhibit_nack << AVR32_USART_MR_INACK_OFFSET |
00593                opt->dis_suc_nack << AVR32_USART_MR_DSNACK_OFFSET |
00594                opt->max_iterations << AVR32_USART_MR_MAX_ITERATION_OFFSET;
00595 
00596   // Setup complete; enable the receiver by default.
00597   usart_iso7816_enable_receiver(usart);
00598 
00599   return USART_SUCCESS;
00600 }

int usart_init_modem ( volatile avr32_usart_t *  usart,
const usart_options_t opt,
long  pba_hz 
)

Sets up the USART to use the modem protocol, activating dedicated inputs/outputs.

Parameters:
usart Base address of the USART instance.
opt Options needed to set up RS232 communication (see usart_options_t).
pba_hz USART module input clock frequency (PBA clock, Hz).
Return values:
USART_SUCCESS Mode successfully initialized.
USART_INVALID_INPUT One or more of the arguments is out of valid range.

Definition at line 397 of file usart.c.

References usart_init_rs232(), USART_INVALID_INPUT, and USART_SUCCESS.

00398 {
00399   // First: Setup standard RS232.
00400   if (usart_init_rs232(usart, opt, pba_hz) == USART_INVALID_INPUT)
00401     return USART_INVALID_INPUT;
00402 
00403   // Set modem mode.
00404   usart->mr = (usart->mr & ~AVR32_USART_MR_MODE_MASK) |
00405               AVR32_USART_MR_MODE_MODEM << AVR32_USART_MR_MODE_OFFSET;
00406 
00407   return USART_SUCCESS;
00408 }

int usart_init_rs232 ( volatile avr32_usart_t *  usart,
const usart_options_t opt,
long  pba_hz 
)

Sets up the USART to use the standard RS232 protocol.

Parameters:
usart Base address of the USART instance.
opt Options needed to set up RS232 communication (see usart_options_t).
pba_hz USART module input clock frequency (PBA clock, Hz).
Return values:
USART_SUCCESS Mode successfully initialized.
USART_INVALID_INPUT One or more of the arguments is out of valid range.

Definition at line 279 of file usart.c.

References usart_options_t::baudrate, usart_options_t::channelmode, usart_options_t::charlength, usart_options_t::paritytype, usart_options_t::stopbits, USART_2_STOPBITS, USART_INVALID_INPUT, usart_reset(), usart_set_async_baudrate(), and USART_SUCCESS.

Referenced by main(), usart_init_hw_handshaking(), usart_init_IrDA(), usart_init_modem(), and usart_init_rs485().

00280 {
00281   // Reset the USART and shutdown TX and RX.
00282   usart_reset(usart);
00283 
00284   // Check input values.
00285   if (!opt || // Null pointer.
00286       opt->charlength < 5 || opt->charlength > 9 ||
00287       opt->paritytype > 7 ||
00288       opt->stopbits > 2 + 255 ||
00289       opt->channelmode > 3 ||
00290       usart_set_async_baudrate(usart, opt->baudrate, pba_hz) == USART_INVALID_INPUT)
00291     return USART_INVALID_INPUT;
00292 
00293   if (opt->charlength == 9)
00294   {
00295     // Character length set to 9 bits. MODE9 dominates CHRL.
00296     usart->mr |= AVR32_USART_MR_MODE9_MASK;
00297   }
00298   else
00299   {
00300     // CHRL gives the character length (- 5) when MODE9 = 0.
00301     usart->mr |= (opt->charlength - 5) << AVR32_USART_MR_CHRL_OFFSET;
00302   }
00303 
00304   usart->mr |= opt->paritytype << AVR32_USART_MR_PAR_OFFSET |
00305                opt->channelmode << AVR32_USART_MR_CHMODE_OFFSET;
00306 
00307   if (opt->stopbits > USART_2_STOPBITS)
00308   {
00309     // Set two stop bits
00310     usart->mr |= AVR32_USART_MR_NBSTOP_2 << AVR32_USART_MR_NBSTOP_OFFSET;
00311     // and a timeguard period gives the rest.
00312     usart->ttgr = opt->stopbits - USART_2_STOPBITS;
00313   }
00314   else
00315     // Insert 1, 1.5 or 2 stop bits.
00316     usart->mr |= opt->stopbits << AVR32_USART_MR_NBSTOP_OFFSET;
00317 
00318   // Set normal mode.
00319   usart->mr = (usart->mr & ~AVR32_USART_MR_MODE_MASK) |
00320               AVR32_USART_MR_MODE_NORMAL << AVR32_USART_MR_MODE_OFFSET;
00321 
00322   // Setup complete; enable communication.
00323   // Enable input and output.
00324   usart->cr = AVR32_USART_CR_RXEN_MASK |
00325               AVR32_USART_CR_TXEN_MASK;
00326 
00327   return USART_SUCCESS;
00328 }

int usart_init_rs232_tx_only ( volatile avr32_usart_t *  usart,
const usart_options_t opt,
long  pba_hz 
)

Sets up the USART to use the standard RS232 protocol in TX-only mode.

Compared to usart_init_rs232, this function allows very high baud rates (up to pba_hz instead of pba_hz / 8) at the expense of full duplex.

Parameters:
usart Base address of the USART instance.
opt Options needed to set up RS232 communication (see usart_options_t).
pba_hz USART module input clock frequency (PBA clock, Hz).
Return values:
USART_SUCCESS Mode successfully initialized.
USART_INVALID_INPUT One or more of the arguments is out of valid range.
Note:
The 1.5 stop bit is not supported in this mode.

Definition at line 331 of file usart.c.

References usart_options_t::baudrate, usart_options_t::channelmode, usart_options_t::charlength, usart_options_t::paritytype, usart_options_t::stopbits, USART_2_STOPBITS, USART_INVALID_INPUT, usart_reset(), usart_set_sync_master_baudrate(), and USART_SUCCESS.

00332 {
00333   // Reset the USART and shutdown TX and RX.
00334   usart_reset(usart);
00335 
00336   // Check input values.
00337   if (!opt || // Null pointer.
00338       opt->charlength < 5 || opt->charlength > 9 ||
00339       opt->paritytype > 7 ||
00340       opt->stopbits == 1 || opt->stopbits > 2 + 255 ||
00341       opt->channelmode > 3 ||
00342       usart_set_sync_master_baudrate(usart, opt->baudrate, pba_hz) == USART_INVALID_INPUT)
00343     return USART_INVALID_INPUT;
00344 
00345   if (opt->charlength == 9)
00346   {
00347     // Character length set to 9 bits. MODE9 dominates CHRL.
00348     usart->mr |= AVR32_USART_MR_MODE9_MASK;
00349   }
00350   else
00351   {
00352     // CHRL gives the character length (- 5) when MODE9 = 0.
00353     usart->mr |= (opt->charlength - 5) << AVR32_USART_MR_CHRL_OFFSET;
00354   }
00355 
00356   usart->mr |= opt->paritytype << AVR32_USART_MR_PAR_OFFSET |
00357                opt->channelmode << AVR32_USART_MR_CHMODE_OFFSET;
00358 
00359   if (opt->stopbits > USART_2_STOPBITS)
00360   {
00361     // Set two stop bits
00362     usart->mr |= AVR32_USART_MR_NBSTOP_2 << AVR32_USART_MR_NBSTOP_OFFSET;
00363     // and a timeguard period gives the rest.
00364     usart->ttgr = opt->stopbits - USART_2_STOPBITS;
00365   }
00366   else
00367     // Insert 1 or 2 stop bits.
00368     usart->mr |= opt->stopbits << AVR32_USART_MR_NBSTOP_OFFSET;
00369 
00370   // Set normal mode.
00371   usart->mr = (usart->mr & ~AVR32_USART_MR_MODE_MASK) |
00372               AVR32_USART_MR_MODE_NORMAL << AVR32_USART_MR_MODE_OFFSET;
00373 
00374   // Setup complete; enable communication.
00375   // Enable only output as input is not possible in synchronous mode without
00376   // transferring clock.
00377   usart->cr = AVR32_USART_CR_TXEN_MASK;
00378 
00379   return USART_SUCCESS;
00380 }

int usart_init_rs485 ( volatile avr32_usart_t *  usart,
const usart_options_t opt,
long  pba_hz 
)

Sets up the USART to use the RS485 protocol.

Parameters:
usart Base address of the USART instance.
opt Options needed to set up RS232 communication (see usart_options_t).
pba_hz USART module input clock frequency (PBA clock, Hz).
Return values:
USART_SUCCESS Mode successfully initialized.
USART_INVALID_INPUT One or more of the arguments is out of valid range.

Definition at line 516 of file usart.c.

References usart_init_rs232(), USART_INVALID_INPUT, and USART_SUCCESS.

00517 {
00518   // First: Setup standard RS232.
00519   if (usart_init_rs232(usart, opt, pba_hz) == USART_INVALID_INPUT)
00520     return USART_INVALID_INPUT;
00521 
00522   // Set RS485 mode.
00523   usart->mr = (usart->mr & ~AVR32_USART_MR_MODE_MASK) |
00524               AVR32_USART_MR_MODE_RS485 << AVR32_USART_MR_MODE_OFFSET;
00525 
00526   return USART_SUCCESS;
00527 }

int usart_init_sync_master ( volatile avr32_usart_t *  usart,
const usart_options_t opt,
long  pba_hz 
)

Sets up the USART to use a synchronous RS232-like protocol in master mode.

Parameters:
usart Base address of the USART instance.
opt Options needed to set up RS232 communication (see usart_options_t).
pba_hz USART module input clock frequency (PBA clock, Hz).
Return values:
USART_SUCCESS Mode successfully initialized.
USART_INVALID_INPUT One or more of the arguments is out of valid range.

Definition at line 411 of file usart.c.

References usart_options_t::baudrate, usart_options_t::channelmode, usart_options_t::charlength, usart_options_t::paritytype, usart_options_t::stopbits, USART_2_STOPBITS, USART_INVALID_INPUT, usart_reset(), usart_set_sync_master_baudrate(), and USART_SUCCESS.

00412 {
00413   // Reset the USART and shutdown TX and RX.
00414   usart_reset(usart);
00415 
00416   // Check input values.
00417   if (!opt || // Null pointer.
00418       opt->charlength < 5 || opt->charlength > 9 ||
00419       opt->paritytype > 7 ||
00420       opt->stopbits == 1 || opt->stopbits > 2 + 255 ||
00421       opt->channelmode > 3 ||
00422       usart_set_sync_master_baudrate(usart, opt->baudrate, pba_hz) == USART_INVALID_INPUT)
00423     return USART_INVALID_INPUT;
00424 
00425   if (opt->charlength == 9)
00426   {
00427     // Character length set to 9 bits. MODE9 dominates CHRL.
00428     usart->mr |= AVR32_USART_MR_MODE9_MASK;
00429   }
00430   else
00431   {
00432     // CHRL gives the character length (- 5) when MODE9 = 0.
00433     usart->mr |= (opt->charlength - 5) << AVR32_USART_MR_CHRL_OFFSET;
00434   }
00435 
00436   usart->mr |= opt->paritytype << AVR32_USART_MR_PAR_OFFSET |
00437                opt->channelmode << AVR32_USART_MR_CHMODE_OFFSET;
00438 
00439   if (opt->stopbits > USART_2_STOPBITS)
00440   {
00441     // Set two stop bits
00442     usart->mr |= AVR32_USART_MR_NBSTOP_2 << AVR32_USART_MR_NBSTOP_OFFSET;
00443     // and a timeguard period gives the rest.
00444     usart->ttgr = opt->stopbits - USART_2_STOPBITS;
00445   }
00446   else
00447     // Insert 1 or 2 stop bits.
00448     usart->mr |= opt->stopbits << AVR32_USART_MR_NBSTOP_OFFSET;
00449 
00450   // Set normal mode.
00451   usart->mr = (usart->mr & ~AVR32_USART_MR_MODE_MASK) |
00452               AVR32_USART_MR_MODE_NORMAL << AVR32_USART_MR_MODE_OFFSET |
00453               AVR32_USART_MR_CLKO_MASK;
00454 
00455   // Setup complete; enable communication.
00456   // Enable input and output.
00457   usart->cr = AVR32_USART_CR_RXEN_MASK |
00458               AVR32_USART_CR_TXEN_MASK;
00459 
00460   return USART_SUCCESS;
00461 }

int usart_init_sync_slave ( volatile avr32_usart_t *  usart,
const usart_options_t opt,
long  pba_hz 
)

Sets up the USART to use a synchronous RS232-like protocol in slave mode.

Parameters:
usart Base address of the USART instance.
opt Options needed to set up RS232 communication (see usart_options_t).
pba_hz USART module input clock frequency (PBA clock, Hz).
Return values:
USART_SUCCESS Mode successfully initialized.
USART_INVALID_INPUT One or more of the arguments is out of valid range.

Definition at line 464 of file usart.c.

References usart_options_t::channelmode, usart_options_t::charlength, usart_options_t::paritytype, usart_options_t::stopbits, USART_2_STOPBITS, USART_INVALID_INPUT, usart_reset(), usart_set_sync_slave_baudrate(), and USART_SUCCESS.

00465 {
00466   // Reset the USART and shutdown TX and RX.
00467   usart_reset(usart);
00468 
00469   // Check input values.
00470   if (!opt || // Null pointer.
00471       opt->charlength < 5 || opt->charlength > 9 ||
00472       opt->paritytype > 7 ||
00473       opt->stopbits == 1 || opt->stopbits > 2 + 255 ||
00474       opt->channelmode > 3 ||
00475       usart_set_sync_slave_baudrate(usart) == USART_INVALID_INPUT)
00476     return USART_INVALID_INPUT;
00477 
00478   if (opt->charlength == 9)
00479   {
00480     // Character length set to 9 bits. MODE9 dominates CHRL.
00481     usart->mr |= AVR32_USART_MR_MODE9_MASK;
00482   }
00483   else
00484   {
00485     // CHRL gives the character length (- 5) when MODE9 = 0.
00486     usart->mr |= (opt->charlength - 5) << AVR32_USART_MR_CHRL_OFFSET;
00487   }
00488 
00489   usart->mr |= opt->paritytype << AVR32_USART_MR_PAR_OFFSET |
00490                opt->channelmode << AVR32_USART_MR_CHMODE_OFFSET;
00491 
00492   if (opt->stopbits > USART_2_STOPBITS)
00493   {
00494     // Set two stop bits
00495     usart->mr |= AVR32_USART_MR_NBSTOP_2 << AVR32_USART_MR_NBSTOP_OFFSET;
00496     // and a timeguard period gives the rest.
00497     usart->ttgr = opt->stopbits - USART_2_STOPBITS;
00498   }
00499   else
00500     // Insert 1 or 2 stop bits.
00501     usart->mr |= opt->stopbits << AVR32_USART_MR_NBSTOP_OFFSET;
00502 
00503   // Set normal mode.
00504   usart->mr = (usart->mr & ~AVR32_USART_MR_MODE_MASK) |
00505               AVR32_USART_MR_MODE_NORMAL << AVR32_USART_MR_MODE_OFFSET;
00506 
00507   // Setup complete; enable communication.
00508   // Enable input and output.
00509   usart->cr = AVR32_USART_CR_RXEN_MASK |
00510               AVR32_USART_CR_TXEN_MASK;
00511 
00512   return USART_SUCCESS;
00513 }

static __inline__ int usart_mode_is_multidrop ( volatile avr32_usart_t *  usart  )  [static]

Checks if the USART is in multidrop mode.

Parameters:
usart Base address of the USART instance.
Returns:
1 if the USART is in multidrop mode, otherwise 0.

Definition at line 65 of file usart.c.

Referenced by usart_send_address().

00066 {
00067   return ((usart->mr >> AVR32_USART_MR_PAR_OFFSET) & AVR32_USART_MR_PAR_MULTI) == AVR32_USART_MR_PAR_MULTI;
00068 }

int usart_putchar ( volatile avr32_usart_t *  usart,
int  c 
)

Sends a character with the USART.

Parameters:
usart Base address of the USART instance.
c Character to write.
Return values:
USART_SUCCESS The character was written.
USART_FAILURE The function timed out before the USART transmitter became ready to send.

Definition at line 806 of file usart.c.

References USART_DEFAULT_TIMEOUT, USART_FAILURE, USART_SUCCESS, and usart_write_char().

Referenced by usart_get_echo_line(), and usart_write_line().

00807 {
00808   int timeout = USART_DEFAULT_TIMEOUT;
00809 
00810   if (c == '\n')
00811   {
00812     do
00813     {
00814       if (!timeout--) return USART_FAILURE;
00815     } while (usart_write_char(usart, '\r') != USART_SUCCESS);
00816 
00817     timeout = USART_DEFAULT_TIMEOUT;
00818   }
00819 
00820   do
00821   {
00822     if (!timeout--) return USART_FAILURE;
00823   } while (usart_write_char(usart, c) != USART_SUCCESS);
00824 
00825   return USART_SUCCESS;
00826 }

int usart_read_char ( volatile avr32_usart_t *  usart,
int *  c 
)

Checks the RX buffer for a received character, and stores it at the given memory location.

Parameters:
usart Base address of the USART instance.
c Pointer to the where the read character should be stored (must be at least short in order to accept 9-bit characters).
Return values:
USART_SUCCESS The character was read successfully.
USART_RX_EMPTY The RX buffer was empty.
USART_RX_ERROR An error was deteceted.

Definition at line 829 of file usart.c.

References USART_RX_EMPTY, USART_RX_ERROR, USART_SUCCESS, and usart_test_hit().

Referenced by usart_getchar().

00830 {
00831   // Check for errors: frame, parity and overrun. In RS485 mode, a parity error
00832   // would mean that an address char has been received.
00833   if (usart->csr & (AVR32_USART_CSR_OVRE_MASK |
00834                     AVR32_USART_CSR_FRAME_MASK |
00835                     AVR32_USART_CSR_PARE_MASK))
00836     return USART_RX_ERROR;
00837 
00838   // No error; if we really did receive a char, read it and return SUCCESS.
00839   if (usart_test_hit(usart))
00840   {
00841     *c = (usart->rhr & AVR32_USART_RHR_RXCHR_MASK) >> AVR32_USART_RHR_RXCHR_OFFSET;
00842     return USART_SUCCESS;
00843   }
00844   else
00845     return USART_RX_EMPTY;
00846 }

void usart_reset ( volatile avr32_usart_t *  usart  ) 

Resets the USART and disables TX and RX.

Parameters:
usart Base address of the USART instance.

Definition at line 251 of file usart.c.

Referenced by usart_init_iso7816(), usart_init_rs232(), usart_init_rs232_tx_only(), usart_init_sync_master(), and usart_init_sync_slave().

00252 {
00253   Bool global_interrupt_enabled = Is_global_interrupt_enabled();
00254 
00255   // Disable all USART interrupts.
00256   // Interrupts needed should be set explicitly on every reset.
00257   if (global_interrupt_enabled) Disable_global_interrupt();
00258   usart->idr = 0xFFFFFFFF;
00259   usart->csr;
00260   if (global_interrupt_enabled) Enable_global_interrupt();
00261 
00262   // Reset mode and other registers that could cause unpredictable behavior after reset.
00263   usart->mr = 0;
00264   usart->rtor = 0;
00265   usart->ttgr = 0;
00266 
00267   // Shutdown TX and RX (will be re-enabled when setup has successfully completed),
00268   // reset status bits and turn off DTR and RTS.
00269   usart->cr = AVR32_USART_CR_RSTRX_MASK   |
00270               AVR32_USART_CR_RSTTX_MASK   |
00271               AVR32_USART_CR_RSTSTA_MASK  |
00272               AVR32_USART_CR_RSTIT_MASK   |
00273               AVR32_USART_CR_RSTNACK_MASK |
00274               AVR32_USART_CR_DTRDIS_MASK  |
00275               AVR32_USART_CR_RTSDIS_MASK;
00276 }

int usart_send_address ( volatile avr32_usart_t *  usart,
int  address 
)

Addresses a receiver.

While in RS485 mode, receivers only accept data addressed to them. A packet/char with the address tag set has to precede any data. This function is used to address a receiver. This receiver should read all the following data, until an address packet addresses another receiver.

Parameters:
usart Base address of the USART instance.
address Address of the target device.
Return values:
USART_SUCCESS Address successfully sent (if current mode is RS485).
USART_MODE_FAULT Wrong operating mode.

Definition at line 779 of file usart.c.

References usart_bw_write_char(), USART_MODE_FAULT, usart_mode_is_multidrop(), and USART_SUCCESS.

00780 {
00781   // Check if USART is in multidrop / RS485 mode.
00782   if (!usart_mode_is_multidrop(usart)) return USART_MODE_FAULT;
00783 
00784   // Prepare to send an address.
00785   usart->cr = AVR32_USART_CR_SENDA_MASK;
00786 
00787   // Write the address to TX.
00788   usart_bw_write_char(usart, address);
00789 
00790   return USART_SUCCESS;
00791 }

static int usart_set_async_baudrate ( volatile avr32_usart_t *  usart,
unsigned int  baudrate,
unsigned long  pba_hz 
) [static]

Calculates a clock divider (CD) and a fractional part (FP) for the USART asynchronous modes to generate a baud rate as close as possible to the baud rate set point.

Baud rate calculation: $ Baudrate = \frac{SelectedClock}{Over \times (CD + \frac{FP}{8})} $, Over being 16 or 8. The maximal oversampling is selected if it allows to generate a baud rate close to the set point.

Parameters:
usart Base address of the USART instance.
baudrate Baud rate set point.
pba_hz USART module input clock frequency (PBA clock, Hz).
Return values:
USART_SUCCESS Baud rate successfully initialized.
USART_INVALID_INPUT Baud rate set point is out of range for the given input clock frequency.

Definition at line 86 of file usart.c.

References USART_INVALID_INPUT, and USART_SUCCESS.

Referenced by usart_init_rs232().

00087 {
00088   unsigned int over = (pba_hz >= 16 * baudrate) ? 16 : 8;
00089   unsigned int cd_fp = ((1 << AVR32_USART_BRGR_FP_SIZE) * pba_hz + (over * baudrate) / 2) / (over * baudrate);
00090   unsigned int cd = cd_fp >> AVR32_USART_BRGR_FP_SIZE;
00091   unsigned int fp = cd_fp & ((1 << AVR32_USART_BRGR_FP_SIZE) - 1);
00092 
00093   if (cd < 1 || cd > (1 << AVR32_USART_BRGR_CD_SIZE) - 1)
00094     return USART_INVALID_INPUT;
00095 
00096   usart->mr = (usart->mr & ~(AVR32_USART_MR_USCLKS_MASK |
00097                              AVR32_USART_MR_SYNC_MASK |
00098                              AVR32_USART_MR_OVER_MASK)) |
00099               AVR32_USART_MR_USCLKS_MCK << AVR32_USART_MR_USCLKS_OFFSET |
00100               ((over == 16) ? AVR32_USART_MR_OVER_X16 : AVR32_USART_MR_OVER_X8) << AVR32_USART_MR_OVER_OFFSET;
00101 
00102   usart->brgr = cd << AVR32_USART_BRGR_CD_OFFSET |
00103                 fp << AVR32_USART_BRGR_FP_OFFSET;
00104 
00105   return USART_SUCCESS;
00106 }

static int usart_set_iso7816_clock ( volatile avr32_usart_t *  usart,
unsigned int  clock,
unsigned long  pba_hz 
) [static]

Calculates a clock divider (CD) for the USART ISO7816 mode to generate an ISO7816 clock as close as possible to the clock set point.

ISO7816 clock calculation: $ Clock = \frac{SelectedClock}{CD} $.

Parameters:
usart Base address of the USART instance.
clock ISO7816 clock set point.
pba_hz USART module input clock frequency (PBA clock, Hz).
Return values:
USART_SUCCESS ISO7816 clock successfully initialized.
USART_INVALID_INPUT ISO7816 clock set point is out of range for the given input clock frequency.

Definition at line 170 of file usart.c.

References USART_INVALID_INPUT, and USART_SUCCESS.

Referenced by usart_init_iso7816().

00171 {
00172   unsigned int cd = (pba_hz + clock / 2) / clock;
00173 
00174   if (cd < 1 || cd > (1 << AVR32_USART_BRGR_CD_SIZE) - 1)
00175     return USART_INVALID_INPUT;
00176 
00177   usart->mr = (usart->mr & ~(AVR32_USART_MR_USCLKS_MASK |
00178                              AVR32_USART_MR_SYNC_MASK |
00179                              AVR32_USART_MR_OVER_MASK)) |
00180               AVR32_USART_MR_USCLKS_MCK << AVR32_USART_MR_USCLKS_OFFSET |
00181               AVR32_USART_MR_OVER_X16 << AVR32_USART_MR_OVER_OFFSET;
00182 
00183   usart->brgr = cd << AVR32_USART_BRGR_CD_OFFSET;
00184 
00185   return USART_SUCCESS;
00186 }

static int usart_set_sync_master_baudrate ( volatile avr32_usart_t *  usart,
unsigned int  baudrate,
unsigned long  pba_hz 
) [static]

Calculates a clock divider (CD) for the USART synchronous master modes to generate a baud rate as close as possible to the baud rate set point.

Baud rate calculation: $ Baudrate = \frac{SelectedClock}{CD} $.

Parameters:
usart Base address of the USART instance.
baudrate Baud rate set point.
pba_hz USART module input clock frequency (PBA clock, Hz).
Return values:
USART_SUCCESS Baud rate successfully initialized.
USART_INVALID_INPUT Baud rate set point is out of range for the given input clock frequency.

Definition at line 123 of file usart.c.

References USART_INVALID_INPUT, and USART_SUCCESS.

Referenced by usart_init_rs232_tx_only(), and usart_init_sync_master().

00124 {
00125   unsigned int cd = (pba_hz + baudrate / 2) / baudrate;
00126 
00127   if (cd < 1 || cd > (1 << AVR32_USART_BRGR_CD_SIZE) - 1)
00128     return USART_INVALID_INPUT;
00129 
00130   usart->mr = (usart->mr & ~AVR32_USART_MR_USCLKS_MASK) |
00131               AVR32_USART_MR_USCLKS_MCK << AVR32_USART_MR_USCLKS_OFFSET |
00132               AVR32_USART_MR_SYNC_MASK;
00133 
00134   usart->brgr = cd << AVR32_USART_BRGR_CD_OFFSET;
00135 
00136   return USART_SUCCESS;
00137 }

static int usart_set_sync_slave_baudrate ( volatile avr32_usart_t *  usart  )  [static]

Selects the SCK pin as the source of baud rate for the USART synchronous slave modes.

Parameters:
usart Base address of the USART instance.
Return values:
USART_SUCCESS Baud rate successfully initialized.

Definition at line 147 of file usart.c.

References USART_SUCCESS.

Referenced by usart_init_sync_slave().

00148 {
00149   usart->mr = (usart->mr & ~AVR32_USART_MR_USCLKS_MASK) |
00150               AVR32_USART_MR_USCLKS_SCK << AVR32_USART_MR_USCLKS_OFFSET |
00151               AVR32_USART_MR_SYNC_MASK;
00152 
00153   return USART_SUCCESS;
00154 }

int usart_write_char ( volatile avr32_usart_t *  usart,
int  c 
)

Writes the given character to the TX buffer if the transmitter is ready.

Parameters:
usart Base address of the USART instance.
c The character (up to 9 bits) to transmit.
Return values:
USART_SUCCESS The transmitter was ready.
USART_TX_BUSY The transmitter was busy.

Definition at line 794 of file usart.c.

References USART_SUCCESS, USART_TX_BUSY, and usart_tx_ready().

Referenced by usart_bw_write_char(), and usart_putchar().

00795 {
00796   if (usart_tx_ready(usart))
00797   {
00798     usart->thr = (c << AVR32_USART_THR_TXCHR_OFFSET) & AVR32_USART_THR_TXCHR_MASK;
00799     return USART_SUCCESS;
00800   }
00801   else
00802     return USART_TX_BUSY;
00803 }

void usart_write_line ( volatile avr32_usart_t *  usart,
const char *  string 
)

Writes one character string to the USART.

Parameters:
usart Base address of the USART instance.
string String to be written.

Definition at line 862 of file usart.c.

References usart_putchar().

Referenced by main(), and usart_get_echo_line().

00863 {
00864   while (*string != '\0')
00865     usart_putchar(usart, *string++);
00866 }


Generated on Tue Nov 25 11:16:36 2008 for AVR32 AP7 - USART Driver by  doxygen 1.5.6