/* === 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);
}
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;
}
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_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);
}
/*---------------------------------------------------------------------------*/
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;
}
static void configure_usart_callbacks(void)
{
usart_register_callback(&usart_debug, usart_read_callback, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&usart_debug, USART_CALLBACK_BUFFER_RECEIVED);
// set up first callback 'job'
usart_read_buffer_job(&usart_debug, (uint8_t *)rx_buffer, MAX_RX_BUFFER_LENGTH);
}
void uart_rx_notify(uint8_t port)
{
UNUSED(port);
/* Transmit first data */
ui_com_rx_start();
usart_enable_callback(&usart_module_edbg, USART_CALLBACK_BUFFER_TRANSMITTED);
tx_data = udi_cdc_getc();
usart_write_buffer_job(&usart_module_edbg, &tx_data, 1);
}
/**
* \brief Callback to get the MQTT status update.
*
* \param[in] conn_id instance id of connection which is being used.
* \param[in] type type of MQTT notification. Possible types are:
* - [MQTT_CALLBACK_SOCK_CONNECTED](@ref MQTT_CALLBACK_SOCK_CONNECTED)
* - [MQTT_CALLBACK_CONNECTED](@ref MQTT_CALLBACK_CONNECTED)
* - [MQTT_CALLBACK_PUBLISHED](@ref MQTT_CALLBACK_PUBLISHED)
* - [MQTT_CALLBACK_SUBSCRIBED](@ref MQTT_CALLBACK_SUBSCRIBED)
* - [MQTT_CALLBACK_UNSUBSCRIBED](@ref MQTT_CALLBACK_UNSUBSCRIBED)
* - [MQTT_CALLBACK_DISCONNECTED](@ref MQTT_CALLBACK_DISCONNECTED)
* - [MQTT_CALLBACK_RECV_PUBLISH](@ref MQTT_CALLBACK_RECV_PUBLISH)
* \param[in] data A structure contains notification informations. @ref mqtt_data
*/
static void mqtt_callback(struct mqtt_module *module_inst, int type, union mqtt_data *data)
{
switch (type) {
case MQTT_CALLBACK_SOCK_CONNECTED:
{
/*
* If connecting to broker server is complete successfully, Start sending CONNECT message of MQTT.
* Or else retry to connect to broker server.
*/
if (data->sock_connected.result >= 0) {
mqtt_connect_broker(module_inst, 1, NULL, NULL, mqtt_user, NULL, NULL, 0, 0, 0);
} else {
printf("Connect fail to server(%s)! retry it automatically.\r\n", main_mqtt_broker);
mqtt_connect(module_inst, main_mqtt_broker); /* Retry that. */
}
}
break;
case MQTT_CALLBACK_CONNECTED:
if (data->connected.result == MQTT_CONN_RESULT_ACCEPT) {
/* Subscribe chat topic. */
mqtt_subscribe(module_inst, MAIN_CHAT_TOPIC "#", 0);
/* Enable USART receiving callback. */
usart_enable_callback(&cdc_uart_module, USART_CALLBACK_BUFFER_RECEIVED);
printf("Preparation of the chat has been completed.\r\n");
} else {
/* Cannot connect for some reason. */
printf("MQTT broker decline your access! error code %d\r\n", data->connected.result);
}
break;
case MQTT_CALLBACK_RECV_PUBLISH:
/* You received publish message which you had subscribed. */
if (data->recv_publish.topic != NULL && data->recv_publish.msg != NULL) {
if (!strncmp(data->recv_publish.topic, MAIN_CHAT_TOPIC, strlen(MAIN_CHAT_TOPIC))) {
/* Print user name and message */
for (int i = strlen(MAIN_CHAT_TOPIC); i < data->recv_publish.topic_size; i++) {
printf("%c", data->recv_publish.topic[i]);
}
printf(" >> ");
for (int i = 0; i < data->recv_publish.msg_size; i++) {
printf("%c", data->recv_publish.msg[i]);
}
printf("\r\n");
}
}
break;
case MQTT_CALLBACK_DISCONNECTED:
/* Stop timer and USART callback. */
printf("MQTT disconnected\r\n");
usart_disable_callback(&cdc_uart_module, USART_CALLBACK_BUFFER_RECEIVED);
break;
}
}
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 );
}
void usart_configureCallbacks( void )
{
/* Register FTDI Callbacks */
#ifndef FTDI_USE_DMA
usart_register_callback(&usart_instanceFTDI,
usart_txCallbackFTDI, USART_CALLBACK_BUFFER_TRANSMITTED);
usart_register_callback(&usart_instanceFTDI,
usart_rxCallbackFTDI, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&usart_instanceFTDI, USART_CALLBACK_BUFFER_TRANSMITTED);
usart_enable_callback(&usart_instanceFTDI, USART_CALLBACK_BUFFER_RECEIVED);
#endif
/* Register Bluetooth Callbacks */
#ifndef BT_USE_DMA
usart_register_callback(&usart_instanceBluetooth,
usart_txCallbackBluetooth, USART_CALLBACK_BUFFER_TRANSMITTED);
usart_register_callback(&usart_instanceBluetooth,
usart_rxCallbackBluetooth, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&usart_instanceBluetooth, USART_CALLBACK_BUFFER_TRANSMITTED);
usart_enable_callback(&usart_instanceBluetooth, USART_CALLBACK_BUFFER_RECEIVED);
#endif
}
/**
* \brief Configure UART console with callback function.
*/
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_callback(&cdc_uart_module, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable(&cdc_uart_module);
}
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;
}
void cph_stdio_set_rx_callback(usart_callback_t callback_func) {
usart_register_callback(&usart_instance, callback_func, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&usart_instance, USART_CALLBACK_BUFFER_RECEIVED);
}
void configure_usart_callbacks(void)
{
usart_register_callback(&cdc_uart_module, USART_RX_callback, USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&cdc_uart_module, USART_CALLBACK_BUFFER_RECEIVED);
}
void uart_config(uint8_t port,usb_cdc_line_coding_t *cfg)
{
UNUSED(port);
/* Configure USART for unit test output */
usart_get_config_defaults(&usart_conf);
switch (cfg->bCharFormat) {
case CDC_STOP_BITS_2:
usart_conf.stopbits = USART_STOPBITS_2;
break;
case CDC_STOP_BITS_1_5:
usart_conf.stopbits = USART_STOPBITS_1;
break;
case CDC_STOP_BITS_1:
default:
/* Default stop bit = 1 stop bit */
usart_conf.stopbits = USART_STOPBITS_1;
break;
}
switch (cfg->bParityType) {
case CDC_PAR_EVEN:
usart_conf.parity = USART_PARITY_EVEN;
break;
case CDC_PAR_ODD:
usart_conf.parity = USART_PARITY_ODD;
break;
case CDC_PAR_MARK:
usart_conf.parity = USART_PARITY_NONE;
break;
case CDC_PAR_SPACE:
usart_conf.parity = USART_PARITY_NONE;
break;
case CDC_PAR_NONE:
default:
usart_conf.parity = USART_PARITY_NONE;
break;
}
switch(cfg->bDataBits) {
case 5:
usart_conf.character_size = USART_CHARACTER_SIZE_5BIT;
break;
case 6:
usart_conf.character_size = USART_CHARACTER_SIZE_6BIT;
break;
case 7:
usart_conf.character_size = USART_CHARACTER_SIZE_7BIT;
break;
case 8:
default:
usart_conf.character_size = USART_CHARACTER_SIZE_8BIT;
break;
}
/* Options for USART. */
usart_conf.baudrate = LE32_TO_CPU(cfg->dwDTERate);
usart_conf.mux_setting = CONF_USART_MUX_SETTING;
usart_conf.pinmux_pad0 = CONF_USART_PINMUX_PAD0;
usart_conf.pinmux_pad1 = CONF_USART_PINMUX_PAD1;
usart_conf.pinmux_pad2 = CONF_USART_PINMUX_PAD2;
usart_conf.pinmux_pad3 = CONF_USART_PINMUX_PAD3;
usart_disable(&usart_module_edbg);
usart_init(&usart_module_edbg, CONF_USART_BASE, &usart_conf);
usart_enable(&usart_module_edbg);
/* Enable interrupts */
usart_register_callback(&usart_module_edbg, usart_tx_callback,
USART_CALLBACK_BUFFER_TRANSMITTED);
usart_enable_callback(&usart_module_edbg, USART_CALLBACK_BUFFER_TRANSMITTED);
usart_register_callback(&usart_module_edbg, usart_rx_callback,
USART_CALLBACK_BUFFER_RECEIVED);
usart_enable_callback(&usart_module_edbg, USART_CALLBACK_BUFFER_RECEIVED);
usart_read_buffer_job(&usart_module_edbg, &rx_data, 1);
}
