Universal Synchronous Asynchronous Receiver

Transmitter (USART). More...

Data Structures
struct	sam_usart_opt_t
	micro definition for LIN mode of SAMV71 More...
struct	usart_iso7816_opt_t
struct	usart_spi_opt_t

Macros
#define	SPI_CPHA   (1 << 0)
	Clock phase.
#define	SPI_CPOL   (1 << 1)
	Clock polarity.
#define	SPI_MODE_0   0
	SPI mode definition.
#define	SPI_MODE_1   (SPI_CPHA)
#define	SPI_MODE_2   (SPI_CPOL)
#define	SPI_MODE_3   (SPI_CPOL | SPI_CPHA)

Functions
void	usart_disable_interrupt (Usart *p_usart, uint32_t ul_sources)
	Disable USART interrupts.
void	usart_disable_rx (Usart *p_usart)
	Disable USART receiver.
void	usart_disable_tx (Usart *p_usart)
	Disable USART transmitter.
void	usart_disable_writeprotect (Usart *p_usart)
	Disable write protect of USART registers.
void	usart_drive_DTR_pin_high (Usart *p_usart)
	Drive the pin DTR to 1.
void	usart_drive_DTR_pin_low (Usart *p_usart)
	Drive the pin DTR to 0.
void	usart_drive_RTS_pin_high (Usart *p_usart)
	Drive the pin RTS to 1.
void	usart_drive_RTS_pin_low (Usart *p_usart)
	Drive the pin RTS to 0.
void	usart_enable_interrupt (Usart *p_usart, uint32_t ul_sources)
	Enable USART interrupts.
void	usart_enable_rx (Usart *p_usart)
	Enable USART receiver.
void	usart_enable_tx (Usart *p_usart)
	Enable USART transmitter.
void	usart_enable_writeprotect (Usart *p_usart)
	Enable write protect of USART registers.
uint8_t	usart_get_error_number (Usart *p_usart)
	Get the total number of errors that occur during an ISO7816 transfer.
uint32_t	usart_get_interrupt_mask (Usart *p_usart)
	Read USART interrupt mask.
Pdc *	usart_get_pdc_base (Usart *p_usart)
	Get USART PDC base address.
uint32_t	usart_get_status (Usart *p_usart)
	Get current status.
uint32_t	usart_get_writeprotect_status (Usart *p_usart)
	Get write protect status.
uint32_t	usart_getchar (Usart *p_usart, uint32_t *c)
	Read from USART Receive Holding Register.
uint32_t	usart_init_hw_handshaking (Usart *p_usart, const sam_usart_opt_t *p_usart_opt, uint32_t ul_mck)
	Configure USART to work in hardware handshaking mode.
uint32_t	usart_init_irda (Usart *p_usart, const sam_usart_opt_t *p_usart_opt, uint32_t ul_mck)
	Configure USART to work in IrDA mode.
uint32_t	usart_init_iso7816 (Usart *p_usart, const usart_iso7816_opt_t *p_usart_opt, uint32_t ul_mck)
	Configure USART to work in ISO7816 mode.
uint32_t	usart_init_modem (Usart *p_usart, const sam_usart_opt_t *p_usart_opt, uint32_t ul_mck)
	Configure USART to work in modem mode.
uint32_t	usart_init_rs232 (Usart *p_usart, const sam_usart_opt_t *p_usart_opt, uint32_t ul_mck)
	Configure USART to work in RS232 mode.
uint32_t	usart_init_rs485 (Usart *p_usart, const sam_usart_opt_t *p_usart_opt, uint32_t ul_mck)
	Configure USART to work in RS485 mode.
uint32_t	usart_init_spi_master (Usart *p_usart, const usart_spi_opt_t *p_usart_opt, uint32_t ul_mck)
	Configure USART to work in SPI mode and act as a master.
uint32_t	usart_init_spi_slave (Usart *p_usart, const usart_spi_opt_t *p_usart_opt)
	Configure USART to work in SPI mode and act as a slave.
uint32_t	usart_init_sync_master (Usart *p_usart, const sam_usart_opt_t *p_usart_opt, uint32_t ul_mck)
	Configure USART to work in SYNC mode and act as a master.
uint32_t	usart_init_sync_slave (Usart *p_usart, const sam_usart_opt_t *p_usart_opt)
	Configure USART to work in SYNC mode and act as a slave.
uint32_t	usart_is_rx_buf_end (Usart *p_usart)
	Check if one receive buffer is filled.
uint32_t	usart_is_rx_buf_full (Usart *p_usart)
	Check if both receive buffers are full.
uint32_t	usart_is_rx_ready (Usart *p_usart)
	Check if the received data are ready.
uint32_t	usart_is_tx_buf_empty (Usart *p_usart)
	Check if both transmit buffers are empty.
uint32_t	usart_is_tx_buf_end (Usart *p_usart)
	Check if one transmit buffer is empty.
uint32_t	usart_is_tx_empty (Usart *p_usart)
	Check if Transmit Holding Register is empty.
uint32_t	usart_is_tx_ready (Usart *p_usart)
	Check if Transmit is Ready.
void	usart_man_disable_drift_compensation (Usart *p_usart)
	Disable drift compensation.
void	usart_man_enable_drift_compensation (Usart *p_usart)
	Enable drift compensation.
void	usart_man_set_rx_polarity (Usart *p_usart, uint8_t uc_polarity)
	Configure the receiver Manchester polarity when the Manchester encode/decode is enabled.
void	usart_man_set_rx_pre_len (Usart *p_usart, uint8_t uc_len)
	Configure the detected receiver preamble length when the Manchester encode/decode is enabled.
void	usart_man_set_rx_pre_pattern (Usart *p_usart, uint8_t uc_pattern)
	Configure the detected receiver preamble pattern when the Manchester encode/decode is enabled, which should be 0 ~ 3.
void	usart_man_set_tx_polarity (Usart *p_usart, uint8_t uc_polarity)
	Configure the transmitter Manchester polarity when the Manchester encode/decode is enabled.
void	usart_man_set_tx_pre_len (Usart *p_usart, uint8_t uc_len)
	Configure the transmitter preamble length when the Manchester encode/decode is enabled.
void	usart_man_set_tx_pre_pattern (Usart *p_usart, uint8_t uc_pattern)
	Configure the transmitter preamble pattern when the Manchester encode/decode is enabled, which should be 0 ~ 3.
uint32_t	usart_putchar (Usart *p_usart, uint32_t c)
	Write to USART Transmit Holding Register.
uint32_t	usart_read (Usart *p_usart, uint32_t *c)
	Read from USART Receive Holding Register.
void	usart_reset (Usart *p_usart)
	Reset the USART and disable TX and RX.
void	usart_reset_iterations (Usart *p_usart)
	Reset the ITERATION in US_CSR when the ISO7816 mode is enabled.
void	usart_reset_nack (Usart *p_usart)
	Reset NACK in US_CSR.
void	usart_reset_rx (Usart *p_usart)
	Immediately stop and disable USART receiver.
void	usart_reset_status (Usart *p_usart)
	Reset status bits (PARE, OVER, MANERR, UNRE and PXBRK in US_CSR).
void	usart_reset_tx (Usart *p_usart)
	Immediately stop and disable USART transmitter.
void	usart_restart_rx_timeout (Usart *p_usart)
	Restart the receive timeout.
uint32_t	usart_send_address (Usart *p_usart, uint32_t ul_addr)
	In Multidrop mode only, the next character written to the US_THR is sent with the address bit set.
uint32_t	usart_set_async_baudrate (Usart *p_usart, uint32_t baudrate, uint32_t ul_mck)
	Calculate a clock divider(CD) and a fractional part (FP) for the USART asynchronous modes to generate a baudrate as close as possible to the baudrate set point.
void	usart_set_rx_timeout (Usart *p_usart, uint32_t timeout)
	Configure the receive timeout register.
void	usart_set_tx_timeguard (Usart *p_usart, uint32_t timeguard)
	Configure the transmit timeguard register.
void	usart_spi_force_chip_select (Usart *p_usart)
	Drive the slave select line NSS (RTS pin) to 0 in SPI master mode.
void	usart_spi_release_chip_select (Usart *p_usart)
	Drive the slave select line NSS (RTS pin) to 1 in SPI master mode.
void	usart_start_rx_timeout (Usart *p_usart)
	Start waiting for a character before clocking the timeout count.
void	usart_start_tx_break (Usart *p_usart)
	Start transmission of a break.
void	usart_stop_tx_break (Usart *p_usart)
	Stop transmission of a break.
uint32_t	usart_write (Usart *p_usart, uint32_t c)
	Write to USART Transmit Holding Register.
void	usart_write_line (Usart *p_usart, const char *string)
	Write one-line string through USART.

Detailed Description

Transmitter (USART).

See Quick start guide for the SAM USART module.

This is a low-level driver implementation for the SAM Universal Synchronous/Asynchronous Receiver/Transmitter.

Macro Definition Documentation

SPI_CPHA

#define SPI_CPHA   (1 << 0)

Clock phase.

Definition at line 64 of file usart.h.

SPI_CPOL

#define SPI_CPOL   (1 << 1)

Clock polarity.

Definition at line 67 of file usart.h.

SPI_MODE_0

#define SPI_MODE_0   0

SPI mode definition.

Definition at line 70 of file usart.h.

Referenced by usart_init_spi_master(), and usart_init_spi_slave().

SPI_MODE_1

#define SPI_MODE_1   (SPI_CPHA)

Definition at line 71 of file usart.h.

Referenced by usart_init_spi_master(), and usart_init_spi_slave().

SPI_MODE_2

#define SPI_MODE_2   (SPI_CPOL)

Definition at line 72 of file usart.h.

Referenced by usart_init_spi_master(), and usart_init_spi_slave().

SPI_MODE_3

#define SPI_MODE_3   (SPI_CPOL | SPI_CPHA)

Definition at line 73 of file usart.h.

Referenced by usart_init_spi_master(), and usart_init_spi_slave().

Function Documentation

usart_disable_interrupt()

void usart_disable_interrupt	(	Usart *	p_usart,
		uint32_t	ul_sources )

Disable USART interrupts.

Parameters

p_usart	Pointer to a USART peripheral.
ul_sources	Interrupt sources bit map.

Definition at line 1480 of file usart.c.

{
    p_usart->US_IDR = ul_sources;
}

References Usart::US_IDR.

usart_disable_rx()

void usart_disable_rx

(

Usart *

p_usart

)

Disable USART receiver.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1436 of file usart.c.

{
    p_usart->US_CR = US_CR_RXDIS;
}

References Usart::US_CR, and US_CR_RXDIS.

usart_disable_tx()

void usart_disable_tx

(

Usart *

p_usart

)

Disable USART transmitter.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1394 of file usart.c.

{
    p_usart->US_CR = US_CR_TXDIS;
}

References Usart::US_CR, and US_CR_TXDIS.

usart_disable_writeprotect()

void usart_disable_writeprotect

(

Usart *

p_usart

)

Disable write protect of USART registers.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1907 of file usart.c.

{
    p_usart->US_WPMR = US_WPMR_WPKEY_PASSWD;
}

References Usart::US_WPMR, and US_WPMR_WPKEY_PASSWD.

Referenced by usart_reset().

usart_drive_DTR_pin_high()

void usart_drive_DTR_pin_high

(

Usart *

p_usart

)

Drive the pin DTR to 1.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1602 of file usart.c.

{
    p_usart->US_CR = US_CR_DTRDIS;
}

References Usart::US_CR, and US_CR_DTRDIS.

Referenced by usart_reset().

usart_drive_DTR_pin_low()

void usart_drive_DTR_pin_low

(

Usart *

p_usart

)

Drive the pin DTR to 0.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1592 of file usart.c.

{
    p_usart->US_CR = US_CR_DTREN;
}

References Usart::US_CR, and US_CR_DTREN.

usart_drive_RTS_pin_high()

void usart_drive_RTS_pin_high

(

Usart *

p_usart

)

Drive the pin RTS to 1.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1624 of file usart.c.

{
    p_usart->US_CR = US_CR_RTSDIS;
}

References Usart::US_CR, and US_CR_RTSDIS.

Referenced by usart_reset().

usart_drive_RTS_pin_low()

void usart_drive_RTS_pin_low

(

Usart *

p_usart

)

Drive the pin RTS to 0.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1614 of file usart.c.

{
    p_usart->US_CR = US_CR_RTSEN;
}

References Usart::US_CR, and US_CR_RTSEN.

usart_enable_interrupt()

void usart_enable_interrupt	(	Usart *	p_usart,
		uint32_t	ul_sources )

Enable USART interrupts.

Parameters

p_usart	Pointer to a USART peripheral.
ul_sources	Interrupt sources bit map.

Definition at line 1469 of file usart.c.

{
    p_usart->US_IER = ul_sources;
}

References Usart::US_IER.

usart_enable_rx()

void usart_enable_rx

(

Usart *

p_usart

)

Enable USART receiver.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1426 of file usart.c.

{
    p_usart->US_CR = US_CR_RXEN;
}

References Usart::US_CR, and US_CR_RXEN.

Referenced by usart_serial_init().

usart_enable_tx()

void usart_enable_tx

(

Usart *

p_usart

)

Enable USART transmitter.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1384 of file usart.c.

{
    p_usart->US_CR = US_CR_TXEN;
}

References Usart::US_CR, and US_CR_TXEN.

Referenced by usart_serial_init().

usart_enable_writeprotect()

void usart_enable_writeprotect

(

Usart *

p_usart

)

Enable write protect of USART registers.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1897 of file usart.c.

{
    p_usart->US_WPMR = US_WPMR_WPEN | US_WPMR_WPKEY_PASSWD;
}

References Usart::US_WPMR, US_WPMR_WPEN, and US_WPMR_WPKEY_PASSWD.

usart_get_error_number()

uint8_t usart_get_error_number

(

Usart *

p_usart

)

Get the total number of errors that occur during an ISO7816 transfer.

Parameters

p_usart

Pointer to a USART instance.

Returns

The number of errors that occurred.

Definition at line 699 of file usart.c.

{
    return (p_usart->US_NER & US_NER_NB_ERRORS_Msk);
}

References Usart::US_NER, and US_NER_NB_ERRORS_Msk.

usart_get_interrupt_mask()

uint32_t usart_get_interrupt_mask

(

Usart *

p_usart

)

Read USART interrupt mask.

Parameters

p_usart

Pointer to a USART peripheral.

Returns

The interrupt mask value.

Definition at line 1492 of file usart.c.

{
    return p_usart->US_IMR;
}

References Usart::US_IMR.

usart_get_pdc_base()

Pdc * usart_get_pdc_base

(

Usart *

p_usart

)

Get USART PDC base address.

Parameters

p_usart

Pointer to a UART instance.

Returns

USART PDC registers base for PDC driver to access.

Definition at line 1827 of file usart.c.

{
    Pdc *p_pdc_base;
 
    p_pdc_base = (Pdc *)NULL;
 
#ifdef PDC_USART
    if (p_usart == USART) {
        p_pdc_base = PDC_USART;
        return p_pdc_base;
    }
#endif
#ifdef PDC_USART0
    if (p_usart == USART0) {
        p_pdc_base = PDC_USART0;
        return p_pdc_base;
    }
#endif
#ifdef PDC_USART1
    else if (p_usart == USART1) {
        p_pdc_base = PDC_USART1;
        return p_pdc_base;
    }
#endif
#ifdef PDC_USART2
    else if (p_usart == USART2) {
        p_pdc_base = PDC_USART2;
        return p_pdc_base;
    }
#endif
#ifdef PDC_USART3
    else if (p_usart == USART3) {
        p_pdc_base = PDC_USART3;
        return p_pdc_base;
    }
#endif
#ifdef PDC_USART4
    else if (p_usart == USART4) {
        p_pdc_base = PDC_USART4;
        return p_pdc_base;
    }
#endif
#ifdef PDC_USART5
    else if (p_usart == USART5) {
        p_pdc_base = PDC_USART5;
        return p_pdc_base;
    }
#endif
#ifdef PDC_USART6
    else if (p_usart == USART6) {
        p_pdc_base = PDC_USART6;
        return p_pdc_base;
    }
#endif
#ifdef PDC_USART7
    else if (p_usart == USART7) {
        p_pdc_base = PDC_USART7;
        return p_pdc_base;
    }
#endif
 
    return p_pdc_base;
}

References PDC_USART0, PDC_USART1, USART0, and USART1.

usart_get_status()

uint32_t usart_get_status

(

Usart *

p_usart

)

Get current status.

Parameters

p_usart

Pointer to a USART instance.

Returns

The current USART status.

Definition at line 1504 of file usart.c.

{
    return p_usart->US_CSR;
}

References Usart::US_CSR.

usart_get_writeprotect_status()

uint32_t usart_get_writeprotect_status

(

Usart *

p_usart

)

Get write protect status.

Parameters

p_usart

Pointer to a USART instance.

Returns

0 if no write protect violation occurred, or 16-bit write protect violation source.

Definition at line 1920 of file usart.c.

{
    uint32_t reg_value;
 
    reg_value = p_usart->US_WPSR;
    if (reg_value & US_WPSR_WPVS) {
        return (reg_value & US_WPSR_WPVSRC_Msk) >> US_WPSR_WPVSRC_Pos;
    } else {
        return 0;
    }
}

References Usart::US_WPSR, US_WPSR_WPVS, US_WPSR_WPVSRC_Msk, and US_WPSR_WPVSRC_Pos.

usart_getchar()

uint32_t usart_getchar	(	Usart *	p_usart,
		uint32_t *	c )

Read from USART Receive Holding Register.

Before reading user should check if rx is ready.

Parameters

p_usart	Pointer to a USART instance.
c	Pointer where the one-byte received data will be stored.

Return values

0	Data has been received.
1	on failure.

Definition at line 1781 of file usart.c.

{
    /* Wait until it's not empty or timeout has reached. */
    while (!(p_usart->US_CSR & US_CSR_RXRDY)) {
    }
 
    /* Read character */
    *c = p_usart->US_RHR & US_RHR_RXCHR_Msk;
 
    return 0;
}

References Usart::US_CSR, US_CSR_RXRDY, Usart::US_RHR, and US_RHR_RXCHR_Msk.

usart_init_hw_handshaking()

uint32_t usart_init_hw_handshaking	(	Usart *	p_usart,
		const sam_usart_opt_t *	p_usart_opt,
		uint32_t	ul_mck )

Configure USART to work in hardware handshaking mode.

Note

By default, the transmitter and receiver aren't enabled.

Parameters

p_usart	Pointer to a USART instance.
p_usart_opt	Pointer to sam_usart_opt_t instance.
ul_mck	USART module input clock frequency.

Return values

0	on success.
1	on failure.

Definition at line 313 of file usart.c.

{
    /* Initialize the USART as standard RS232. */
    if (usart_init_rs232(p_usart, p_usart_opt, ul_mck)) {
        return 1;
    }
 
    /* Set hardware handshaking mode. */
    p_usart->US_MR = (p_usart->US_MR & ~US_MR_USART_MODE_Msk) |
            US_MR_USART_MODE_HW_HANDSHAKING;
 
    return 0;
}

References Usart::US_MR, US_MR_USART_MODE_HW_HANDSHAKING, US_MR_USART_MODE_Msk, and usart_init_rs232().

usart_init_irda()

uint32_t usart_init_irda	(	Usart *	p_usart,
		const sam_usart_opt_t *	p_usart_opt,
		uint32_t	ul_mck )

Configure USART to work in IrDA mode.

Note

By default, the transmitter and receiver aren't enabled.

Parameters

p_usart	Pointer to a USART instance.
p_usart_opt	Pointer to sam_usart_opt_t instance.
ul_mck	USART module input clock frequency.

Return values

0	on success.
1	on failure.

Definition at line 490 of file usart.c.

{
    /* Initialize the USART as standard RS232. */
    if (usart_init_rs232(p_usart, p_usart_opt, ul_mck)) {
        return 1;
    }
 
    /* Set IrDA filter. */
    p_usart->US_IF = p_usart_opt->irda_filter;
 
    /* Set IrDA mode. */
    p_usart->US_MR = (p_usart->US_MR & ~US_MR_USART_MODE_Msk) |
            US_MR_USART_MODE_IRDA;
 
    return 0;
}

References sam_usart_opt_t::irda_filter, Usart::US_IF, Usart::US_MR, US_MR_USART_MODE_IRDA, US_MR_USART_MODE_Msk, and usart_init_rs232().

usart_init_iso7816()

uint32_t usart_init_iso7816	(	Usart *	p_usart,
		const usart_iso7816_opt_t *	p_usart_opt,
		uint32_t	ul_mck )

Configure USART to work in ISO7816 mode.

Note

By default, the transmitter and receiver aren't enabled.

Parameters

p_usart	Pointer to a USART instance.
p_usart_opt	Pointer to sam_usart_opt_t instance.
ul_mck	USART module input clock frequency.

Return values

0	on success.
1	on failure.

Definition at line 557 of file usart.c.

{
    static uint32_t ul_reg_val;
 
    /* Reset the USART and shut down TX and RX. */
    usart_reset(p_usart);
 
    ul_reg_val = 0;
 
    /* Check whether the input values are legal. */
    if (!p_usart_opt || ((p_usart_opt->parity_type != US_MR_PAR_EVEN) &&
            (p_usart_opt->parity_type != US_MR_PAR_ODD))) {
        return 1;
    }
 
    if (p_usart_opt->protocol_type == ISO7816_T_0) {
        ul_reg_val |= US_MR_USART_MODE_IS07816_T_0 | US_MR_NBSTOP_2_BIT |
                (p_usart_opt->max_iterations << US_MR_MAX_ITERATION_Pos);
 
        if (p_usart_opt->bit_order) {
            ul_reg_val |= US_MR_MSBF;
        }
    } else if (p_usart_opt->protocol_type == ISO7816_T_1) {
        /*
         * Only LSBF is used in the T=1 protocol, and max_iterations field
         * is only used in T=0 mode.
         */
        if (p_usart_opt->bit_order || p_usart_opt->max_iterations) {
            return 1;
        }
 
        /* Set USART mode to ISO7816, T=1, and always uses 1 stop bit. */
        ul_reg_val |= US_MR_USART_MODE_IS07816_T_1 | US_MR_NBSTOP_1_BIT;
    } else {
        return 1;
    }
 
    /* Set up the baudrate. */
    if (usart_set_iso7816_clock(p_usart, p_usart_opt->iso7816_hz, ul_mck)) {
        return 1;
    }
 
    /* Set FIDI register: bit rate = iso7816_hz / fidi_ratio. */
    p_usart->US_FIDI = p_usart_opt->fidi_ratio;
 
    /* Set ISO7816 parity type in the MODE register. */
    ul_reg_val |= p_usart_opt->parity_type;
 
    if (p_usart_opt->inhibit_nack) {
        ul_reg_val |= US_MR_INACK;
    }
    if (p_usart_opt->dis_suc_nack) {
        ul_reg_val |= US_MR_DSNACK;
    }
 
    p_usart->US_MR |= ul_reg_val;
 
    return 0;
}

References usart_iso7816_opt_t::bit_order, usart_iso7816_opt_t::dis_suc_nack, usart_iso7816_opt_t::fidi_ratio, usart_iso7816_opt_t::inhibit_nack, usart_iso7816_opt_t::iso7816_hz, ISO7816_T_0, ISO7816_T_1, usart_iso7816_opt_t::max_iterations, usart_iso7816_opt_t::parity_type, usart_iso7816_opt_t::protocol_type, Usart::US_FIDI, Usart::US_MR, US_MR_DSNACK, US_MR_INACK, US_MR_MAX_ITERATION_Pos, US_MR_MSBF, US_MR_NBSTOP_1_BIT, US_MR_NBSTOP_2_BIT, US_MR_PAR_EVEN, US_MR_PAR_ODD, US_MR_USART_MODE_IS07816_T_0, US_MR_USART_MODE_IS07816_T_1, usart_reset(), and usart_set_iso7816_clock().

usart_init_modem()

uint32_t usart_init_modem	(	Usart *	p_usart,
		const sam_usart_opt_t *	p_usart_opt,
		uint32_t	ul_mck )

Configure USART to work in modem mode.

Note

By default, the transmitter and receiver aren't enabled.

Parameters

p_usart	Pointer to a USART instance.
p_usart_opt	Pointer to sam_usart_opt_t instance.
ul_mck	USART module input clock frequency.

Return values

0	on success.
1	on failure.

Definition at line 342 of file usart.c.

{
    /*
     * SAM3S, SAM4S and SAM4E series support MODEM mode only on USART1,
     * SAM3U and SAM4L series support MODEM mode only on USART0.
     */
#if (SAM3S || SAM4S || SAM4E)
#ifdef USART1
    if (p_usart != USART1) {
        return 1;
    }
#endif
#elif (SAM3U || SAM4L)
    if (p_usart != USART0) {
        return 1;
    }
#endif
 
    /* Initialize the USART as standard RS232. */
    if (usart_init_rs232(p_usart, p_usart_opt, ul_mck)) {
        return 1;
    }
 
    /* Set MODEM mode. */
    p_usart->US_MR = (p_usart->US_MR & ~US_MR_USART_MODE_Msk) |
            US_MR_USART_MODE_MODEM;
 
    return 0;
}

References Usart::US_MR, US_MR_USART_MODE_MODEM, US_MR_USART_MODE_Msk, USART0, USART1, and usart_init_rs232().

usart_init_rs232()

uint32_t usart_init_rs232	(	Usart *	p_usart,
		const sam_usart_opt_t *	p_usart_opt,
		uint32_t	ul_mck )

Configure USART to work in RS232 mode.

Note

By default, the transmitter and receiver aren't enabled.

Parameters

p_usart	Pointer to a USART instance.
p_usart_opt	Pointer to sam_usart_opt_t instance.
ul_mck	USART module input clock frequency.

Return values

0	on success.
1	on failure.

Definition at line 274 of file usart.c.

{
    static uint32_t ul_reg_val;
 
    /* Reset the USART and shut down TX and RX. */
    usart_reset(p_usart);
 
    ul_reg_val = 0;
    /* Check whether the input values are legal. */
    if (!p_usart_opt || usart_set_async_baudrate(p_usart,
            p_usart_opt->baudrate, ul_mck)) {
        return 1;
    }
 
    /* Configure the USART option. */
    ul_reg_val |= p_usart_opt->char_length | p_usart_opt->parity_type |
            p_usart_opt->channel_mode | p_usart_opt->stop_bits;
 
    /* Configure the USART mode as normal mode. */
    ul_reg_val |= US_MR_USART_MODE_NORMAL;
 
    p_usart->US_MR |= ul_reg_val;
 
    return 0;
}

References sam_usart_opt_t::baudrate, sam_usart_opt_t::channel_mode, sam_usart_opt_t::char_length, sam_usart_opt_t::parity_type, sam_usart_opt_t::stop_bits, Usart::US_MR, US_MR_USART_MODE_NORMAL, usart_reset(), and usart_set_async_baudrate().

Referenced by usart_init_hw_handshaking(), usart_init_irda(), usart_init_modem(), usart_init_rs485(), and usart_serial_init().

usart_init_rs485()

uint32_t usart_init_rs485	(	Usart *	p_usart,
		const sam_usart_opt_t *	p_usart_opt,
		uint32_t	ul_mck )

Configure USART to work in RS485 mode.

Note

By default, the transmitter and receiver aren't enabled.

Parameters

p_usart	Pointer to a USART instance.
p_usart_opt	Pointer to sam_usart_opt_t instance.
ul_mck	USART module input clock frequency.

Return values

0	on success.
1	on failure.

Definition at line 462 of file usart.c.

{
    /* Initialize the USART as standard RS232. */
    if (usart_init_rs232(p_usart, p_usart_opt, ul_mck)) {
        return 1;
    }
 
    /* Set RS485 mode. */
    p_usart->US_MR = (p_usart->US_MR & ~US_MR_USART_MODE_Msk) |
            US_MR_USART_MODE_RS485;
 
    return 0;
}

References Usart::US_MR, US_MR_USART_MODE_Msk, US_MR_USART_MODE_RS485, and usart_init_rs232().

usart_init_spi_master()

uint32_t usart_init_spi_master	(	Usart *	p_usart,
		const usart_spi_opt_t *	p_usart_opt,
		uint32_t	ul_mck )

Configure USART to work in SPI mode and act as a master.

Note

By default, the transmitter and receiver aren't enabled.

Parameters

p_usart	Pointer to a USART instance.
p_usart_opt	Pointer to sam_usart_opt_t instance.
ul_mck	USART module input clock frequency.

Return values

0	on success.
1	on failure.

Definition at line 718 of file usart.c.

{
    static uint32_t ul_reg_val;
 
    /* Reset the USART and shut down TX and RX. */
    usart_reset(p_usart);
 
    ul_reg_val = 0;
    /* Check whether the input values are legal. */
    if (!p_usart_opt || (p_usart_opt->spi_mode > SPI_MODE_3) ||
            usart_set_spi_master_baudrate(p_usart, p_usart_opt->baudrate,
            ul_mck)) {
        return 1;
    }
 
    /* Configure the character length bit in MR register. */
    ul_reg_val |= p_usart_opt->char_length;
 
    /* Set SPI master mode and channel mode. */
    ul_reg_val |= US_MR_USART_MODE_SPI_MASTER | US_MR_CLKO |
            p_usart_opt->channel_mode;
 
    switch (p_usart_opt->spi_mode) {
    case SPI_MODE_0:
        ul_reg_val |= US_MR_CPHA;
        ul_reg_val &= ~US_MR_CPOL;
        break;
 
    case SPI_MODE_1:
        ul_reg_val &= ~US_MR_CPHA;
        ul_reg_val &= ~US_MR_CPOL;
        break;
 
    case SPI_MODE_2:
        ul_reg_val |= US_MR_CPHA;
        ul_reg_val |= US_MR_CPOL;
        break;
 
    case SPI_MODE_3:
        ul_reg_val &= ~US_MR_CPHA;
        ul_reg_val |= US_MR_CPOL;
        break;
 
    default:
        break;
    }
 
    p_usart->US_MR |= ul_reg_val;
 
    return 0;
}

References usart_spi_opt_t::baudrate, usart_spi_opt_t::channel_mode, usart_spi_opt_t::char_length, usart_spi_opt_t::spi_mode, SPI_MODE_0, SPI_MODE_1, SPI_MODE_2, SPI_MODE_3, Usart::US_MR, US_MR_CLKO, US_MR_CPHA, US_MR_CPOL, US_MR_USART_MODE_SPI_MASTER, usart_reset(), and usart_set_spi_master_baudrate().

usart_init_spi_slave()

uint32_t usart_init_spi_slave	(	Usart *	p_usart,
		const usart_spi_opt_t *	p_usart_opt )

Configure USART to work in SPI mode and act as a slave.

Note

By default, the transmitter and receiver aren't enabled.

Parameters

p_usart	Pointer to a USART instance.
p_usart_opt	Pointer to sam_usart_opt_t instance.

Return values

0	on success.
1	on failure.

Definition at line 782 of file usart.c.

{
    static uint32_t ul_reg_val;
 
    /* Reset the USART and shut down TX and RX. */
    usart_reset(p_usart);
 
    ul_reg_val = 0;
    usart_set_spi_slave_baudrate(p_usart);
 
    /* Check whether the input values are legal. */
    if (!p_usart_opt || p_usart_opt->spi_mode > SPI_MODE_3) {
        return 1;
    }
 
    /* Configure the character length bit in MR register. */
    ul_reg_val |= p_usart_opt->char_length;
 
    /* Set SPI slave mode and channel mode. */
    ul_reg_val |= US_MR_USART_MODE_SPI_SLAVE | p_usart_opt->channel_mode;
 
    switch (p_usart_opt->spi_mode) {
    case SPI_MODE_0:
        ul_reg_val |= US_MR_CPHA;
        ul_reg_val &= ~US_MR_CPOL;
        break;
 
    case SPI_MODE_1:
        ul_reg_val &= ~US_MR_CPHA;
        ul_reg_val &= ~US_MR_CPOL;
        break;
 
    case SPI_MODE_2:
        ul_reg_val |= US_MR_CPHA;
        ul_reg_val |= US_MR_CPOL;
        break;
 
    case SPI_MODE_3:
        ul_reg_val |= US_MR_CPOL;
        ul_reg_val &= ~US_MR_CPHA;
        break;
 
    default:
        break;
    }
 
    p_usart->US_MR |= ul_reg_val;
 
    return 0;
}

References usart_spi_opt_t::channel_mode, usart_spi_opt_t::char_length, usart_spi_opt_t::spi_mode, SPI_MODE_0, SPI_MODE_1, SPI_MODE_2, SPI_MODE_3, Usart::US_MR, US_MR_CPHA, US_MR_CPOL, US_MR_USART_MODE_SPI_SLAVE, usart_reset(), and usart_set_spi_slave_baudrate().

usart_init_sync_master()

uint32_t usart_init_sync_master	(	Usart *	p_usart,
		const sam_usart_opt_t *	p_usart_opt,
		uint32_t	ul_mck )

Configure USART to work in SYNC mode and act as a master.

Note

By default, the transmitter and receiver aren't enabled.

Parameters

p_usart	Pointer to a USART instance.
p_usart_opt	Pointer to sam_usart_opt_t instance.
ul_mck	USART module input clock frequency.

Return values

0	on success.
1	on failure.

Definition at line 386 of file usart.c.

{
    static uint32_t ul_reg_val;
 
    /* Reset the USART and shut down TX and RX. */
    usart_reset(p_usart);
 
    ul_reg_val = 0;
    /* Check whether the input values are legal. */
    if (!p_usart_opt || usart_set_sync_master_baudrate(p_usart,
            p_usart_opt->baudrate, ul_mck)) {
        return 1;
    }
 
    /* Configure the USART option. */
    ul_reg_val |= p_usart_opt->char_length | p_usart_opt->parity_type |
            p_usart_opt->channel_mode | p_usart_opt->stop_bits;
 
    /* Set normal mode and output clock as synchronous master. */
    ul_reg_val |= US_MR_USART_MODE_NORMAL | US_MR_CLKO;
    p_usart->US_MR |= ul_reg_val;
 
    return 0;
}

References sam_usart_opt_t::baudrate, sam_usart_opt_t::channel_mode, sam_usart_opt_t::char_length, sam_usart_opt_t::parity_type, sam_usart_opt_t::stop_bits, Usart::US_MR, US_MR_CLKO, US_MR_USART_MODE_NORMAL, usart_reset(), and usart_set_sync_master_baudrate().

usart_init_sync_slave()

uint32_t usart_init_sync_slave	(	Usart *	p_usart,
		const sam_usart_opt_t *	p_usart_opt )

Configure USART to work in SYNC mode and act as a slave.

Note

By default, the transmitter and receiver aren't enabled.

Parameters

p_usart	Pointer to a USART instance.
p_usart_opt	Pointer to sam_usart_opt_t instance.

Return values

0	on success.
1	on failure.

Definition at line 423 of file usart.c.

{
    static uint32_t ul_reg_val;
 
    /* Reset the USART and shut down TX and RX. */
    usart_reset(p_usart);
 
    ul_reg_val = 0;
    usart_set_sync_slave_baudrate(p_usart);
 
    /* Check whether the input values are legal. */
    if (!p_usart_opt) {
        return 1;
    }
 
    /* Configure the USART option. */
    ul_reg_val |= p_usart_opt->char_length | p_usart_opt->parity_type |
            p_usart_opt->channel_mode | p_usart_opt->stop_bits;
 
    /* Set normal mode. */
    ul_reg_val |= US_MR_USART_MODE_NORMAL;
    p_usart->US_MR |= ul_reg_val;
 
    return 0;
}

References sam_usart_opt_t::channel_mode, sam_usart_opt_t::char_length, sam_usart_opt_t::parity_type, sam_usart_opt_t::stop_bits, Usart::US_MR, US_MR_USART_MODE_NORMAL, usart_reset(), and usart_set_sync_slave_baudrate().

usart_is_rx_buf_end()

uint32_t usart_is_rx_buf_end

(

Usart *

p_usart

)

Check if one receive buffer is filled.

Parameters

p_usart

Pointer to a USART instance.

Return values

1	Receive is complete.
0	Receive is still pending.

Definition at line 660 of file usart.c.

{
    return (p_usart->US_CSR & US_CSR_ENDRX) > 0;
}

References Usart::US_CSR, and US_CSR_ENDRX.

usart_is_rx_buf_full()

uint32_t usart_is_rx_buf_full

(

Usart *

p_usart

)

Check if both receive buffers are full.

Parameters

p_usart

Pointer to a USART instance.

Return values

1	Receive buffers are full.
0	Receive buffers are not full.

Definition at line 646 of file usart.c.

{
    return (p_usart->US_CSR & US_CSR_RXBUFF) > 0;
}

References Usart::US_CSR, and US_CSR_RXBUFF.

usart_is_rx_ready()

uint32_t usart_is_rx_ready

(

Usart *

p_usart

)

Check if the received data are ready.

Check if Data have been received and loaded into USART_RHR.

Parameters

p_usart

Pointer to a USART instance.

Return values

1	Some data has been received.
0	No data has been received.

Definition at line 1688 of file usart.c.

{
    return (p_usart->US_CSR & US_CSR_RXRDY) > 0;
}

References Usart::US_CSR, and US_CSR_RXRDY.

Referenced by usart_serial_is_rx_ready().

usart_is_tx_buf_empty()

uint32_t usart_is_tx_buf_empty

(

Usart *

p_usart

)

Check if both transmit buffers are empty.

Parameters

p_usart

Pointer to a USART instance.

Return values

1	Transmit buffers are empty.
0	Transmit buffers are not empty.

Definition at line 686 of file usart.c.

{
    return (p_usart->US_CSR & US_CSR_TXBUFE) > 0;
}

References Usart::US_CSR, and US_CSR_TXBUFE.

usart_is_tx_buf_end()

uint32_t usart_is_tx_buf_end

(

Usart *

p_usart

)

Check if one transmit buffer is empty.

Parameters

p_usart

Pointer to a USART instance.

Return values

1	Transmit is complete.
0	Transmit is still pending.

Definition at line 673 of file usart.c.

{
    return (p_usart->US_CSR & US_CSR_ENDTX) > 0;
}

References Usart::US_CSR, and US_CSR_ENDTX.

usart_is_tx_empty()

uint32_t usart_is_tx_empty

(

Usart *

p_usart

)

Check if Transmit Holding Register is empty.

Check if the last data written in USART_THR have been loaded in TSR and the last data loaded in TSR have been transmitted.

Parameters

p_usart

Pointer to a USART instance.

Return values

1	Transmitter is empty.
0	Transmitter is not empty.

Definition at line 1674 of file usart.c.

{
    return (p_usart->US_CSR & US_CSR_TXEMPTY) > 0;
}

References Usart::US_CSR, and US_CSR_TXEMPTY.

usart_is_tx_ready()

uint32_t usart_is_tx_ready

(

Usart *

p_usart

)

Check if Transmit is Ready.

Check if data have been loaded in USART_THR and are waiting to be loaded into the Transmit Shift Register (TSR).

Parameters

p_usart

Pointer to a USART instance.

Return values

1	No data is in the Transmit Holding Register.
0	There is data in the Transmit Holding Register.

Definition at line 1659 of file usart.c.

{
    return (p_usart->US_CSR & US_CSR_TXRDY) > 0;
}

References Usart::US_CSR, and US_CSR_TXRDY.

usart_man_disable_drift_compensation()

void usart_man_disable_drift_compensation

(

Usart *

p_usart

)

Disable drift compensation.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 2037 of file usart.c.

{
    p_usart->US_MAN &= ~US_MAN_DRIFT;
}

References Usart::US_MAN, and US_MAN_DRIFT.

usart_man_enable_drift_compensation()

void usart_man_enable_drift_compensation

(

Usart *

p_usart

)

Enable drift compensation.

Note

The 16X clock mode must be enabled.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 2027 of file usart.c.

{
    p_usart->US_MAN |= US_MAN_DRIFT;
}

References Usart::US_MAN, and US_MAN_DRIFT.

usart_man_set_rx_polarity()

void usart_man_set_rx_polarity	(	Usart *	p_usart,
		uint8_t	uc_polarity )

Configure the receiver Manchester polarity when the Manchester encode/decode is enabled.

Parameters

p_usart	Pointer to a USART instance.
uc_polarity	Indicate the receiver Manchester polarity, which should be 0 or 1.

Definition at line 2014 of file usart.c.

{
    p_usart->US_MAN = (p_usart->US_MAN & ~US_MAN_RX_MPOL) |
            (uc_polarity << 28);
}

References Usart::US_MAN, and US_MAN_RX_MPOL.

usart_man_set_rx_pre_len()

void usart_man_set_rx_pre_len	(	Usart *	p_usart,
		uint8_t	uc_len )

Configure the detected receiver preamble length when the Manchester encode/decode is enabled.

Parameters

p_usart	Pointer to a USART instance.
uc_len	The detected receiver preamble length, which should be 0 ~ 15.

Definition at line 1984 of file usart.c.

{
    p_usart->US_MAN = (p_usart->US_MAN & ~US_MAN_RX_PL_Msk) |
            US_MAN_RX_PL(uc_len);
}

References Usart::US_MAN, US_MAN_RX_PL, and US_MAN_RX_PL_Msk.

usart_man_set_rx_pre_pattern()

void usart_man_set_rx_pre_pattern	(	Usart *	p_usart,
		uint8_t	uc_pattern )

Configure the detected receiver preamble pattern when the Manchester encode/decode is enabled, which should be 0 ~ 3.

Parameters

p_usart	Pointer to a USART instance.
uc_pattern	0 if the preamble is composed of '1's; 1 if the preamble is composed of '0's; 2 if the preamble is composed of '01's; 3 if the preamble is composed of '10's.

Definition at line 2000 of file usart.c.

{
    p_usart->US_MAN = (p_usart->US_MAN & ~US_MAN_RX_PP_Msk) |
            (uc_pattern << US_MAN_RX_PP_Pos);
}

References Usart::US_MAN, US_MAN_RX_PP_Msk, and US_MAN_RX_PP_Pos.

usart_man_set_tx_polarity()

void usart_man_set_tx_polarity	(	Usart *	p_usart,
		uint8_t	uc_polarity )

Configure the transmitter Manchester polarity when the Manchester encode/decode is enabled.

Parameters

p_usart	Pointer to a USART instance.
uc_polarity	Indicate the transmitter Manchester polarity, which should be 0 or 1.

Definition at line 1971 of file usart.c.

{
    p_usart->US_MAN = (p_usart->US_MAN & ~US_MAN_TX_MPOL) |
            (uc_polarity << 12);
}

References Usart::US_MAN, and US_MAN_TX_MPOL.

usart_man_set_tx_pre_len()

void usart_man_set_tx_pre_len	(	Usart *	p_usart,
		uint8_t	uc_len )

Configure the transmitter preamble length when the Manchester encode/decode is enabled.

Parameters

p_usart	Pointer to a USART instance.
uc_len	The transmitter preamble length, which should be 0 ~ 15.

Definition at line 1941 of file usart.c.

{
    p_usart->US_MAN = (p_usart->US_MAN & ~US_MAN_TX_PL_Msk) |
            US_MAN_TX_PL(uc_len);
}

References Usart::US_MAN, US_MAN_TX_PL, and US_MAN_TX_PL_Msk.

usart_man_set_tx_pre_pattern()

void usart_man_set_tx_pre_pattern	(	Usart *	p_usart,
		uint8_t	uc_pattern )

Configure the transmitter preamble pattern when the Manchester encode/decode is enabled, which should be 0 ~ 3.

Parameters

p_usart	Pointer to a USART instance.
uc_pattern	0 if the preamble is composed of '1's; 1 if the preamble is composed of '0's; 2 if the preamble is composed of '01's; 3 if the preamble is composed of '10's.

Definition at line 1957 of file usart.c.

{
    p_usart->US_MAN = (p_usart->US_MAN & ~US_MAN_TX_PP_Msk) |
            (uc_pattern << US_MAN_TX_PP_Pos);
}

References Usart::US_MAN, US_MAN_TX_PP_Msk, and US_MAN_TX_PP_Pos.

usart_putchar()

uint32_t usart_putchar	(	Usart *	p_usart,
		uint32_t	c )

Write to USART Transmit Holding Register.

Note

Before writing user should check if tx is ready (or empty).

Parameters

p_usart	Pointer to a USART instance.
c	Data to be sent.

Return values

0	on success.
1	on failure.

Definition at line 1725 of file usart.c.

{
    while (!(p_usart->US_CSR & US_CSR_TXRDY)) {
    }
 
    p_usart->US_THR = US_THR_TXCHR(c);
 
    return 0;
}

References Usart::US_CSR, US_CSR_TXRDY, Usart::US_THR, and US_THR_TXCHR.

Referenced by usart_write_line().

usart_read()

uint32_t usart_read	(	Usart *	p_usart,
		uint32_t *	c )

Read from USART Receive Holding Register.

Note

Before reading user should check if rx is ready.

Parameters

p_usart	Pointer to a USART instance.
c	Pointer where the one-byte received data will be stored.

Return values

0	on success.
1	if no data is available or errors.

Definition at line 1759 of file usart.c.

{
    if (!(p_usart->US_CSR & US_CSR_RXRDY)) {
        return 1;
    }
 
    /* Read character */
    *c = p_usart->US_RHR & US_RHR_RXCHR_Msk;
 
    return 0;
}

References Usart::US_CSR, US_CSR_RXRDY, Usart::US_RHR, and US_RHR_RXCHR_Msk.

Referenced by usart_serial_getchar().

usart_reset()

void usart_reset

(

Usart *

p_usart

)

Reset the USART and disable TX and RX.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 240 of file usart.c.

{
    /* Disable the Write Protect. */
    usart_disable_writeprotect(p_usart);
 
    /* Reset registers that could cause unpredictable behavior after reset. */
    p_usart->US_MR = 0;
    p_usart->US_RTOR = 0;
    p_usart->US_TTGR = 0;
 
    /* Disable TX and RX. */
    usart_reset_tx(p_usart);
    usart_reset_rx(p_usart);
    /* Reset status bits. */
    usart_reset_status(p_usart);
    /* Turn off RTS and DTR if exist. */
    usart_drive_RTS_pin_high(p_usart);
#if (SAM3S || SAM4S || SAM3U || SAM4L || SAM4E)
    usart_drive_DTR_pin_high(p_usart);
#endif
}

References Usart::US_MR, Usart::US_RTOR, Usart::US_TTGR, usart_disable_writeprotect(), usart_drive_DTR_pin_high(), usart_drive_RTS_pin_high(), usart_reset_rx(), usart_reset_status(), and usart_reset_tx().

Referenced by usart_init_iso7816(), usart_init_rs232(), usart_init_spi_master(), usart_init_spi_slave(), usart_init_sync_master(), and usart_init_sync_slave().

usart_reset_iterations()

void usart_reset_iterations

(

Usart *

p_usart

)

Reset the ITERATION in US_CSR when the ISO7816 mode is enabled.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 623 of file usart.c.

{
    p_usart->US_CR = US_CR_RSTIT;
}

References Usart::US_CR, and US_CR_RSTIT.

usart_reset_nack()

void usart_reset_nack

(

Usart *

p_usart

)

Reset NACK in US_CSR.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 633 of file usart.c.

{
    p_usart->US_CR = US_CR_RSTNACK;
}

References Usart::US_CR, and US_CR_RSTNACK.

usart_reset_rx()

void usart_reset_rx

(

Usart *

p_usart

)

Immediately stop and disable USART receiver.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1446 of file usart.c.

{
    /* Reset Receiver */
    p_usart->US_CR = US_CR_RSTRX | US_CR_RXDIS;
}

References Usart::US_CR, US_CR_RSTRX, and US_CR_RXDIS.

Referenced by usart_reset().

usart_reset_status()

void usart_reset_status

(

Usart *

p_usart

)

Reset status bits (PARE, OVER, MANERR, UNRE and PXBRK in US_CSR).

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1514 of file usart.c.

{
    p_usart->US_CR = US_CR_RSTSTA;
}

References Usart::US_CR, and US_CR_RSTSTA.

Referenced by usart_reset().

usart_reset_tx()

void usart_reset_tx

(

Usart *

p_usart

)

Immediately stop and disable USART transmitter.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1404 of file usart.c.

{
    /* Reset transmitter */
    p_usart->US_CR = US_CR_RSTTX | US_CR_TXDIS;
}

References Usart::US_CR, US_CR_RSTTX, and US_CR_TXDIS.

Referenced by usart_reset().

usart_restart_rx_timeout()

void usart_restart_rx_timeout

(

Usart *

p_usart

)

Restart the receive timeout.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1580 of file usart.c.

{
    p_usart->US_CR = US_CR_RETTO;
}

References Usart::US_CR, and US_CR_RETTO.

usart_send_address()

uint32_t usart_send_address	(	Usart *	p_usart,
		uint32_t	ul_addr )

In Multidrop mode only, the next character written to the US_THR is sent with the address bit set.

Parameters

p_usart	Pointer to a USART instance.
ul_addr	The address to be sent out.

Return values

0	on success.
1	on failure.

Definition at line 1560 of file usart.c.

{
    if ((p_usart->US_MR & US_MR_PAR_MULTIDROP) != US_MR_PAR_MULTIDROP) {
        return 1;
    }
 
    p_usart->US_CR = US_CR_SENDA;
 
    if (usart_write(p_usart, ul_addr)) {
        return 1;
    } else {
        return 0;
    }
}

References Usart::US_CR, US_CR_SENDA, Usart::US_MR, US_MR_PAR_MULTIDROP, and usart_write().

usart_set_async_baudrate()

uint32_t usart_set_async_baudrate	(	Usart *	p_usart,
		uint32_t	baudrate,
		uint32_t	ul_mck )

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

Note

Baud rate calculation: Baudrate = ul_mck/(Over * (CD + FP/8)) (Over being 16 or 8). The maximal oversampling is selected if it allows to generate a baudrate close to the set point.

Parameters

p_usart	Pointer to a USART instance.
baudrate	Baud rate set point.
ul_mck	USART module input clock frequency.

Return values

0	Baud rate is successfully initialized.
1	Baud rate set point is out of range for the given input clock frequency.

Definition at line 111 of file usart.c.

{
    uint32_t over;
    uint32_t cd_fp;
    uint32_t cd;
    uint32_t fp;
 
    /* Calculate the receiver sampling divide of baudrate clock. */
    if (ul_mck >= HIGH_FRQ_SAMPLE_DIV * baudrate) {
        over = HIGH_FRQ_SAMPLE_DIV;
    } else {
        over = LOW_FRQ_SAMPLE_DIV;
    }
 
    /* Calculate clock divider according to the fraction calculated formula. */
    cd_fp = (8 * ul_mck + (over * baudrate) / 2) / (over * baudrate);
    cd = cd_fp >> 3;
    fp = cd_fp & 0x07;
    if (cd < MIN_CD_VALUE || cd > MAX_CD_VALUE) {
        return 1;
    }
 
    /* Configure the OVER bit in MR register. */
    if (over == 8) {
        p_usart->US_MR |= US_MR_OVER;
    }
 
    /* Configure the baudrate generate register. */
    p_usart->US_BRGR = (cd << US_BRGR_CD_Pos) | (fp << US_BRGR_FP_Pos);
 
    return 0;
}

References HIGH_FRQ_SAMPLE_DIV, LOW_FRQ_SAMPLE_DIV, MAX_CD_VALUE, Usart::US_BRGR, US_BRGR_CD_Pos, US_BRGR_FP_Pos, Usart::US_MR, and US_MR_OVER.

Referenced by usart_init_rs232().

usart_set_rx_timeout()

void usart_set_rx_timeout	(	Usart *	p_usart,
		uint32_t	timeout )

Configure the receive timeout register.

Parameters

p_usart	Pointer to a USART instance.
timeout	The value of receive timeout.

Definition at line 1458 of file usart.c.

{
    p_usart->US_RTOR = timeout;
}

References Usart::US_RTOR.

usart_set_tx_timeguard()

void usart_set_tx_timeguard	(	Usart *	p_usart,
		uint32_t	timeguard )

Configure the transmit timeguard register.

Parameters

p_usart	Pointer to a USART instance.
timeguard	The value of transmit timeguard.

Definition at line 1416 of file usart.c.

{
    p_usart->US_TTGR = timeguard;
}

References Usart::US_TTGR.

usart_spi_force_chip_select()

void usart_spi_force_chip_select

(

Usart *

p_usart

)

Drive the slave select line NSS (RTS pin) to 0 in SPI master mode.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1634 of file usart.c.

{
    p_usart->US_CR = US_CR_FCS;
}

References Usart::US_CR, and US_CR_FCS.

usart_spi_release_chip_select()

void usart_spi_release_chip_select

(

Usart *

p_usart

)

Drive the slave select line NSS (RTS pin) to 1 in SPI master mode.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1644 of file usart.c.

{
    p_usart->US_CR = US_CR_RCS;
}

References Usart::US_CR, and US_CR_RCS.

usart_start_rx_timeout()

void usart_start_rx_timeout

(

Usart *

p_usart

)

Start waiting for a character before clocking the timeout count.

Reset the status bit TIMEOUT in US_CSR.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1545 of file usart.c.

{
    p_usart->US_CR = US_CR_STTTO;
}

References Usart::US_CR, and US_CR_STTTO.

usart_start_tx_break()

void usart_start_tx_break

(

Usart *

p_usart

)

Start transmission of a break.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1524 of file usart.c.

{
    p_usart->US_CR = US_CR_STTBRK;
}

References Usart::US_CR, and US_CR_STTBRK.

usart_stop_tx_break()

void usart_stop_tx_break

(

Usart *

p_usart

)

Stop transmission of a break.

Parameters

p_usart

Pointer to a USART instance.

Definition at line 1534 of file usart.c.

{
    p_usart->US_CR = US_CR_STPBRK;
}

References Usart::US_CR, and US_CR_STPBRK.

usart_write()

uint32_t usart_write	(	Usart *	p_usart,
		uint32_t	c )

Write to USART Transmit Holding Register.

Note

Before writing user should check if tx is ready (or empty).

Parameters

p_usart	Pointer to a USART instance.
c	Data to be sent.

Return values

0	on success.
1	on failure.

Definition at line 1704 of file usart.c.

{
    if (!(p_usart->US_CSR & US_CSR_TXRDY)) {
        return 1;
    }
 
    p_usart->US_THR = US_THR_TXCHR(c);
    return 0;
}

References Usart::US_CSR, US_CSR_TXRDY, Usart::US_THR, and US_THR_TXCHR.

Referenced by usart_send_address(), and usart_serial_putchar().

usart_write_line()

void usart_write_line	(	Usart *	p_usart,
		const char *	string )

Write one-line string through USART.

Parameters

p_usart	Pointer to a USART instance.
string	Pointer to one-line string to be sent.

Definition at line 1741 of file usart.c.

{
    while (*string != '\0') {
        usart_putchar(p_usart, *string++);
    }
}

References usart_putchar().