/**
 * \file
 *
 * \brief Universal Synchronous Asynchronous Receiver Transmitter (USART) driver for SAM.
 *
 * Copyright (c) 2011-2012 Atmel Corporation. All rights reserved.
 *
 * \asf_license_start
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * 3. The name of Atmel may not be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * 4. This software may only be redistributed and used in connection with an
 *    Atmel microcontroller product.
 *
 * THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
 * EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * \asf_license_stop
 *
 */

#ifndef USART_H_INCLUDED
#define USART_H_INCLUDED

#include "compiler.h"

/**
 * \defgroup usart_group Universal Synchronous Asynchronous Receiver Transmitter (USART)
 *
 * See \ref sam_usart_quickstart.
 *
 * This is a low-level driver implementation for the SAM Universal
 * Synchronous/Asynchronous Receiver/Transmitter.
 *
 * @{
 */

/// @cond 0
/**INDENT-OFF**/
#ifdef __cplusplus
extern "C" {
#endif
/**INDENT-ON**/
/// @endcond

/** Clock phase. */
#define SPI_CPHA	(1 << 0)

/** Clock polarity. */
#define SPI_CPOL	(1 << 1)

/** SPI mode definition. */
#define SPI_MODE_0	(SPI_CPHA)
#define SPI_MODE_1	0
#define SPI_MODE_2	(SPI_CPOL | SPI_CPHA)
#define SPI_MODE_3	(SPI_CPOL)

//! Input parameters when initializing RS232 and similar modes.
typedef struct {
	//! Set baud rate of the USART (unused in slave modes).
	uint32_t baudrate;
	
	//! Number of bits, which should be one of the following: US_MR_CHRL_5_BIT,
	//! US_MR_CHRL_6_BIT, US_MR_CHRL_7_BIT, US_MR_CHRL_8_BIT or US_MR_MODE9.
	uint32_t char_length;
	
	//! Parity type, which should be one of the following: US_MR_PAR_EVEN, US_MR_PAR_ODD,
	//! US_MR_PAR_SPACE, US_MR_PAR_MARK, US_MR_PAR_NO or US_MR_PAR_MULTIDROP.
	uint32_t parity_type;

	//! Number of stop bits between two characters: US_MR_NBSTOP_1_BIT,
	//! US_MR_NBSTOP_1_5_BIT, US_MR_NBSTOP_2_BIT.
	//! \note US_MR_NBSTOP_1_5_BIT is supported in asynchronous modes only.
	uint32_t stop_bits;

	//! Run the channel in test mode, which should be one of following: US_MR_CHMODE_NORMAL,
	//! US_MR_CHMODE_AUTOMATIC, US_MR_CHMODE_LOCAL_LOOPBACK, US_MR_CHMODE_REMOTE_LOOPBACK
	uint32_t channel_mode;

	//! Filter of IrDA mode, useless in other modes. 
	uint32_t irda_filter;
} sam_usart_opt_t;

//! Input parameters when initializing ISO7816 mode.
typedef struct {
	//! Set the frequency of the ISO7816 clock.
	uint32_t iso7816_hz;
	
	//! The number of ISO7816 clock ticks in every bit period (1 to 2047, 0 = disable clock).
	//! Baudrate rate = iso7816_hz / fidi_ratio
	uint32_t fidi_ratio;

	//! How to calculate the parity bit: US_MR_PAR_EVEN for normal mode or
	//! US_MR_PAR_ODD for inverse mode.
	uint32_t parity_type;

	//! Inhibit Non Acknowledge:
	//!   - 0: the NACK is generated;
	//!   - 1: the NACK is not generated.
	//!
	//! \note This bit will be used only in ISO7816 mode, protocol T = 0 receiver.
	uint32_t inhibit_nack;

	//! Disable successive NACKs.
	//!  - 0: NACK is sent on the ISO line as soon as a parity error occurs in the received character.
	//! Successive parity errors are counted up to the value in the max_iterations field.
	//! These parity errors generate a NACK on the ISO line. As soon as this value is reached,
	//! No additional NACK is sent on the ISO line. The ITERATION flag is asserted.
	uint32_t dis_suc_nack;

	//! Max number of repetitions (0 to 7).
	uint32_t max_iterations;

	//! Bit order in transmitted characters:
	//!   - 0: LSB first;
	//!   - 1: MSB first.
	uint32_t bit_order;
	
	//! Which protocol is used:
	//!   - 0: T = 0;
	//!   - 1: T = 1.
	uint32_t protocol_type;
} usart_iso7816_opt_t;

//! Input parameters when initializing SPI mode.
typedef struct {
	//! Set the frequency of the SPI clock (unused in slave mode).
	uint32_t baudrate;

	//! Number of bits, which should be one of the following: US_MR_CHRL_5_BIT,
	//! US_MR_CHRL_6_BIT, US_MR_CHRL_7_BIT, US_MR_CHRL_8_BIT or US_MR_MODE9.
	uint32_t char_length;

	//! Which SPI mode to use, which should be one of the following:
	//! SPI_MODE_0, SPI_MODE_1, SPI_MODE_2, SPI_MODE_3.
	uint32_t spi_mode;

	//! Run the channel in test mode, which should be one of following: US_MR_CHMODE_NORMAL,
	//! US_MR_CHMODE_AUTOMATIC, US_MR_CHMODE_LOCAL_LOOPBACK, US_MR_CHMODE_REMOTE_LOOPBACK
	uint32_t channel_mode;
} usart_spi_opt_t;

void usart_reset(Usart *p_usart);
uint32_t usart_init_rs232(Usart *p_usart, const sam_usart_opt_t *p_usart_opt, uint32_t ul_mck);
uint32_t usart_init_hw_handshaking(Usart *p_usart, const sam_usart_opt_t *p_usart_opt, uint32_t ul_mck);
#if (SAM3S || SAM4S || SAM3U)
uint32_t usart_init_modem(Usart *p_usart, const sam_usart_opt_t *p_usart_opt, uint32_t ul_mck);
#endif
uint32_t usart_init_sync_master(Usart *p_usart, const sam_usart_opt_t *p_usart_opt, uint32_t ul_mck);
uint32_t usart_init_sync_slave(Usart *p_usart, const sam_usart_opt_t *p_usart_opt);
uint32_t usart_init_rs485(Usart *p_usart, const sam_usart_opt_t *p_usart_opt, uint32_t ul_mck);
uint32_t usart_init_irda(Usart *p_usart, const sam_usart_opt_t *p_usart_opt, uint32_t ul_mck);
uint32_t usart_init_iso7816(Usart *p_usart, const usart_iso7816_opt_t *p_usart_opt, uint32_t ul_mck);
uint32_t usart_init_spi_master(Usart *p_usart, const usart_spi_opt_t *p_usart_opt, uint32_t ul_mck);
uint32_t usart_init_spi_slave(Usart *p_usart, const usart_spi_opt_t *p_usart_opt);
#if SAM3XA
uint32_t usart_init_lin_master(Usart *p_usart, const sam_usart_opt_t *p_usart_opt, uint32_t ul_mck);
uint32_t usart_init_lin_slave(Usart *p_usart, const sam_usart_opt_t *p_usart_opt, uint32_t ul_mck);
void usart_lin_abort_tx(Usart *p_usart);
void usart_lin_send_wakeup_signal(Usart *p_usart);
void usart_lin_set_node_action(Usart *p_usart, uint8_t uc_action);
void usart_lin_disable_parity(Usart *p_usart);
void usart_lin_enable_parity(Usart *p_usart);
void usart_lin_disable_checksum(Usart *p_usart);
void usart_lin_enable_checksum(Usart *p_usart);
void usart_lin_set_checksum_type(Usart *p_usart, uint8_t uc_type);
void usart_lin_set_data_len_mode(Usart *p_usart, uint8_t uc_mode);
void usart_lin_disable_frame_slot(Usart *p_usart);
void usart_lin_enable_frame_slot(Usart *p_usart);
void usart_lin_set_wakeup_signal_type(Usart *p_usart, uint8_t uc_type);
void usart_lin_set_response_data_len(Usart *p_usart, uint8_t uc_len);
void usart_lin_disable_pdc_mode(Usart *p_usart);
void usart_lin_enable_pdc_mode(Usart *p_usart);
void usart_lin_set_tx_identifier(Usart *p_usart, uint8_t uc_id);
uint8_t usart_lin_read_identifier(Usart *p_usart);
#endif
void usart_enable_tx(Usart *p_usart);
void usart_disable_tx(Usart *p_usart);
void usart_reset_tx(Usart *p_usart);
void usart_set_tx_timeguard(Usart *p_usart, uint32_t timeguard);
void usart_enable_rx(Usart *p_usart);
void usart_disable_rx(Usart *p_usart);
void usart_reset_rx(Usart *p_usart);
void usart_set_rx_timeout(Usart *p_usart, uint32_t timeout);
void usart_enable_interrupt(Usart *p_usart,uint32_t ul_sources);
void usart_disable_interrupt(Usart *p_usart,uint32_t ul_sources);
uint32_t usart_get_interrupt_mask(Usart *p_usart);
uint32_t usart_get_status(Usart *p_usart);
void usart_reset_status(Usart *p_usart);
void usart_start_tx_break(Usart *p_usart);
void usart_stop_tx_break(Usart *p_usart);
void usart_start_rx_timeout(Usart *p_usart);
uint32_t usart_send_address(Usart *p_usart, uint32_t ul_addr);
void usart_reset_iterations(Usart *p_usart);
void usart_reset_nack(Usart *p_usart);
void usart_restart_rx_timeout(Usart *p_usart);
#if (SAM3S || SAM4S || SAM3U)
void usart_drive_DTR_pin_low(Usart *p_usart);
void usart_drive_DTR_pin_high(Usart *p_usart);
#endif
void usart_drive_RTS_pin_low(Usart *p_usart);
void usart_drive_RTS_pin_high(Usart *p_usart);
void usart_spi_force_chip_select(Usart *p_usart);
void usart_spi_release_chip_select(Usart *p_usart);
uint32_t usart_is_tx_ready(Usart *p_usart);
uint32_t usart_is_tx_empty(Usart *p_usart);
uint32_t usart_is_rx_ready(Usart *p_usart);
uint32_t usart_is_rx_buf_end(Usart *p_usart);
uint32_t usart_is_tx_buf_end(Usart *p_usart);
uint32_t usart_is_rx_buf_full(Usart *p_usart);
uint32_t usart_is_tx_buf_empty(Usart *p_usart);
uint32_t usart_write(Usart *p_usart, uint32_t c);
uint32_t usart_putchar(Usart *p_usart, uint32_t c);
void usart_write_line(Usart *p_usart, const char *string);
uint32_t usart_read(Usart *p_usart, uint32_t *c);
uint32_t usart_getchar(Usart *p_usart, uint32_t *c);
#if (SAM3XA || SAM3U)
uint32_t * usart_get_tx_access(Usart *p_usart);
uint32_t * usart_get_rx_access(Usart *p_usart);
#endif
Pdc *usart_get_pdc_base(Usart *p_usart);
void usart_enable_writeprotect(Usart *p_usart);
void usart_disable_writeprotect(Usart *p_usart);
uint32_t usart_get_writeprotect_status(Usart *p_usart);
uint8_t usart_get_error_number(Usart *p_usart);
#if (SAM3S || SAM4S || SAM3U || SAM3XA)
void usart_man_set_tx_pre_len(Usart *p_usart, uint8_t uc_len);
void usart_man_set_tx_pre_pattern(Usart *p_usart, uint8_t uc_pattern);
void usart_man_set_tx_polarity(Usart *p_usart, uint8_t uc_polarity);
void usart_man_set_rx_pre_len(Usart *p_usart, uint8_t uc_len);
void usart_man_set_rx_pre_pattern(Usart *p_usart, uint8_t uc_pattern);
void usart_man_set_rx_polarity(Usart *p_usart, uint8_t uc_polarity);
void usart_man_enable_drift_compensation(Usart *p_usart);
void usart_man_disable_drift_compensation(Usart *p_usart);
#endif

/// @cond 0
/**INDENT-OFF**/
#ifdef __cplusplus
}
#endif
/**INDENT-ON**/
/// @endcond

//! @}

/**
 * \page sam_usart_quickstart Quick start guide for the SAM USART module
 *
 * This is the quick start guide for the \ref usart_group "USART module", with
 * step-by-step instructions on how to configure and use the driver in a
 * selection of use cases.
 *
 * The use cases contain several code fragments. The code fragments in the
 * steps for setup can be copied into a custom initialization function, while
 * the steps for usage can be copied into, e.g., the main application function.
 *
 * \note Some SAM devices contain both USART and UART modules, with the latter
 *       being a subset in functionality of the former but physically seperate
 *       peripherals. UART modules are compatible with the USART driver, but
 *       only for the functions and modes suported by the base UART driver.
 *
 * \section usart_basic_use_case Basic use case
 * \section usart_use_cases USART use cases
 * - \ref usart_basic_use_case
 * - \subpage usart_use_case_1
 * - \subpage usart_use_case_2
 *
 * \section usart_basic_use_case Basic use case - transmit a character
 * In this use case, the USART module is configured for:
 * - Using USART0
 * - Baudrate: 9600
 * - Character length: 8 bit
 * - Parity mode: Disabled
 * - Stop bit: None
 * - RS232 mode
 *
 * \section usart_basic_use_case_setup Setup steps
 *
 * \subsection usart_basic_use_case_setup_prereq Prerequisites
 * -# \ref sysclk_group "System Clock Management (sysclock)"
 * -# \ref pio_group "Parallel Input/Output Controller (pio)"
 * -# \ref pmc_group "Power Management Controller (pmc)"
 *
 * \subsection usart_basic_use_case_setup_code Example code
 * The following configuration must be added to the project (typically to a 
 * conf_usart.h file, but it can also be added to your main application file.)
 * \code
 *    #define USART_SERIAL                 USART0
 *    #define USART_SERIAL_ID              ID_USART0
 *    #define USART_SERIAL_PIO             PINS_USART_PIO
 *    #define USART_SERIAL_TYPE            PINS_USART_TYPE
 *    #define USART_SERIAL_PINS            PINS_USART_PINS
 *    #define USART_SERIAL_MASK            PINS_USART_MASK
 *    #define USART_SERIAL_BAUDRATE        9600
 *    #define USART_SERIAL_CHAR_LENGTH     US_MR_CHRL_8_BIT
 *    #define USART_SERIAL_PARITY          US_MR_PAR_NO
 *    #define USART_SERIAL_STOP_BIT        US_MR_NBSTOP_1_BIT
 * \endcode
 *
 * Add to application initialization:
 * \code
 *    sysclk_init();
 *
 *    pio_configure(USART_SERIAL_PIO, USART_SERIAL_TYPE,
 *                  USART_SERIAL_MASK, USART_SERIAL_ATTR);
 *    
 *    const sam_usart_opt_t usart_console_settings = {
 *        USART_SERIAL_BAUDRATE,
 *        USART_SERIAL_CHAR_LENGTH,
 *        USART_SERIAL_PARITY,
 *        USART_SERIAL_STOP_BIT,
 *        US_MR_CHMODE_NORMAL
 *    };
 *    
 *    pmc_enable_periph_clk(USART_SERIAL_ID);
 *   
 *    usart_init_rs232(USART_SERIAL, &usart_console_settings, sysclk_get_main_hz());
 *    usart_enable_tx(USART_SERIAL);
 *    usart_enable_rx(USART_SERIAL);
 * \endcode
 *
 * \subsection usart_basic_use_case_setup_flow Workflow
 * -# Initialize system clock:
 *   \code
 *   sysclk_init();
 *   \endcode
 * -# Configure the USART Tx and Rx pins as Outputs and Inputs respectively:
 *   \code
 *   pio_configure(PINS_UART_PIO, PINS_UART_TYPE, PINS_UART_MASK,
 *                 PINS_UART_ATTR);
 *   \endcode
 * -# Create USART options struct:
 *   \code
 *   const sam_usart_opt_t usart_console_settings = {
 *        USART_SERIAL_BAUDRATE,
 *        USART_SERIAL_CHAR_LENGTH,
 *        USART_SERIAL_PARITY,
 *        USART_SERIAL_STOP_BIT,
 *        US_MR_CHMODE_NORMAL
 *   };
 *   \endcode
 * -# Enable the clock to the USART module:
 *   \code
 *   pmc_enable_periph_clk(USART_SERIAL_ID);
 *   \endcode
 * -# Initialize the USART module in RS232 mode:
 *   \code
 *   usart_init_rs232(USART_SERIAL, &usart_console_settings, sysclk_get_main_hz());
 *   \endcode
 * -# Enable the Rx and Tx modes of the USART module:
 *   \code
 *   usart_enable_tx(USART_SERIAL);
 *   usart_enable_rx(USART_SERIAL);
 *   \endcode
 *
 * \section usart_basic_use_case_usage Usage steps
 *
 * \subsection usart_basic_use_case_usage_code Example code
 * Add to application C-file:
 * \code
 * usart_putchar(USART_SERIAL, 'a');
 * \endcode
 *
 * \subsection usart_basic_use_case_usage_flow Workflow
 * -# Send an 'a' character via USART
 *   \code usart_putchar(USART_SERIAL, 'a'); \endcode
 */

/**
 * \page usart_use_case_1 USART receive character and echo back
 *
 * In this use case, the USART module is configured for:
 * - Using USART0
 * - Baudrate: 9600
 * - Character length: 8 bit
 * - Parity mode: Disabled
 * - Stop bit: None
 * - RS232 mode
 *
 * The use case waits for a received character on the configured USART and
 * echoes the character back to the same USART.
 *
 * \section usart_use_case_1_setup Setup steps
 *
 * \subsection usart_use_case_1_setup_prereq Prerequisites
 * -# \ref sysclk_group "System Clock Management (sysclock)"
 * -# \ref pio_group "Parallel Input/Output Controller (pio)"
 * -# \ref pmc_group "Power Management Controller (pmc)"
 *
 * \subsection usart_use_case_1_setup_code Example code
 * The following configuration must be added to the project (typically to a 
 * conf_usart.h file, but it can also be added to your main application file.):
 * \code
 *    #define USART_SERIAL                 USART0
 *    #define USART_SERIAL_ID              ID_USART0
 *    #define USART_SERIAL_PIO             PINS_USART_PIO
 *    #define USART_SERIAL_TYPE            PINS_USART_TYPE
 *    #define USART_SERIAL_PINS            PINS_USART_PINS
 *    #define USART_SERIAL_MASK            PINS_USART_MASK
 *    #define USART_SERIAL_BAUDRATE        9600
 *    #define USART_SERIAL_CHAR_LENGTH     US_MR_CHRL_8_BIT
 *    #define USART_SERIAL_PARITY          US_MR_PAR_NO
 *    #define USART_SERIAL_STOP_BIT        US_MR_NBSTOP_1_BIT
 * \endcode
 *
 * A variable for the received byte must be added:
 * \code
 *    uint32_t received_byte;
 * \endcode
 *
 * Add to application initialization:
 * \code
 *    sysclk_init();
 *
 *    pio_configure(USART_SERIAL_PIO, USART_SERIAL_TYPE,
 *                  USART_SERIAL_MASK, USART_SERIAL_ATTR);
 *    
 *    const sam_usart_opt_t usart_console_settings = {
 *        USART_SERIAL_BAUDRATE,
 *        USART_SERIAL_CHAR_LENGTH,
 *        USART_SERIAL_PARITY,
 *        USART_SERIAL_STOP_BIT,
 *        US_MR_CHMODE_NORMAL
 *    };
 *    
 *    pmc_enable_periph_clk(USART_SERIAL_ID);
 *   
 *    usart_init_rs232(USART_SERIAL, &usart_console_settings, sysclk_get_main_hz());
 *    usart_enable_tx(USART_SERIAL);
 *    usart_enable_rx(USART_SERIAL);
 * \endcode
 *
 * \subsection usart_use_case_1_setup_flow Workflow
 * -# Initialize system clock:
 *   \code
 *   sysclk_init();
 *   \endcode
 * -# Configure the USART Tx and Rx pins as Outputs and Inputs respectively:
 *   \code
 *    pio_configure(USART_SERIAL_PIO, USART_SERIAL_TYPE,
 *                  USART_SERIAL_MASK, USART_SERIAL_ATTR);
 *   \endcode
 * -# Create USART options struct:
 *   \code
 *   const sam_usart_opt_t usart_console_settings = {
 *        USART_SERIAL_BAUDRATE,
 *        USART_SERIAL_CHAR_LENGTH,
 *        USART_SERIAL_PARITY,
 *        USART_SERIAL_STOP_BIT,
 *        US_MR_CHMODE_NORMAL
 *   };
 *   \endcode
 * -# Enable the clock to the USART module:
 *   \code pmc_enable_periph_clk(USART_SERIAL_ID); \endcode
 * -# Initialize the USART module in RS232 mode:
 *   \code usart_init_rs232(USART_SERIAL, &usart_console_settings, sysclk_get_main_hz()); \endcode
 * -# Enable the Rx and Tx modes of the USART module:
 *   \code
 *   usart_enable_tx(USART_SERIAL);
 *   usart_enable_rx(USART_SERIAL);
 *   \endcode
 *
 * \section usart_use_case_1_usage Usage steps
 *
 * \subsection usart_use_case_1_usage_code Example code
 * Add to, e.g., main loop in application C-file:
 * \code
 * received_byte = usart_getchar(USART_SERIAL);
 * usart_putchar(USART_SERIAL, received_byte);
 * \endcode
 *
 * \subsection usart_use_case_1_usage_flow Workflow
 * -# Wait for reception of a character:
 *   \code usart_getchar(USART_SERIAL, &received_byte); \endcode
 * -# Echo the character back:
 *   \code usart_putchar(USART_SERIAL, received_byte); \endcode
 */

/**
 * \page usart_use_case_2 USART receive character and echo back via interrupts
 *
 * In this use case, the USART module is configured for:
 * - Using USART0
 * - Baudrate: 9600
 * - Character length: 8 bit
 * - Parity mode: Disabled
 * - Stop bit: None
 * - RS232 mode
 *
 * The use case waits for a received character on the configured USART and
 * echoes the character back to the same USART. The character reception is
 * performed via an interrupt handler, rather than the polling method used
 * in \ref usart_use_case_1.
 *
 * \section usart_use_case_2_setup Setup steps
 *
 * \subsection usart_use_case_2_setup_prereq Prerequisites
 * -# \ref sysclk_group "System Clock Management (sysclock)"
 * -# \ref pio_group "Parallel Input/Output Controller (pio)"
 * -# \ref pmc_group "Power Management Controller (pmc)"
 *
 * \subsection usart_use_case_2_setup_code Example code
 * The following configuration must be added to the project (typically to a 
 * conf_usart.h file, but it can also be added to your main application file.):
 * \code
 *    #define USART_SERIAL                 USART0
 *    #define USART_SERIAL_ID              ID_USART0
 *    #define USART_SERIAL_ISR_HANDLER     USART0_Handler
 *    #define USART_SERIAL_PIO             PINS_USART_PIO
 *    #define USART_SERIAL_TYPE            PINS_USART_TYPE
 *    #define USART_SERIAL_PINS            PINS_USART_PINS
 *    #define USART_SERIAL_MASK            PINS_USART_MASK
 *    #define USART_SERIAL_BAUDRATE        9600
 *    #define USART_SERIAL_CHAR_LENGTH     US_MR_CHRL_8_BIT
 *    #define USART_SERIAL_PARITY          US_MR_PAR_NO
 *    #define USART_SERIAL_STOP_BIT        US_MR_NBSTOP_1_BIT
 * \endcode
 *
 * A variable for the received byte must be added:
 * \code
 *    uint32_t received_byte;
 * \endcode
 *
 * Add to application initialization:
 * \code
 *    sysclk_init();
 *
 *    pio_configure(USART_SERIAL_PIO, USART_SERIAL_TYPE,
 *                  USART_SERIAL_MASK, USART_SERIAL_ATTR);
 *    
 *    const sam_usart_opt_t usart_console_settings = {
 *        USART_SERIAL_BAUDRATE,
 *        USART_SERIAL_CHAR_LENGTH,
 *        USART_SERIAL_PARITY,
 *        USART_SERIAL_STOP_BIT,
 *        US_MR_CHMODE_NORMAL
 *    };
 *    
 *    pmc_enable_periph_clk(USART_SERIAL_ID);
 *   
 *    usart_init_rs232(USART_SERIAL, &usart_console_settings, sysclk_get_main_hz());
 *    usart_enable_tx(USART_SERIAL);
 *    usart_enable_rx(USART_SERIAL);
 * 
 *    usart_enable_interrupt(USART_SERIAL, US_IER_RXRDY);
 *    NVIC_EnableIRQ(USART_SERIAL_IRQ);
 * \endcode
 *
 * \subsection usart_use_case_2_setup_flow Workflow
 * -# Initialize system clock:
 *   \code
 *   sysclk_init();
 *   \endcode
 * -# Configure the USART Tx and Rx pins as Outputs and Inputs respectively:
 *   \code
 *    pio_configure(USART_SERIAL_PIO, USART_SERIAL_TYPE,
 *                  USART_SERIAL_MASK, USART_SERIAL_ATTR);
 *   \endcode
 * -# Create USART options struct:
 *   \code
 *   const sam_usart_opt_t usart_console_settings = {
 *        USART_SERIAL_BAUDRATE,
 *        USART_SERIAL_CHAR_LENGTH,
 *        USART_SERIAL_PARITY,
 *        USART_SERIAL_STOP_BIT,
 *        US_MR_CHMODE_NORMAL
 *   };
 *   \endcode
 * -# Enable the clock to the USART module:
 *   \code pmc_enable_periph_clk(USART_SERIAL_ID); \endcode
 * -# Initialize the USART module in RS232 mode:
 *   \code usart_init_rs232(USART_SERIAL, &usart_console_settings, sysclk_get_main_hz()); \endcode
 * -# Enable the Rx and Tx modes of the USART module:
 *   \code
 *   usart_enable_tx(USART_SERIAL);
 *   usart_enable_rx(USART_SERIAL);
 *   \endcode
 * -# Enable the USART character reception interrupt, and general interrupts for the USART module.
 *   \code
 *   usart_enable_interrupt(USART_SERIAL, US_IER_RXRDY);
 *   NVIC_EnableIRQ(USART_SERIAL_IRQ);
 *   \endcode
 * \section usart_use_case_2_usage Usage steps
 *
 * \subsection usart_use_case_2_usage_code Example code
 * Add to your main application C-file the USART interrupt handler:
 * \code
 * void USART_SERIAL_ISR_HANDLER(void)
 * {
 *    uint32_t dw_status = usart_get_status(USART_SERIAL);
 * 
 *    if (dw_status & US_CSR_RXRDY) {
 *        uint32_t received_byte;
 * 
 *        usart_read(USART_SERIAL, &received_byte);
 *        usart_write(USART_SERIAL, received_byte);
 *    }
 * }
 * \endcode
 *
 * \subsection usart_use_case_2_usage_flow Workflow
 * -# When the USART ISR fires, retrieve the USART module interrupt flags:
 *   \code uint32_t dw_status = usart_get_status(USART_SERIAL); \endcode
 * -# Check if the USART Receive Character interrupt has fired:
 *   \code if (dw_status & US_CSR_RXRDY) \endcode
 * -# If a character has been received, fetch it into a temporary variable:
 *   \code usart_read(USART_SERIAL, &received_byte); \endcode
 * -# Echo the character back:
 *   \code usart_write(USART_SERIAL, received_byte); \endcode
 */

#endif /* USART_H_INCLUDED */
