Quick Start Guide for SERCOM USART - Callback

This quick start will echo back characters typed into the terminal, using asynchronous TX and RX callbacks from the USART peripheral.

In this use case the USART will be configured with the following settings:

• Asynchronous mode
• 9600 Baudrate
• 8-bits, No Parity and one Stop Bit
• TX and RX enabled and connected to the Xplained Pro Embedded Debugger virtual COM port

Setup

Prerequisites

There are no special setup requirements for this use-case.

Code

Add to the main application source file, outside of any functions:

struct usart_module usart_instance;

#define MAX_RX_BUFFER_LENGTH   5

volatile uint8_t rx_buffer[MAX_RX_BUFFER_LENGTH];

Copy-paste the following callback function code to your user application:

void usart_read_callback(struct usart_module *const usart_module)
{
    usart_write_buffer_job(&usart_instance,
            (uint8_t *)rx_buffer, MAX_RX_BUFFER_LENGTH);
}

void usart_write_callback(struct usart_module *const usart_module)
{
    port_pin_toggle_output_level(LED_0_PIN);
}

Copy-paste the following setup code to your user application:

void configure_usart(void)
{
    struct usart_config config_usart;
    usart_get_config_defaults(&config_usart);

#if(SAMR30E)
{
    config_usart.baudrate    = 9600;
    config_usart.mux_setting = CDC_SERCOM_MUX_SETTING;
    config_usart.pinmux_pad0 = CDC_SERCOM_PINMUX_PAD0;
    config_usart.pinmux_pad1 = CDC_SERCOM_PINMUX_PAD1;
    config_usart.pinmux_pad2 = CDC_SERCOM_PINMUX_PAD2;
    config_usart.pinmux_pad3 = CDC_SERCOM_PINMUX_PAD3;

    while (usart_init(&usart_instance,
    CDC_MODULE, &config_usart) != STATUS_OK) {
    }
}
#else
{
    config_usart.baudrate    = 9600;
    config_usart.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;
    config_usart.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;
    config_usart.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;
    config_usart.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;
    config_usart.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;

    while (usart_init(&usart_instance,
    EDBG_CDC_MODULE, &config_usart) != STATUS_OK) {
    }
}
#endif

    usart_enable(&usart_instance);
}

void configure_usart_callbacks(void)
{
    usart_register_callback(&usart_instance,
            usart_write_callback, USART_CALLBACK_BUFFER_TRANSMITTED);
    usart_register_callback(&usart_instance,
            usart_read_callback, USART_CALLBACK_BUFFER_RECEIVED);

    usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_TRANSMITTED);
    usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_RECEIVED);
}

Add to user application initialization (typically the start of main()):

    configure_usart();
    configure_usart_callbacks();

Workflow

1. Create a module software instance structure for the USART module to store the USART driver state while it is in use.

   struct usart_module usart_instance;

   Note

   This should never go out of scope as long as the module is in use. In most cases, this should be global.

2. Configure the USART module.
   1. Create a USART module configuration struct, which can be filled out to adjust the configuration of a physical USART peripheral.

          struct usart_config config_usart;

   2. Initialize the USART configuration struct with the module's default values.

          usart_get_config_defaults(&config_usart);

      Note

      This should always be performed before using the configuration struct to ensure that all values are initialized to known default settings.

   3. Alter the USART settings to configure the physical pinout, baudrate, and other relevant parameters.

      
          while (usart_init(&usart_instance,
          CDC_MODULE, &config_usart) != STATUS_OK) {
          }
      }
      #else
      {
          config_usart.baudrate    = 9600;
          config_usart.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;
          config_usart.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;
          config_usart.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;
          config_usart.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;
          config_usart.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;

   4. Configure the USART module with the desired settings, retrying while the driver is busy until the configuration is stressfully set.

          while (usart_init(&usart_instance,
          CDC_MODULE, &config_usart) != STATUS_OK) {
          }

   5. Enable the USART module.

          usart_enable(&usart_instance);

3. Configure the USART callbacks.
   1. Register the TX and RX callback functions with the driver.

          usart_register_callback(&usart_instance,
                  usart_write_callback, USART_CALLBACK_BUFFER_TRANSMITTED);
          usart_register_callback(&usart_instance,
                  usart_read_callback, USART_CALLBACK_BUFFER_RECEIVED);

   2. Enable the TX and RX callbacks so that they will be called by the driver when appropriate.

          usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_TRANSMITTED);
          usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_RECEIVED);

Use Case

Code

Copy-paste the following code to your user application:

    system_interrupt_enable_global();

    uint8_t string[] = "Hello World!\r\n";
    usart_write_buffer_wait(&usart_instance, string, sizeof(string));

    while (true) {
        usart_read_buffer_job(&usart_instance,
                (uint8_t *)rx_buffer, MAX_RX_BUFFER_LENGTH);
    }

Workflow

1. Enable global interrupts, so that the callbacks can be fired.

       system_interrupt_enable_global();

2. Send a string to the USART to show the demo is running, blocking until all characters have been sent.

       uint8_t string[] = "Hello World!\r\n";
       usart_write_buffer_wait(&usart_instance, string, sizeof(string));

3. Enter an infinite loop to continuously echo received values on the USART.

       while (true) {

4. Perform an asynchronous read of the USART, which will fire the registered callback when characters are received.

           usart_read_buffer_job(&usart_instance,
                   (uint8_t *)rx_buffer, MAX_RX_BUFFER_LENGTH);