This file contains basic functions for the AVR32 USART, with support for all modes, settings and clock speeds.
Definition in file usart.h.
#include <avr32/io.h>
#include "compiler.h"
Go to the source code of this file.
Data Structures | |
struct | usart_iso7816_options_t |
Input parameters when initializing ISO7816 mode. More... | |
struct | usart_options_t |
Input parameters when initializing RS232 and similar modes. More... | |
Defines | |
#define | USART_DEFAULT_TIMEOUT 10000 |
Default time-out value (number of attempts). | |
Stop Bits Settings | |
#define | USART_1_5_STOPBITS AVR32_USART_MR_NBSTOP_1_5 |
Use 1.5 stop bits. | |
#define | USART_1_STOPBIT AVR32_USART_MR_NBSTOP_1 |
Use 1 stop bit. | |
#define | USART_2_STOPBITS AVR32_USART_MR_NBSTOP_2 |
Use 2 stop bits (for more, just give the number of bits). | |
Channel Modes | |
#define | USART_AUTO_ECHO AVR32_USART_MR_CHMODE_ECHO |
Echo data. | |
#define | USART_LOCAL_LOOPBACK AVR32_USART_MR_CHMODE_LOCAL_LOOP |
Local loopback. | |
#define | USART_NORMAL_CHMODE AVR32_USART_MR_CHMODE_NORMAL |
Normal communication. | |
#define | USART_REMOTE_LOOPBACK AVR32_USART_MR_CHMODE_REMOTE_LOOP |
Remote loopback. | |
Parity Settings | |
#define | USART_EVEN_PARITY AVR32_USART_MR_PAR_EVEN |
Use even parity on character transmission. | |
#define | USART_MARK_PARITY AVR32_USART_MR_PAR_MARK |
Use a mark as parity bit. | |
#define | USART_MULTIDROP_PARITY AVR32_USART_MR_PAR_MULTI |
Parity bit is used to flag address characters. | |
#define | USART_NO_PARITY AVR32_USART_MR_PAR_NONE |
Don't use a parity bit. | |
#define | USART_ODD_PARITY AVR32_USART_MR_PAR_ODD |
Use odd parity on character transmission. | |
#define | USART_SPACE_PARITY AVR32_USART_MR_PAR_SPACE |
Use a space as parity bit. | |
Return Values | |
#define | USART_FAILURE -1 |
Failure because of some unspecified reason. | |
#define | USART_INVALID_ARGUMENT -1 |
Argument value out of range. | |
#define | USART_INVALID_INPUT 1 |
Input value out of range. | |
#define | USART_MODE_FAULT 5 |
USART not in the appropriate mode. | |
#define | USART_RX_EMPTY 3 |
Nothing was received. | |
#define | USART_RX_ERROR 4 |
Transmission error occurred. | |
#define | USART_SUCCESS 0 |
Successful completion. | |
#define | USART_TX_BUSY 2 |
Transmitter was busy. | |
Functions | |
Transmit/Receive Functions | |
__inline__ void | usart_bw_write_char (volatile avr32_usart_t *usart, int c) |
An active wait writing a character to the USART. | |
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. | |
__inline__ int | usart_test_hit (volatile avr32_usart_t *usart) |
Tests if the USART contains a received character. | |
__inline__ int | usart_tx_empty (volatile avr32_usart_t *usart) |
Tests if all requested USART transmissions are over. | |
__inline__ int | usart_tx_ready (volatile avr32_usart_t *usart) |
Tests if the USART is ready to transmit a character. | |
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. | |
Read and Reset Error Status Bits | |
__inline__ int | usart_framing_error (volatile avr32_usart_t *usart) |
Checks if a framing error has occurred since last status reset. | |
__inline__ int | usart_overrun_error (volatile avr32_usart_t *usart) |
Checks if an overrun error has occurred since last status reset. | |
__inline__ int | usart_parity_error (volatile avr32_usart_t *usart) |
Checks if a parity error has occurred since last status reset. | |
__inline__ void | usart_reset_status (volatile avr32_usart_t *usart) |
Resets the error status. | |
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. | |
ISO7816 Control Functions | |
__inline__ void | usart_iso7816_enable_receiver (volatile avr32_usart_t *usart) |
Enables the ISO7816 receiver. | |
__inline__ void | usart_iso7816_enable_transmitter (volatile avr32_usart_t *usart) |
Enables the ISO7816 transmitter. |
#define USART_1_5_STOPBITS AVR32_USART_MR_NBSTOP_1_5 |
#define USART_1_STOPBIT AVR32_USART_MR_NBSTOP_1 |
#define USART_2_STOPBITS AVR32_USART_MR_NBSTOP_2 |
Use 2 stop bits (for more, just give the number of bits).
Definition at line 88 of file usart.h.
Referenced by usart_init_rs232(), usart_init_rs232_tx_only(), usart_init_sync_master(), and usart_init_sync_slave().
#define USART_AUTO_ECHO AVR32_USART_MR_CHMODE_ECHO |
#define USART_DEFAULT_TIMEOUT 10000 |
Default time-out value (number of attempts).
Definition at line 70 of file usart.h.
Referenced by usart_putchar().
#define USART_EVEN_PARITY AVR32_USART_MR_PAR_EVEN |
#define USART_FAILURE -1 |
Failure because of some unspecified reason.
Definition at line 60 of file usart.h.
Referenced by usart_get_echo_line(), usart_getchar(), and usart_putchar().
#define USART_INVALID_ARGUMENT -1 |
#define USART_INVALID_INPUT 1 |
Input value out of range.
Definition at line 61 of file usart.h.
Referenced by usart_init_hw_handshaking(), usart_init_IrDA(), usart_init_iso7816(), usart_init_modem(), usart_init_rs232(), usart_init_rs232_tx_only(), usart_init_rs485(), usart_init_sync_master(), usart_init_sync_slave(), usart_set_async_baudrate(), usart_set_iso7816_clock(), and usart_set_sync_master_baudrate().
#define USART_LOCAL_LOOPBACK AVR32_USART_MR_CHMODE_LOCAL_LOOP |
#define USART_MARK_PARITY AVR32_USART_MR_PAR_MARK |
#define USART_MODE_FAULT 5 |
USART not in the appropriate mode.
Definition at line 66 of file usart.h.
Referenced by usart_send_address().
#define USART_MULTIDROP_PARITY AVR32_USART_MR_PAR_MULTI |
#define USART_NO_PARITY AVR32_USART_MR_PAR_NONE |
#define USART_NORMAL_CHMODE AVR32_USART_MR_CHMODE_NORMAL |
#define USART_ODD_PARITY AVR32_USART_MR_PAR_ODD |
#define USART_REMOTE_LOOPBACK AVR32_USART_MR_CHMODE_REMOTE_LOOP |
#define USART_RX_EMPTY 3 |
Nothing was received.
Definition at line 64 of file usart.h.
Referenced by usart_getchar(), and usart_read_char().
#define USART_RX_ERROR 4 |
Transmission error occurred.
Definition at line 65 of file usart.h.
Referenced by usart_getchar(), and usart_read_char().
#define USART_SPACE_PARITY AVR32_USART_MR_PAR_SPACE |
#define USART_SUCCESS 0 |
Successful completion.
Definition at line 59 of file usart.h.
Referenced by usart_bw_write_char(), usart_get_echo_line(), usart_init_hw_handshaking(), usart_init_IrDA(), usart_init_iso7816(), usart_init_modem(), usart_init_rs232(), usart_init_rs232_tx_only(), usart_init_rs485(), usart_init_sync_master(), usart_init_sync_slave(), usart_putchar(), usart_read_char(), usart_send_address(), usart_set_async_baudrate(), usart_set_iso7816_clock(), usart_set_sync_master_baudrate(), usart_set_sync_slave_baudrate(), and usart_write_char().
#define USART_TX_BUSY 2 |
__inline__ void usart_bw_write_char | ( | volatile avr32_usart_t * | usart, | |
int | c | |||
) |
An active wait writing a character to the USART.
usart | Base address of the USART instance. | |
c | The character (up to 9 bits) to transmit. |
Definition at line 770 of file usart.h.
References USART_SUCCESS, and usart_write_char().
Referenced by usart_send_address().
00770 { 00771 while (usart_write_char(usart, c) != USART_SUCCESS); 00772 } 00773
__inline__ int usart_framing_error | ( | volatile avr32_usart_t * | usart | ) |
int usart_get_echo_line | ( | volatile avr32_usart_t * | usart | ) |
Gets and echoes characters until end of line.
usart | Base address of the USART instance. |
USART_SUCCESS | Success. | |
USART_FAILURE | Low-level error detected or ETX character received. |
Definition at line 881 of file usart.c.
References USART_FAILURE, usart_getchar(), usart_putchar(), USART_SUCCESS, and usart_write_line().
00882 { 00883 int rx_char; 00884 int retval = USART_SUCCESS; 00885 00886 while (1) 00887 { 00888 rx_char = usart_getchar(usart); 00889 if (rx_char == USART_FAILURE) 00890 { 00891 usart_write_line(usart, "Error!!!\n"); 00892 retval = USART_FAILURE; 00893 break; 00894 } 00895 if (rx_char == '\x03') 00896 { 00897 retval = USART_FAILURE; 00898 break; 00899 } 00900 usart_putchar(usart, rx_char); 00901 if (rx_char == '\r') 00902 { 00903 usart_putchar(usart, '\n'); 00904 break; 00905 } 00906 } 00907 00908 return retval; 00909 }
int usart_getchar | ( | volatile avr32_usart_t * | usart | ) |
Waits until a character is received, and returns it.
usart | Base address of the USART instance. |
Definition at line 861 of file usart.c.
References USART_FAILURE, usart_read_char(), USART_RX_EMPTY, and USART_RX_ERROR.
Referenced by usart_get_echo_line().
00862 { 00863 int c, ret; 00864 00865 while ((ret = usart_read_char(usart, &c)) == USART_RX_EMPTY); 00866 00867 if (ret == USART_RX_ERROR) 00868 return USART_FAILURE; 00869 00870 return c; 00871 }
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.
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). |
USART_SUCCESS | Mode successfully initialized. | |
USART_INVALID_INPUT | One or more of the arguments is out of valid range. |
Definition at line 391 of file usart.c.
References usart_init_rs232(), USART_INVALID_INPUT, and USART_SUCCESS.
00392 { 00393 // First: Setup standard RS232. 00394 if (usart_init_rs232(usart, opt, pba_hz) == USART_INVALID_INPUT) 00395 return USART_INVALID_INPUT; 00396 00397 // Set hardware handshaking mode. 00398 usart->mr = (usart->mr & ~AVR32_USART_MR_MODE_MASK) | 00399 AVR32_USART_MR_MODE_HARDWARE << AVR32_USART_MR_MODE_OFFSET; 00400 00401 return USART_SUCCESS; 00402 }
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.
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. |
USART_SUCCESS | Mode successfully initialized. | |
USART_INVALID_INPUT | One or more of the arguments is out of valid range. |
Definition at line 538 of file usart.c.
References usart_init_rs232(), USART_INVALID_INPUT, and USART_SUCCESS.
00540 { 00541 // First: Setup standard RS232. 00542 if (usart_init_rs232(usart, opt, pba_hz) == USART_INVALID_INPUT) 00543 return USART_INVALID_INPUT; 00544 00545 // Set IrDA filter. 00546 usart->ifr = irda_filter; 00547 00548 // Set IrDA mode and activate filtering of input. 00549 usart->mr = (usart->mr & ~AVR32_USART_MR_MODE_MASK) | 00550 AVR32_USART_MODE_IRDA << AVR32_USART_MR_MODE_OFFSET | 00551 AVR32_USART_MR_FILTER_MASK; 00552 00553 return USART_SUCCESS; 00554 }
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.
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). |
USART_SUCCESS | Mode successfully initialized. | |
USART_INVALID_INPUT | One or more of the arguments is out of valid range. |
Definition at line 557 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.
00558 { 00559 // Reset the USART and shutdown TX and RX. 00560 usart_reset(usart); 00561 00562 // Check input values. 00563 if (!opt || // Null pointer. 00564 opt->paritytype > 1) 00565 return USART_INVALID_INPUT; 00566 00567 if (t == 0) 00568 { 00569 // Set USART mode to ISO7816, T=0. 00570 // The T=0 protocol always uses 2 stop bits. 00571 usart->mr = AVR32_USART_MR_MODE_ISO7816_T0 << AVR32_USART_MR_MODE_OFFSET | 00572 AVR32_USART_MR_NBSTOP_2 << AVR32_USART_MR_NBSTOP_OFFSET | 00573 opt->bit_order << AVR32_USART_MR_MSBF_OFFSET; // Allow MSBF in T=0. 00574 } 00575 else if (t == 1) 00576 { 00577 // Only LSB first in the T=1 protocol. 00578 // max_iterations field is only used in T=0 mode. 00579 if (opt->bit_order != 0 || 00580 opt->max_iterations != 0) 00581 return USART_INVALID_INPUT; 00582 00583 // Set USART mode to ISO7816, T=1. 00584 // The T=1 protocol always uses 1 stop bit. 00585 usart->mr = AVR32_USART_MR_MODE_ISO7816_T1 << AVR32_USART_MR_MODE_OFFSET | 00586 AVR32_USART_MR_NBSTOP_1 << AVR32_USART_MR_NBSTOP_OFFSET; 00587 } 00588 else 00589 return USART_INVALID_INPUT; 00590 00591 if (usart_set_iso7816_clock(usart, opt->iso7816_hz, pba_hz) == USART_INVALID_INPUT) 00592 return USART_INVALID_INPUT; 00593 00594 // Set FIDI register: bit rate = selected clock/FI_DI_ratio/16. 00595 usart->fidi = opt->fidi_ratio; 00596 00597 // Set ISO7816 spesific options in the MODE register. 00598 usart->mr |= opt->paritytype << AVR32_USART_MR_PAR_OFFSET | 00599 AVR32_USART_MR_CLKO_MASK | // Enable clock output. 00600 opt->inhibit_nack << AVR32_USART_MR_INACK_OFFSET | 00601 opt->dis_suc_nack << AVR32_USART_MR_DSNACK_OFFSET | 00602 opt->max_iterations << AVR32_USART_MR_MAX_ITERATION_OFFSET; 00603 00604 // Setup complete; enable the receiver by default. 00605 usart_iso7816_enable_receiver(usart); 00606 00607 return USART_SUCCESS; 00608 }
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.
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). |
USART_SUCCESS | Mode successfully initialized. | |
USART_INVALID_INPUT | One or more of the arguments is out of valid range. |
Definition at line 405 of file usart.c.
References usart_init_rs232(), USART_INVALID_INPUT, and USART_SUCCESS.
00406 { 00407 // First: Setup standard RS232. 00408 if (usart_init_rs232(usart, opt, pba_hz) == USART_INVALID_INPUT) 00409 return USART_INVALID_INPUT; 00410 00411 // Set modem mode. 00412 usart->mr = (usart->mr & ~AVR32_USART_MR_MODE_MASK) | 00413 AVR32_USART_MR_MODE_MODEM << AVR32_USART_MR_MODE_OFFSET; 00414 00415 return USART_SUCCESS; 00416 }
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.
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). |
USART_SUCCESS | Mode successfully initialized. | |
USART_INVALID_INPUT | One or more of the arguments is out of valid range. |
Definition at line 287 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 usart_init_hw_handshaking(), usart_init_IrDA(), usart_init_modem(), and usart_init_rs485().
00288 { 00289 // Reset the USART and shutdown TX and RX. 00290 usart_reset(usart); 00291 00292 // Check input values. 00293 if (!opt || // Null pointer. 00294 opt->charlength < 5 || opt->charlength > 9 || 00295 opt->paritytype > 7 || 00296 opt->stopbits > 2 + 255 || 00297 opt->channelmode > 3 || 00298 usart_set_async_baudrate(usart, opt->baudrate, pba_hz) == USART_INVALID_INPUT) 00299 return USART_INVALID_INPUT; 00300 00301 if (opt->charlength == 9) 00302 { 00303 // Character length set to 9 bits. MODE9 dominates CHRL. 00304 usart->mr |= AVR32_USART_MR_MODE9_MASK; 00305 } 00306 else 00307 { 00308 // CHRL gives the character length (- 5) when MODE9 = 0. 00309 usart->mr |= (opt->charlength - 5) << AVR32_USART_MR_CHRL_OFFSET; 00310 } 00311 00312 usart->mr |= opt->paritytype << AVR32_USART_MR_PAR_OFFSET | 00313 opt->channelmode << AVR32_USART_MR_CHMODE_OFFSET; 00314 00315 if (opt->stopbits > USART_2_STOPBITS) 00316 { 00317 // Set two stop bits 00318 usart->mr |= AVR32_USART_MR_NBSTOP_2 << AVR32_USART_MR_NBSTOP_OFFSET; 00319 // and a timeguard period gives the rest. 00320 usart->ttgr = opt->stopbits - USART_2_STOPBITS; 00321 } 00322 else 00323 // Insert 1, 1.5 or 2 stop bits. 00324 usart->mr |= opt->stopbits << AVR32_USART_MR_NBSTOP_OFFSET; 00325 00326 // Set normal mode. 00327 usart->mr = (usart->mr & ~AVR32_USART_MR_MODE_MASK) | 00328 AVR32_USART_MR_MODE_NORMAL << AVR32_USART_MR_MODE_OFFSET; 00329 00330 // Setup complete; enable communication. 00331 // Enable input and output. 00332 usart->cr = AVR32_USART_CR_RXEN_MASK | 00333 AVR32_USART_CR_TXEN_MASK; 00334 00335 return USART_SUCCESS; 00336 }
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.
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). |
USART_SUCCESS | Mode successfully initialized. | |
USART_INVALID_INPUT | One or more of the arguments is out of valid range. |
1.5
stop bit is not supported in this mode. Definition at line 339 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.
00340 { 00341 // Reset the USART and shutdown TX and RX. 00342 usart_reset(usart); 00343 00344 // Check input values. 00345 if (!opt || // Null pointer. 00346 opt->charlength < 5 || opt->charlength > 9 || 00347 opt->paritytype > 7 || 00348 opt->stopbits == 1 || opt->stopbits > 2 + 255 || 00349 opt->channelmode > 3 || 00350 usart_set_sync_master_baudrate(usart, opt->baudrate, pba_hz) == USART_INVALID_INPUT) 00351 return USART_INVALID_INPUT; 00352 00353 if (opt->charlength == 9) 00354 { 00355 // Character length set to 9 bits. MODE9 dominates CHRL. 00356 usart->mr |= AVR32_USART_MR_MODE9_MASK; 00357 } 00358 else 00359 { 00360 // CHRL gives the character length (- 5) when MODE9 = 0. 00361 usart->mr |= (opt->charlength - 5) << AVR32_USART_MR_CHRL_OFFSET; 00362 } 00363 00364 usart->mr |= opt->paritytype << AVR32_USART_MR_PAR_OFFSET | 00365 opt->channelmode << AVR32_USART_MR_CHMODE_OFFSET; 00366 00367 if (opt->stopbits > USART_2_STOPBITS) 00368 { 00369 // Set two stop bits 00370 usart->mr |= AVR32_USART_MR_NBSTOP_2 << AVR32_USART_MR_NBSTOP_OFFSET; 00371 // and a timeguard period gives the rest. 00372 usart->ttgr = opt->stopbits - USART_2_STOPBITS; 00373 } 00374 else 00375 // Insert 1 or 2 stop bits. 00376 usart->mr |= opt->stopbits << AVR32_USART_MR_NBSTOP_OFFSET; 00377 00378 // Set normal mode. 00379 usart->mr = (usart->mr & ~AVR32_USART_MR_MODE_MASK) | 00380 AVR32_USART_MR_MODE_NORMAL << AVR32_USART_MR_MODE_OFFSET; 00381 00382 // Setup complete; enable communication. 00383 // Enable only output as input is not possible in synchronous mode without 00384 // transferring clock. 00385 usart->cr = AVR32_USART_CR_TXEN_MASK; 00386 00387 return USART_SUCCESS; 00388 }
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.
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). |
USART_SUCCESS | Mode successfully initialized. | |
USART_INVALID_INPUT | One or more of the arguments is out of valid range. |
Definition at line 524 of file usart.c.
References usart_init_rs232(), USART_INVALID_INPUT, and USART_SUCCESS.
00525 { 00526 // First: Setup standard RS232. 00527 if (usart_init_rs232(usart, opt, pba_hz) == USART_INVALID_INPUT) 00528 return USART_INVALID_INPUT; 00529 00530 // Set RS485 mode. 00531 usart->mr = (usart->mr & ~AVR32_USART_MR_MODE_MASK) | 00532 AVR32_USART_MR_MODE_RS485 << AVR32_USART_MR_MODE_OFFSET; 00533 00534 return USART_SUCCESS; 00535 }
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.
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). |
USART_SUCCESS | Mode successfully initialized. | |
USART_INVALID_INPUT | One or more of the arguments is out of valid range. |
Definition at line 419 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.
00420 { 00421 // Reset the USART and shutdown TX and RX. 00422 usart_reset(usart); 00423 00424 // Check input values. 00425 if (!opt || // Null pointer. 00426 opt->charlength < 5 || opt->charlength > 9 || 00427 opt->paritytype > 7 || 00428 opt->stopbits == 1 || opt->stopbits > 2 + 255 || 00429 opt->channelmode > 3 || 00430 usart_set_sync_master_baudrate(usart, opt->baudrate, pba_hz) == USART_INVALID_INPUT) 00431 return USART_INVALID_INPUT; 00432 00433 if (opt->charlength == 9) 00434 { 00435 // Character length set to 9 bits. MODE9 dominates CHRL. 00436 usart->mr |= AVR32_USART_MR_MODE9_MASK; 00437 } 00438 else 00439 { 00440 // CHRL gives the character length (- 5) when MODE9 = 0. 00441 usart->mr |= (opt->charlength - 5) << AVR32_USART_MR_CHRL_OFFSET; 00442 } 00443 00444 usart->mr |= opt->paritytype << AVR32_USART_MR_PAR_OFFSET | 00445 opt->channelmode << AVR32_USART_MR_CHMODE_OFFSET; 00446 00447 if (opt->stopbits > USART_2_STOPBITS) 00448 { 00449 // Set two stop bits 00450 usart->mr |= AVR32_USART_MR_NBSTOP_2 << AVR32_USART_MR_NBSTOP_OFFSET; 00451 // and a timeguard period gives the rest. 00452 usart->ttgr = opt->stopbits - USART_2_STOPBITS; 00453 } 00454 else 00455 // Insert 1 or 2 stop bits. 00456 usart->mr |= opt->stopbits << AVR32_USART_MR_NBSTOP_OFFSET; 00457 00458 // Set normal mode. 00459 usart->mr = (usart->mr & ~AVR32_USART_MR_MODE_MASK) | 00460 AVR32_USART_MR_MODE_NORMAL << AVR32_USART_MR_MODE_OFFSET | 00461 AVR32_USART_MR_CLKO_MASK; 00462 00463 // Setup complete; enable communication. 00464 // Enable input and output. 00465 usart->cr = AVR32_USART_CR_RXEN_MASK | 00466 AVR32_USART_CR_TXEN_MASK; 00467 00468 return USART_SUCCESS; 00469 }
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.
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). |
USART_SUCCESS | Mode successfully initialized. | |
USART_INVALID_INPUT | One or more of the arguments is out of valid range. |
Definition at line 472 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.
00473 { 00474 // Reset the USART and shutdown TX and RX. 00475 usart_reset(usart); 00476 00477 // Check input values. 00478 if (!opt || // Null pointer. 00479 opt->charlength < 5 || opt->charlength > 9 || 00480 opt->paritytype > 7 || 00481 opt->stopbits == 1 || opt->stopbits > 2 + 255 || 00482 opt->channelmode > 3 || 00483 usart_set_sync_slave_baudrate(usart) == USART_INVALID_INPUT) 00484 return USART_INVALID_INPUT; 00485 00486 if (opt->charlength == 9) 00487 { 00488 // Character length set to 9 bits. MODE9 dominates CHRL. 00489 usart->mr |= AVR32_USART_MR_MODE9_MASK; 00490 } 00491 else 00492 { 00493 // CHRL gives the character length (- 5) when MODE9 = 0. 00494 usart->mr |= (opt->charlength - 5) << AVR32_USART_MR_CHRL_OFFSET; 00495 } 00496 00497 usart->mr |= opt->paritytype << AVR32_USART_MR_PAR_OFFSET | 00498 opt->channelmode << AVR32_USART_MR_CHMODE_OFFSET; 00499 00500 if (opt->stopbits > USART_2_STOPBITS) 00501 { 00502 // Set two stop bits 00503 usart->mr |= AVR32_USART_MR_NBSTOP_2 << AVR32_USART_MR_NBSTOP_OFFSET; 00504 // and a timeguard period gives the rest. 00505 usart->ttgr = opt->stopbits - USART_2_STOPBITS; 00506 } 00507 else 00508 // Insert 1 or 2 stop bits. 00509 usart->mr |= opt->stopbits << AVR32_USART_MR_NBSTOP_OFFSET; 00510 00511 // Set normal mode. 00512 usart->mr = (usart->mr & ~AVR32_USART_MR_MODE_MASK) | 00513 AVR32_USART_MR_MODE_NORMAL << AVR32_USART_MR_MODE_OFFSET; 00514 00515 // Setup complete; enable communication. 00516 // Enable input and output. 00517 usart->cr = AVR32_USART_CR_RXEN_MASK | 00518 AVR32_USART_CR_TXEN_MASK; 00519 00520 return USART_SUCCESS; 00521 }
__inline__ void usart_iso7816_enable_receiver | ( | volatile avr32_usart_t * | usart | ) |
Enables the ISO7816 receiver.
The ISO7816 transmitter is disabled.
usart | Base address of the USART instance. |
Definition at line 496 of file usart.h.
Referenced by usart_init_iso7816().
__inline__ void usart_iso7816_enable_transmitter | ( | volatile avr32_usart_t * | usart | ) |
__inline__ int usart_overrun_error | ( | volatile avr32_usart_t * | usart | ) |
__inline__ int usart_parity_error | ( | volatile avr32_usart_t * | usart | ) |
int usart_putchar | ( | volatile avr32_usart_t * | usart, | |
int | c | |||
) |
Sends a character with the USART.
usart | Base address of the USART instance. | |
c | Character to write. |
USART_SUCCESS | The character was written. | |
USART_FAILURE | The function timed out before the USART transmitter became ready to send. |
Definition at line 818 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().
00819 { 00820 int timeout = USART_DEFAULT_TIMEOUT; 00821 00822 if (c == '\n') 00823 { 00824 do 00825 { 00826 if (!timeout--) return USART_FAILURE; 00827 } while (usart_write_char(usart, '\r') != USART_SUCCESS); 00828 00829 timeout = USART_DEFAULT_TIMEOUT; 00830 } 00831 00832 do 00833 { 00834 if (!timeout--) return USART_FAILURE; 00835 } while (usart_write_char(usart, c) != USART_SUCCESS); 00836 00837 return USART_SUCCESS; 00838 }
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.
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). |
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 841 of file usart.c.
References USART_RX_EMPTY, USART_RX_ERROR, USART_SUCCESS, and usart_test_hit().
Referenced by usart_getchar().
00842 { 00843 // Check for errors: frame, parity and overrun. In RS485 mode, a parity error 00844 // would mean that an address char has been received. 00845 if (usart->csr & (AVR32_USART_CSR_OVRE_MASK | 00846 AVR32_USART_CSR_FRAME_MASK | 00847 AVR32_USART_CSR_PARE_MASK)) 00848 return USART_RX_ERROR; 00849 00850 // No error; if we really did receive a char, read it and return SUCCESS. 00851 if (usart_test_hit(usart)) 00852 { 00853 *c = (usart->rhr & AVR32_USART_RHR_RXCHR_MASK) >> AVR32_USART_RHR_RXCHR_OFFSET; 00854 return USART_SUCCESS; 00855 } 00856 else 00857 return USART_RX_EMPTY; 00858 }
void usart_reset | ( | volatile avr32_usart_t * | usart | ) |
Resets the USART and disables TX and RX.
usart | Base address of the USART instance. |
Definition at line 256 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().
00257 { 00258 Bool global_interrupt_enabled = Is_global_interrupt_enabled(); 00259 00260 // Disable all USART interrupts. 00261 // Interrupts needed should be set explicitly on every reset. 00262 if (global_interrupt_enabled) Disable_global_interrupt(); 00263 usart->idr = 0xFFFFFFFF; 00264 usart->csr; 00265 if (global_interrupt_enabled) Enable_global_interrupt(); 00266 00267 // Reset mode and other registers that could cause unpredictable behavior after reset. 00268 usart->mr = 0; 00269 usart->rtor = 0; 00270 usart->ttgr = 0; 00271 00272 // Shutdown TX and RX (will be re-enabled when setup has successfully completed), 00273 // reset status bits and turn off DTR and RTS. 00274 usart->cr = AVR32_USART_CR_RSTRX_MASK | 00275 AVR32_USART_CR_RSTTX_MASK | 00276 AVR32_USART_CR_RSTSTA_MASK | 00277 AVR32_USART_CR_RSTIT_MASK | 00278 AVR32_USART_CR_RSTNACK_MASK | 00279 #ifndef AVR32_USART_440_H_INCLUDED 00280 // Note: Modem Signal Management DTR-DSR-DCD-RI are not included in USART rev.440. 00281 AVR32_USART_CR_DTRDIS_MASK | 00282 #endif 00283 AVR32_USART_CR_RTSDIS_MASK; 00284 }
__inline__ void usart_reset_status | ( | volatile avr32_usart_t * | usart | ) |
Resets the error status.
This function resets the status bits indicating that a parity error, framing error or overrun has occurred. The RXBRK bit, indicating a start/end of break condition on the RX line, is also reset.
usart | Base address of the USART instance. |
Definition at line 406 of file usart.h.
Referenced by lin_int_handler_node0(), and lin_send_cmd().
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.
usart | Base address of the USART instance. | |
address | Address of the target device. |
USART_SUCCESS | Address successfully sent (if current mode is RS485). | |
USART_MODE_FAULT | Wrong operating mode. |
Definition at line 791 of file usart.c.
References usart_bw_write_char(), USART_MODE_FAULT, usart_mode_is_multidrop(), and USART_SUCCESS.
00792 { 00793 // Check if USART is in multidrop / RS485 mode. 00794 if (!usart_mode_is_multidrop(usart)) return USART_MODE_FAULT; 00795 00796 // Prepare to send an address. 00797 usart->cr = AVR32_USART_CR_SENDA_MASK; 00798 00799 // Write the address to TX. 00800 usart_bw_write_char(usart, address); 00801 00802 return USART_SUCCESS; 00803 }
__inline__ int usart_test_hit | ( | volatile avr32_usart_t * | usart | ) |
Tests if the USART contains a received character.
usart | Base address of the USART instance. |
1
if the USART Receive Holding Register is full, otherwise 0
. Definition at line 809 of file usart.h.
Referenced by usart_read_char().
__inline__ int usart_tx_empty | ( | volatile avr32_usart_t * | usart | ) |
__inline__ int usart_tx_ready | ( | volatile avr32_usart_t * | usart | ) |
Tests if the USART is ready to transmit a character.
usart | Base address of the USART instance. |
1
if the USART Transmit Holding Register is free, otherwise 0
. Definition at line 747 of file usart.h.
Referenced by usart_write_char().
int usart_write_char | ( | volatile avr32_usart_t * | usart, | |
int | c | |||
) |
Writes the given character to the TX buffer if the transmitter is ready.
usart | Base address of the USART instance. | |
c | The character (up to 9 bits) to transmit. |
USART_SUCCESS | The transmitter was ready. | |
USART_TX_BUSY | The transmitter was busy. |
Definition at line 806 of file usart.c.
References USART_SUCCESS, USART_TX_BUSY, and usart_tx_ready().
Referenced by usart_bw_write_char(), and usart_putchar().
00807 { 00808 if (usart_tx_ready(usart)) 00809 { 00810 usart->thr = (c << AVR32_USART_THR_TXCHR_OFFSET) & AVR32_USART_THR_TXCHR_MASK; 00811 return USART_SUCCESS; 00812 } 00813 else 00814 return USART_TX_BUSY; 00815 }
void usart_write_line | ( | volatile avr32_usart_t * | usart, | |
const char * | string | |||
) |
Writes one character string to the USART.
usart | Base address of the USART instance. | |
string | String to be written. |
Definition at line 874 of file usart.c.
References usart_putchar().
Referenced by usart_get_echo_line().
00875 { 00876 while (*string != '\0') 00877 usart_putchar(usart, *string++); 00878 }