/**
* \brief Configure UART console.
*/
static void configure_console(void)
{
#if SAMD21
struct usart_config usart_conf;
usart_get_config_defaults(&usart_conf);
usart_conf.mux_setting = CONF_STDIO_MUX_SETTING;
usart_conf.pinmux_pad0 = CONF_STDIO_PINMUX_PAD0;
usart_conf.pinmux_pad1 = CONF_STDIO_PINMUX_PAD1;
usart_conf.pinmux_pad2 = CONF_STDIO_PINMUX_PAD2;
usart_conf.pinmux_pad3 = CONF_STDIO_PINMUX_PAD3;
usart_conf.baudrate = CONF_STDIO_BAUDRATE;
stdio_serial_init(&cdc_uart_module, CONF_STDIO_USART_MODULE, &usart_conf);
usart_enable(&cdc_uart_module);
#elif SAME70
const usart_serial_options_t uart_serial_options = {
.baudrate = CONF_UART_BAUDRATE,
#ifdef CONF_UART_CHAR_LENGTH
.charlength = CONF_UART_CHAR_LENGTH,
#endif
.paritytype = CONF_UART_PARITY,
#ifdef CONF_UART_STOP_BITS
.stopbits = CONF_UART_STOP_BITS,
#endif
};
/* Configure console UART. */
sysclk_enable_peripheral_clock(CONSOLE_UART_ID);
stdio_serial_init(CONF_UART, &uart_serial_options);
#endif
}
//! [setup]
void configure_usart(void)
{
//! [setup_config]
struct usart_config config_usart;
//! [setup_config]
//! [setup_config_defaults]
usart_get_config_defaults(&config_usart);
//! [setup_config_defaults]
//! [setup_change_config]
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;
//! [setup_change_config]
//! [setup_set_config]
while (usart_init(&usart_instance,
EDBG_CDC_MODULE, &config_usart) != STATUS_OK) {
}
//! [setup_set_config]
//! [setup_enable]
usart_enable(&usart_instance);
//! [setup_enable]
}
/* === IMPLEMENTATION ====================================================== */
static inline void usart_configure_flowcontrol(void)
{
struct usart_config config_usart;
#if UART_FLOWCONTROL_6WIRE_MODE == true
usart_disable(&usart_instance);
usart_reset(&usart_instance);
#endif
usart_get_config_defaults(&config_usart);
config_usart.baudrate = CONF_FLCR_BLE_BAUDRATE;
config_usart.generator_source = CONF_FLCR_BLE_UART_CLOCK;
config_usart.mux_setting = CONF_FLCR_BLE_MUX_SETTING;
config_usart.pinmux_pad0 = CONF_FLCR_BLE_PINMUX_PAD0;
config_usart.pinmux_pad1 = CONF_FLCR_BLE_PINMUX_PAD1;
config_usart.pinmux_pad2 = CONF_FLCR_BLE_PINMUX_PAD2;
config_usart.pinmux_pad3 = CONF_FLCR_BLE_PINMUX_PAD3;
while (usart_init(&usart_instance, CONF_FLCR_BLE_USART_MODULE, &config_usart) != STATUS_OK);
usart_enable(&usart_instance);
/* register and enable usart callbacks */
usart_register_callback(&usart_instance,
serial_drv_read_cb, USART_CALLBACK_BUFFER_RECEIVED);
usart_register_callback(&usart_instance,
serial_drv_write_cb, USART_CALLBACK_BUFFER_TRANSMITTED);
usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_TRANSMITTED);
serial_read_byte(&rx_data);
}
//Sets USART to the EDBG virtual COM port of SAMD21 Xpro
void configure_usart(void){
struct usart_config config_usart;
usart_get_config_defaults(&config_usart);
config_usart.baudrate = 9600; //Need to find the SERCOM/pins connected to EDBG on the SAMW25
/*
config_usart.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING; //USART_RX_1_TX_0_XCK_1
config_usart.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0; //PINMUX_PA22C_SERCOM3_PAD0
config_usart.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1; //PINMUX_PA23C_SERCOM3_PAD1
config_usart.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2; //PINMUX_UNUSED
config_usart.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3; //PINMUX_UNUSED
while (usart_init(&usart_instance,
EDBG_CDC_MODULE, &config_usart) != STATUS_OK) {}
*/
config_usart.mux_setting = USART_RX_1_TX_0_XCK_1; //USART_RX_1_TX_2_XCK_3
config_usart.pinmux_pad0 = PINMUX_PA12C_SERCOM2_PAD0;
config_usart.pinmux_pad1 = PINMUX_PA13C_SERCOM2_PAD1;
config_usart.pinmux_pad2 = PINMUX_UNUSED;
config_usart.pinmux_pad3 = PINMUX_UNUSED;
while(usart_init(&usart_instance,SERCOM2, &config_usart) != STATUS_OK) {}
usart_enable(&usart_instance);
}
/**
* \brief configure and enable SERCOM - USART
*/
void configure_usart(void)
{
/* USART set up configuration */
struct usart_config config_usart;
/* USART base address */
SercomUsart *const usart_hw = SERCOM2;
/* Get USART default configuration */
usart_get_config_defaults(&config_usart);
/* Configure USART baud rate and pad */
config_usart.baudrate = 460800;
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;
/* Initialize USART */
while (usart_init(&usart_instance,
EDBG_CDC_MODULE, &config_usart) != STATUS_OK) {
}
/* Enable USART */
usart_enable(&usart_instance);
/* Enable USART transfer complete interrupt */
usart_hw->INTENSET.reg = SERCOM_USART_INTFLAG_TXC;
}
otError otPlatUartEnable(void)
{
struct usart_config configUsart;
usart_get_config_defaults(&configUsart);
configUsart.baudrate = 115200;
configUsart.mux_setting = UART_SERCOM_MUX_SETTING;
configUsart.pinmux_pad0 = UART_SERCOM_PINMUX_PAD0;
configUsart.pinmux_pad1 = UART_SERCOM_PINMUX_PAD1;
configUsart.pinmux_pad2 = UART_SERCOM_PINMUX_PAD2;
configUsart.pinmux_pad3 = UART_SERCOM_PINMUX_PAD3;
while (usart_init(&sUsartInstance, UART_SERCOM_MODULE, &configUsart) != STATUS_OK)
;
usart_enable(&sUsartInstance);
sReceive.mHead = 0;
sReceive.mTail = 0;
usart_register_callback(&sUsartInstance, usartWriteCallback, USART_CALLBACK_BUFFER_TRANSMITTED);
usart_register_callback(&sUsartInstance, usartReadCallback, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&sUsartInstance, USART_CALLBACK_BUFFER_TRANSMITTED);
usart_enable_callback(&sUsartInstance, USART_CALLBACK_BUFFER_RECEIVED);
usart_read_job(&sUsartInstance, (uint16_t *)&sReceive.mBuffer[sReceive.mTail]);
return OT_ERROR_NONE;
}
/*---------------------------------------------------------------------------*/
static int
open(int32_t baudrate, uart_rx_char_callback char_cb, uart_rx_frame_callback frame_cb)
{
struct usart_config config_usart;
struct port_config pin_conf;
usart_get_config_defaults(&config_usart);
config_usart.baudrate = baudrate;
config_usart.mux_setting = RS485_SERCOM_MUX_SETTING;
config_usart.pinmux_pad0 = RS485_SERCOM_PINMUX_PAD0;
config_usart.pinmux_pad1 = RS485_SERCOM_PINMUX_PAD1;
config_usart.pinmux_pad2 = RS485_SERCOM_PINMUX_PAD2;
config_usart.pinmux_pad3 = RS485_SERCOM_PINMUX_PAD3;
while (usart_init(&usart_instance, RS485_MODULE, &config_usart) != STATUS_OK) {}
usart_enable(&usart_instance);
port_get_config_defaults(&pin_conf);
pin_conf.direction = PORT_PIN_DIR_OUTPUT;
port_pin_set_config(RS485_TXE, &pin_conf);
port_pin_set_output_level(RS485_TXE, false);
char_callback = char_cb;
usart_register_callback(&usart_instance,
usart_read_callback, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_RECEIVED);
usart_read_job(&usart_instance, &rx_char);
return 1;
}
uint8_t configure_serial_drv(void)
{
#if UART_FLOWCONTROL_4WIRE_MODE == true
usart_configure_flowcontrol();
#warning "This mode works only if Flow Control Permanently Enabled in the BTLC1000"
#else
struct usart_config config_usart;
usart_get_config_defaults(&config_usart);
config_usart.baudrate = CONF_BLE_BAUDRATE;
config_usart.generator_source = CONF_BLE_UART_CLOCK;
config_usart.mux_setting = CONF_BLE_MUX_SETTING;
config_usart.pinmux_pad0 = CONF_BLE_PINMUX_PAD0;
config_usart.pinmux_pad1 = CONF_BLE_PINMUX_PAD1;
config_usart.pinmux_pad2 = CONF_BLE_PINMUX_PAD2;
config_usart.pinmux_pad3 = CONF_BLE_PINMUX_PAD3;
while (usart_init(&usart_instance, CONF_BLE_USART_MODULE, &config_usart) != STATUS_OK);
usart_enable(&usart_instance);
/* register and enable usart callbacks */
usart_register_callback(&usart_instance,
serial_drv_read_cb, USART_CALLBACK_BUFFER_RECEIVED);
usart_register_callback(&usart_instance,
serial_drv_write_cb, USART_CALLBACK_BUFFER_TRANSMITTED);
usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_TRANSMITTED);
serial_read_byte(&rx_data);
#endif
return STATUS_OK;
}
void configure_console(void)
{
struct usart_config usart_conf;
usart_get_config_defaults(&usart_conf);
usart_conf.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;
usart_conf.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;
usart_conf.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;
usart_conf.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;
usart_conf.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;
usart_conf.baudrate = 115200;
stdio_serial_init(&cdc_uart_module, EDBG_CDC_MODULE, &usart_conf);
usart_enable(&cdc_uart_module);
}
/**
* \brief Configure serial console.
*/
static void configure_console(void)
{
struct usart_config config_usart;
usart_get_config_defaults(&config_usart);
config_usart.baudrate = 115200;
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;
stdio_serial_init(&usart_instance, EDBG_CDC_MODULE, &config_usart);
usart_enable(&usart_instance);
}
// Configure SERCOM channel 1 as USART for BLE module
void configure_usart(void)
{
struct usart_config config_usart;
usart_get_config_defaults(&config_usart);
config_usart.baudrate = 9600;
config_usart.mux_setting = USART_RX_3_TX_2_XCK_3;
config_usart.pinmux_pad0 = PINMUX_UNUSED;
config_usart.pinmux_pad1 = PINMUX_UNUSED;
config_usart.pinmux_pad2 = PINMUX_PA18C_SERCOM1_PAD2;
config_usart.pinmux_pad3 = PINMUX_PA19C_SERCOM1_PAD3;
while (usart_init(&usart_instance,SERCOM1, &config_usart) != STATUS_OK)
{}
usart_enable(&usart_instance);
}
/**
* Configure UART console.
*/
static void configure_console(void)
{
struct usart_config usart_conf;
usart_get_config_defaults(&usart_conf);
usart_conf.mux_setting = CONF_STDIO_MUX_SETTING;
usart_conf.pinmux_pad0 = CONF_STDIO_PINMUX_PAD0;
usart_conf.pinmux_pad1 = CONF_STDIO_PINMUX_PAD1;
usart_conf.pinmux_pad2 = CONF_STDIO_PINMUX_PAD2;
usart_conf.pinmux_pad3 = CONF_STDIO_PINMUX_PAD3;
usart_conf.baudrate = CONF_STDIO_BAUDRATE;
stdio_serial_init(&cdc_uart_module, CONF_STDIO_USART_MODULE, &usart_conf);
}
static void configure_console(void)
{
struct usart_config usart_conf;
usart_get_config_defaults(&usart_conf);
usart_conf.mux_setting = HOST_SERCOM_MUX_SETTING;
usart_conf.pinmux_pad0 = HOST_SERCOM_PINMUX_PAD0;
usart_conf.pinmux_pad1 = HOST_SERCOM_PINMUX_PAD1;
usart_conf.pinmux_pad2 = HOST_SERCOM_PINMUX_PAD2;
usart_conf.pinmux_pad3 = HOST_SERCOM_PINMUX_PAD3;
usart_conf.baudrate = USART_HOST_BAUDRATE;
stdio_serial_init(&cdc_uart_module, USART_HOST, &usart_conf);
usart_enable(&cdc_uart_module);
}
/** Set up the USART (EDBG) communication for debug purpose. */
static void setup_usart_channel(void)
{
struct usart_config config_usart;
usart_get_config_defaults(&config_usart);
/* Configure the USART settings and initialize the standard I/O library */
config_usart.baudrate = 115200;
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;
stdio_serial_init(&usart_instance, EDBG_CDC_MODULE, &config_usart);
usart_enable(&usart_instance);
}
static void serial_port_init(void)
{
struct usart_config usart_conf;
/* Configure USART for unit test output */
usart_get_config_defaults(&usart_conf);
usart_conf.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;
usart_conf.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;
usart_conf.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;
usart_conf.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;
usart_conf.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;
usart_conf.baudrate = DEFAULT_BAUD_RATE;
stdio_serial_init(&usart_instance, EDBG_CDC_MODULE, &usart_conf);
usart_enable(&usart_instance);
}
/**
* \brief Initialize the USART for unit test
*
* Initializes the SERCOM USART used for sending the unit test status to the
* computer via the EDBG CDC gateway.
*/
static void cdc_uart_init(void)
{
struct usart_config usart_conf;
/* Configure USART for unit test output */
usart_get_config_defaults(&usart_conf);
usart_conf.mux_setting = CONF_STDIO_MUX_SETTING;
usart_conf.pinmux_pad0 = CONF_STDIO_PINMUX_PAD0;
usart_conf.pinmux_pad1 = CONF_STDIO_PINMUX_PAD1;
usart_conf.pinmux_pad2 = CONF_STDIO_PINMUX_PAD2;
usart_conf.pinmux_pad3 = CONF_STDIO_PINMUX_PAD3;
usart_conf.baudrate = CONF_STDIO_BAUDRATE;
stdio_serial_init(&cdc_uart_module, CONF_STDIO_USART, &usart_conf);
usart_enable(&cdc_uart_module);
}
/**
* \brief Configure UART console.
*/
static void configure_console(void)
{
struct usart_config usart_conf;
usart_get_config_defaults(&usart_conf);
usart_conf.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;
usart_conf.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;
usart_conf.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;
usart_conf.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;
usart_conf.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;
usart_conf.baudrate = 115200;
stdio_serial_init(&cdc_uart_module, EDBG_CDC_MODULE, &usart_conf);
/* Register USART callback for receiving user input. */
usart_register_callback(&cdc_uart_module, (usart_callback_t)uart_callback, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable(&cdc_uart_module);
}
struct usart_module * cph_stdio_init(void) {
struct usart_config config_usart;
usart_get_config_defaults(&config_usart);
config_usart.baudrate = STDIO_BAUD;
config_usart.mux_setting = STDIO_MUX;
config_usart.pinmux_pad0 = STDIO_PAD0;
config_usart.pinmux_pad1 = STDIO_PAD1;
config_usart.pinmux_pad2 = STDIO_PAD2;
config_usart.pinmux_pad3 = STDIO_PAD3;
stdio_serial_init(&usart_instance, STDIO_HW, &config_usart);
usart_enable(&usart_instance);
return &usart_instance;
}
/*!
* \brief Initialize USART to communicate with on board EDBG - SERCOM
* with the following settings.
* - 8-bit asynchronous USART
* - No parity
* - One stop bit
* - 115200 baud
*/
static void configure_usart(void)
{
struct usart_config config_usart;
// Get the default USART configuration
usart_get_config_defaults(&config_usart);
// Configure the baudrate
config_usart.baudrate = 115200;
// Configure the pin multiplexing for USART
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;
// route the printf output to the USART
stdio_serial_init(&usart_instance, EDBG_CDC_MODULE, &config_usart);
// enable USART
usart_enable(&usart_instance);
}
void usart_configureBluetooth( void )
{
struct usart_config bluetooth_config;
usart_get_config_defaults(&bluetooth_config);
bluetooth_config.baudrate = BAUDRATE_BLUETOOTH;
bluetooth_config.mux_setting = BT_USART_SERCOM_MUX_SETTING;
bluetooth_config.pinmux_pad0 = BT_USART_SERCOM_PINMUX_PAD0;
bluetooth_config.pinmux_pad1 = BT_USART_SERCOM_PINMUX_PAD1;
bluetooth_config.pinmux_pad2 = BT_USART_SERCOM_PINMUX_PAD2;
bluetooth_config.pinmux_pad3 = BT_USART_SERCOM_PINMUX_PAD3;
while ( usart_init(&usart_instanceBluetooth,
BT_USART_MODULE, &bluetooth_config) != STATUS_OK );
usart_enable(&usart_instanceBluetooth);
}
static void configure_usart(const struct UsartConfig * config)
{
struct usart_config config_usart;
usart_get_config_defaults(&config_usart);
config_usart.baudrate = config->baudrate;
config_usart.mux_setting = config->mux_setting;
config_usart.pinmux_pad0 = config->pinmux_pad0;
config_usart.pinmux_pad1 = config->pinmux_pad1;
config_usart.pinmux_pad2 = config->pinmux_pad2;
config_usart.pinmux_pad3 = config->pinmux_pad3;
while (usart_init(&usart_debug, config->module, &config_usart) != STATUS_OK) {
}
stdio_serial_init(&usart_debug, config->module, &config_usart);
usart_enable(&usart_debug);
}
void usart_configureFTDI( void )
{
struct usart_config FTDI_config;
usart_get_config_defaults(&FTDI_config);
FTDI_config.baudrate = BAUDRATE_FTDI;
FTDI_config.mux_setting = FTDI_USART_SERCOM_MUX_SETTING;
FTDI_config.pinmux_pad0 = FTDI_USART_SERCOM_PINMUX_PAD0;
FTDI_config.pinmux_pad1 = FTDI_USART_SERCOM_PINMUX_PAD1;
FTDI_config.pinmux_pad2 = FTDI_USART_SERCOM_PINMUX_PAD2;
FTDI_config.pinmux_pad3 = FTDI_USART_SERCOM_PINMUX_PAD3;
while ( usart_init(&usart_instanceFTDI,
FTDI_USART_MODULE, &FTDI_config) != STATUS_OK );
usart_enable(&usart_instanceFTDI);
}
void sio2host_init(void)
{
#if SAMD20
struct usart_config cdc_uart_config;
/* Configure USART for unit test output */
usart_get_config_defaults(&cdc_uart_config);
cdc_uart_config.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;
cdc_uart_config.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;
cdc_uart_config.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;
cdc_uart_config.baudrate = USART_HOST_BAUDRATE;
stdio_serial_init(&cdc_uart_module, USART_HOST,&cdc_uart_config);
usart_enable(&cdc_uart_module);
/* Enable transceivers */
usart_enable_transceiver(&cdc_uart_module, USART_TRANSCEIVER_TX);
usart_enable_transceiver(&cdc_uart_module, USART_TRANSCEIVER_RX);
#else
stdio_serial_init(USART_HOST, &usart_serial_options);
#endif
USART_HOST_RX_ISR_ENABLE();
}
void configure_console(void)
{
struct usart_config conf_usart;
usart_get_config_defaults(&conf_usart);
conf_usart.generator_source = GCLK_GENERATOR_1;
conf_usart.baudrate = 9600;
conf_usart.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;
conf_usart.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;
conf_usart.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;
conf_usart.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;
conf_usart.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;
stdio_serial_init(&console_instance, EDBG_CDC_MODULE, &conf_usart);
usart_enable(&console_instance);
}
/*---------------------------------------------------------------------------*/
static void _hal_usartInit( void )
{
/* USART configured as follow:
- BaudRate = 34800 baud
- Word Length = 8 Bits
- ONE Stop Bit
- NO parity
- Hardware flow control disabled (RTS and CTS signals)
- Receive and transmit enabled
*/
//! [setup_config]
struct usart_config config_usart;
//! [setup_config]
//! [setup_config_defaults]
usart_get_config_defaults( &config_usart );
//! [setup_config_defaults]
//! [setup_change_config]
config_usart.baudrate = SAMD21_USART0_BAUDRATE;
config_usart.mux_setting = SAMD21_USART0_SERCOM_MUX_SETTING;
config_usart.pinmux_pad0 = SAMD21_USART0_SERCOM_PMUX0;
config_usart.pinmux_pad1 = SAMD21_USART0_SERCOM_PMUX1;
config_usart.pinmux_pad2 = SAMD21_USART0_SERCOM_PMUX2;
config_usart.pinmux_pad3 = SAMD21_USART0_SERCOM_PMUX3;
//! [setup_change_config]
//! [setup_set_config]
while( usart_init( &st_usartInst, SAMD21_USART0_SERCOM, &config_usart )
!= STATUS_OK )
{
}
//! [setup_set_config]
//! [setup_enable]
usart_enable( &st_usartInst );
//! [setup_enable]
// Initialize Serial Interface using Stdio Library
stdio_serial_init( &st_usartInst, SAMD21_USART0_SERCOM, &config_usart );
//stdout = &st_usartStdout;
} /* _hal_usartInit() */
static void prvConfigureUART( struct usart_module *pxCDCUsart )
{
struct usart_config xUARTConfig;
/* This semaphore is used to allow the task to wait for the Tx to complete
without wasting any CPU time. */
vSemaphoreCreateBinary( xTxCompleteSemaphore );
configASSERT( xTxCompleteSemaphore );
/* This semaphore is used to allow the task to block for an Rx to complete
without wasting any CPU time. */
vSemaphoreCreateBinary( xRxCompleteSemaphore );
configASSERT( xRxCompleteSemaphore );
/* Take the semaphores so they start in the wanted state. A block time is
not necessary, and is therefore set to 0, as it is known that the semaphores
exists - they have just been created. */
xSemaphoreTake( xTxCompleteSemaphore, 0 );
xSemaphoreTake( xRxCompleteSemaphore, 0 );
/* Configure the hardware. */
usart_get_config_defaults( &xUARTConfig );
xUARTConfig.baudrate = 115200;
xUARTConfig.mux_setting = EDBG_CDC_SERCOM_MUX_SETTING;
xUARTConfig.pinmux_pad0 = EDBG_CDC_SERCOM_PINMUX_PAD0;
xUARTConfig.pinmux_pad1 = EDBG_CDC_SERCOM_PINMUX_PAD1;
xUARTConfig.pinmux_pad2 = EDBG_CDC_SERCOM_PINMUX_PAD2;
xUARTConfig.pinmux_pad3 = EDBG_CDC_SERCOM_PINMUX_PAD3;
while( usart_init( pxCDCUsart, EDBG_CDC_MODULE, &xUARTConfig ) != STATUS_OK )
{
/* Nothing to do here. Should include a timeout really but this is
init code only. */
}
usart_enable( pxCDCUsart );
/* Register the driver callbacks. */
usart_register_callback( pxCDCUsart, prvUARTTxNotificationHandler, USART_CALLBACK_BUFFER_TRANSMITTED );
usart_register_callback( pxCDCUsart, prvUARTRxNotificationHandler, USART_CALLBACK_BUFFER_RECEIVED );
usart_enable_callback( pxCDCUsart, USART_CALLBACK_BUFFER_TRANSMITTED );
usart_enable_callback( pxCDCUsart, USART_CALLBACK_BUFFER_RECEIVED );
}
bool COZIR_WV_100_init(void){
struct usart_config usart_conf;
usart_get_config_defaults(&usart_conf);
usart_conf.mux_setting = USART_RX_3_TX_2_XCK_3;
usart_conf.pinmux_pad0 = PINMUX_UNUSED;
usart_conf.pinmux_pad1 = PINMUX_UNUSED;
usart_conf.pinmux_pad2 = PINMUX_PA18C_SERCOM1_PAD2;
usart_conf.pinmux_pad3 = PINMUX_PA19C_SERCOM1_PAD3;
usart_conf.baudrate = 9600;
while (usart_init(&COZIR_WV_100_uart, SERCOM1, &usart_conf) != STATUS_OK ) {
//add a timeout if blocked here
}
usart_register_callback(&COZIR_WV_100_uart, COZIR_WV_100_buffer_received , USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&COZIR_WV_100_uart, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable(&COZIR_WV_100_uart);
usart_read_job(&COZIR_WV_100_uart , &get_char_buffer);
//usart_write_buffer_wait(&COZIR_WV_100_uart ,"*\r\n" , 3);
return true;
}
bool PHPROBE_init(void){
struct usart_config usart_conf;
usart_get_config_defaults(&usart_conf);
usart_conf.mux_setting = USART_RX_3_TX_2_XCK_3;
usart_conf.pinmux_pad0 = PINMUX_UNUSED;
usart_conf.pinmux_pad1 = PINMUX_UNUSED;
usart_conf.pinmux_pad2 = PINMUX_PA10C_SERCOM0_PAD2;
usart_conf.pinmux_pad3 = PINMUX_PA11C_SERCOM0_PAD3;
usart_conf.baudrate = 9600;
while (usart_init(&PHPROBE_uart, SERCOM0, &usart_conf) != STATUS_OK ) {
//add a timeout if blocked here
}
usart_register_callback(&PHPROBE_uart, PHPROBE_buffer_received , USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&PHPROBE_uart, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable(&PHPROBE_uart);
usart_read_job(&PHPROBE_uart , &get_char_buffer);
return true;
}
/**
* \brief Run usb device msc unit tests
*
* Initializes the clock system, board and serial output, then sets up the
* usb unit test suite and runs it.
*/
int main(void)
{
#if !SAM0
const usart_serial_options_t usart_serial_options = {
.baudrate = CONF_TEST_BAUDRATE,
.charlength = CONF_TEST_CHARLENGTH,
.paritytype = CONF_TEST_PARITY,
.stopbits = CONF_TEST_STOPBITS,
};
#else
struct usart_config usart_conf;
#endif
irq_initialize_vectors();
cpu_irq_enable();
#if !SAM0
sysclk_init();
board_init();
#else
system_init();
#endif
// Initialize the sleep manager
sleepmgr_init();
#if !SAM0
stdio_serial_init(CONF_TEST_USART, &usart_serial_options);
#else
/* Configure USART for unit test output */
usart_get_config_defaults(&usart_conf);
usart_conf.mux_setting = CONF_STDIO_MUX_SETTING;
usart_conf.pinmux_pad0 = CONF_STDIO_PINMUX_PAD0;
usart_conf.pinmux_pad1 = CONF_STDIO_PINMUX_PAD1;
usart_conf.pinmux_pad2 = CONF_STDIO_PINMUX_PAD2;
usart_conf.pinmux_pad3 = CONF_STDIO_PINMUX_PAD3;
usart_conf.baudrate = CONF_STDIO_BAUDRATE;
usart_conf.generator_source = GCLK_GENERATOR_3;
stdio_serial_init(&cdc_uart_module, CONF_STDIO_USART, &usart_conf);
usart_enable(&cdc_uart_module);
#endif
// Define all the timestamp to date test cases
DEFINE_TEST_CASE(usb_msc_test, NULL,
run_usb_msc_test, NULL,
"USB Device msc enumeration test");
DEFINE_TEST_CASE(usb_msc_read_test, NULL,
run_usb_msc_read_test, NULL,
"USB MSC read access test");
DEFINE_TEST_CASE(usb_vbus_test, NULL,
run_usb_vbus_test, NULL,
"USB vbus event test");
DEFINE_TEST_CASE(usb_resume_test, NULL,
run_usb_resume_test, NULL,
"USB resume event test");
DEFINE_TEST_CASE(usb_suspend_test, NULL,
run_usb_suspend_test, NULL,
"USB suspend event test");
DEFINE_TEST_CASE(usb_sof_test, NULL,
run_usb_sof_test, NULL,
"USB sof event test");
// Put test case addresses in an array
DEFINE_TEST_ARRAY(usb_msc_tests) = {
&usb_msc_test,
&usb_msc_read_test,
&usb_vbus_test,
&usb_resume_test,
&usb_suspend_test,
&usb_sof_test,
};
// Define the test suite
DEFINE_TEST_SUITE(usb_msc_suite, usb_msc_tests,
"Common usb MSC service with test suite");
// The unit test prints message via UART which does not support deep sleep mode.
#if SAM
sleepmgr_lock_mode(SLEEPMGR_ACTIVE);
#else
sleepmgr_lock_mode(SLEEPMGR_IDLE);
#endif
// Run all tests in the suite
test_suite_run(&usb_msc_suite);
while (1) {
// Intentionally left empty.
}
}
/**
* \internal
* \brief Test capture and compare
*
* This test uses TC module 0 as a PWM generator (compare function).
* TC module 1 will be set to capture the signal from TC module 0 to test the capture
* functionality.
*
* \param test Current test case.
*/
static void run_16bit_capture_and_compare_test(const struct test_case *test)
{
test_assert_true(test,
tc_init_success == true,
"TC initialization failed, skipping test");
test_assert_true(test,
callback_function_entered == 1,
"The callback test has failed, skipping test");
/* Configure 16-bit TC module for PWM generation */
tc_reset(&tc_test0_module);
tc_get_config_defaults(&tc_test0_config);
tc_test0_config.wave_generation = TC_WAVE_GENERATION_MATCH_PWM;
tc_test0_config.counter_16_bit.compare_capture_channel[TC_COMPARE_CAPTURE_CHANNEL_0] = 0x03FF;
tc_test0_config.counter_16_bit.compare_capture_channel[TC_COMPARE_CAPTURE_CHANNEL_1] = 0x01FF;
/* Calculate the theoretical PWM frequency & duty */
uint32_t frequency_output, duty_output;
frequency_output = system_clock_source_get_hz(SYSTEM_CLOCK_SOURCE_OSC8M)/ (0x03FF+1);
/* This value is depend on the WaveGeneration Mode */
duty_output = (uint32_t)(tc_test0_config.counter_16_bit.compare_capture_channel[TC_COMPARE_CAPTURE_CHANNEL_1]) * 100 \
/ tc_test0_config.counter_16_bit.compare_capture_channel[TC_COMPARE_CAPTURE_CHANNEL_0];
tc_test0_config.pwm_channel[TC_COMPARE_CAPTURE_CHANNEL_1].enabled = true;
tc_test0_config.pwm_channel[TC_COMPARE_CAPTURE_CHANNEL_1].pin_out = CONF_TEST_PIN_OUT;
tc_test0_config.pwm_channel[TC_COMPARE_CAPTURE_CHANNEL_1].pin_mux = CONF_TEST_PIN_MUX;
tc_init(&tc_test0_module, CONF_TEST_TC0, &tc_test0_config);
tc_register_callback(&tc_test0_module, tc_callback_function, TC_CALLBACK_CC_CHANNEL0);
tc_enable_callback(&tc_test0_module, TC_CALLBACK_CC_CHANNEL0);
/* Configure 16-bit TC module for capture */
tc_reset(&tc_test1_module);
tc_get_config_defaults(&tc_test1_config);
tc_test1_config.clock_prescaler = TC_CLOCK_PRESCALER_DIV1;
tc_test1_config.enable_capture_on_channel[CONF_CAPTURE_CHAN_0] = true;
tc_test1_config.enable_capture_on_channel[CONF_CAPTURE_CHAN_1] = true;
tc_init(&tc_test1_module, CONF_TEST_TC1, &tc_test1_config);
struct tc_events tc_events = { .on_event_perform_action = true,
.event_action = TC_EVENT_ACTION_PPW,};
tc_enable_events(&tc_test1_module, &tc_events);
/* Configure external interrupt controller */
struct extint_chan_conf extint_chan_config;
extint_chan_config.gpio_pin = CONF_EIC_PIN;
extint_chan_config.gpio_pin_mux = CONF_EIC_MUX;
extint_chan_config.gpio_pin_pull = EXTINT_PULL_UP;
extint_chan_config.wake_if_sleeping = false;
extint_chan_config.filter_input_signal = false;
extint_chan_config.detection_criteria = EXTINT_DETECT_HIGH;
extint_chan_set_config(0, &extint_chan_config);
/* Configure external interrupt module to be event generator */
struct extint_events extint_event_conf;
extint_event_conf.generate_event_on_detect[0] = true;
extint_enable_events(&extint_event_conf);
/* Configure event system */
struct events_resource event_res;
/* Configure channel */
struct events_config config;
events_get_config_defaults(&config);
config.generator = CONF_EVENT_GENERATOR_ID;
config.edge_detect = EVENTS_EDGE_DETECT_NONE;
config.path = EVENTS_PATH_ASYNCHRONOUS;
events_allocate(&event_res, &config);
/* Configure user */
events_attach_user(&event_res, CONF_EVENT_USED_ID);
/* Enable TC modules */
tc_enable(&tc_test1_module);
tc_enable(&tc_test0_module);
uint16_t period_after_capture = 0;
uint16_t pulse_width_after_capture = 0;
uint32_t capture_frequency = 0;
uint32_t capture_duty = 0;
while (callback_function_entered < 4) {
period_after_capture = tc_get_capture_value(&tc_test1_module,
TC_COMPARE_CAPTURE_CHANNEL_0);
pulse_width_after_capture = tc_get_capture_value(&tc_test1_module,
TC_COMPARE_CAPTURE_CHANNEL_1);
}
if(period_after_capture != 0) {
capture_frequency = system_clock_source_get_hz(SYSTEM_CLOCK_SOURCE_OSC8M)/ period_after_capture;
capture_duty = (uint32_t)(pulse_width_after_capture) * 100 / period_after_capture;
}
test_assert_true(test,
(capture_frequency <= (frequency_output * (100 + CONF_TEST_TOLERANCE) / 100)) && \
(capture_frequency >= (frequency_output * (100 - CONF_TEST_TOLERANCE) / 100)) && \
(capture_duty <= (duty_output * (100 + CONF_TEST_TOLERANCE) / 100)) && \
(capture_duty >= (duty_output * (100 - CONF_TEST_TOLERANCE) / 100)) \
,"The result of Capture is wrong, captured frequency: %ldHz, captured duty: %ld%%",
capture_frequency,
capture_duty
);
}
/**
* \brief Initialize the USART for unit test
*
* Initializes the SERCOM USART used for sending the unit test status to the
* computer via the EDBG CDC gateway.
*/
static void cdc_uart_init(void)
{
struct usart_config usart_conf;
/* Configure USART for unit test output */
usart_get_config_defaults(&usart_conf);
usart_conf.mux_setting = CONF_STDIO_MUX_SETTING;
usart_conf.pinmux_pad0 = CONF_STDIO_PINMUX_PAD0;
usart_conf.pinmux_pad1 = CONF_STDIO_PINMUX_PAD1;
usart_conf.pinmux_pad2 = CONF_STDIO_PINMUX_PAD2;
usart_conf.pinmux_pad3 = CONF_STDIO_PINMUX_PAD3;
usart_conf.baudrate = CONF_STDIO_BAUDRATE;
stdio_serial_init(&cdc_uart_module, CONF_STDIO_USART, &usart_conf);
usart_enable(&cdc_uart_module);
}
/**
* \brief Run TC unit tests
*
* Initializes the system and serial output, then sets up the TC unit test
* suite and runs it.
*/
int main(void)
{
system_init();
cdc_uart_init();
/* Define Test Cases */
DEFINE_TEST_CASE(init_test, NULL,
run_init_test, NULL,
"Initialize tc_xmodules");
DEFINE_TEST_CASE(basic_functionality_test, NULL,
run_basic_functionality_test, NULL,
"test start stop and getters and setters");
DEFINE_TEST_CASE(callback_test, NULL,
run_callback_test, NULL,
"test callback API");
DEFINE_TEST_CASE(reset_32bit_master_test, NULL,
run_reset_32bit_master_test, NULL,
"Setup, reset and reinitialize TC modules of a 32-bit TC");
DEFINE_TEST_CASE(capture_and_compare_test, NULL,
run_16bit_capture_and_compare_test, NULL,
"Test capture and compare");
/* Put test case addresses in an array */
DEFINE_TEST_ARRAY(tc_tests) = {
&init_test,
&basic_functionality_test,
&callback_test,
&reset_32bit_master_test,
&capture_and_compare_test,
};
/* Define the test suite */
DEFINE_TEST_SUITE(tc_suite, tc_tests,
"SAM TC driver test suite");
/* Run all tests in the suite*/
test_suite_run(&tc_suite);
tc_reset(&tc_test0_module);
tc_reset(&tc_test1_module);
while (true) {
/* Intentionally left empty */
}
}
