int main(void)
{
system_init();
//! [setup_init]
configure_usart();
configure_usart_callbacks();
//! [setup_init]
//! [main]
//! [enable_global_interrupts]
system_interrupt_enable_global();
//! [enable_global_interrupts]
//! [main_send_string]
uint8_t string[] = "Hello World!\r\n";
usart_write_buffer_job(&usart_instance, string, sizeof(string));
//! [main_send_string]
//! [main_loop]
while (true) {
//! [main_loop]
//! [main_read]
usart_read_buffer_job(&usart_instance,
(uint8_t *)rx_buffer, MAX_RX_BUFFER_LENGTH);
//! [main_read]
}
//! [main]
}
void Send(uint8_t user)
{
uint16_t stemp;
uint8_t sn = true;
uint8_t cnt = 1;
uint8_t Temp[17];
sprintf(Temp, "AT+CIPSEND=%c,3\r\n", user);
while(usart_write_buffer_job(&usart_instance, Temp, sizeof(Temp)) != STATUS_OK){}
while(sn)
if(usart_read_wait(&usart_instance, &stemp) == STATUS_OK)
{
if(stemp == '>')
{
while(usart_write_buffer_wait(&usart_instance, num, sizeof(num)) != STATUS_OK){}
while(true)
if(usart_read_wait(&usart_instance, &stemp) == STATUS_OK)
{
if(stemp == 'K')
{
sn = false;
break;
}
else if(cnt == 1000)
{
Send(user);
sn = false;
break;
}
cnt ++;
}
}
}
}
uint16_t serial_drv_send(uint8_t* data, uint16_t len)
{
while (STATUS_OK != usart_write_buffer_job(&usart_instance, data, len));
/* Wait for ongoing transmission complete */
while (STATUS_OK != usart_get_job_status(&usart_instance, USART_TRANSCEIVER_TX));
return STATUS_OK;
}
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);
}
otError otPlatUartSend(const uint8_t *aBuf, uint16_t aBufLength)
{
otError error = OT_ERROR_NONE;
if (usart_write_buffer_job(&sUsartInstance, (uint8_t *)aBuf, aBufLength) != STATUS_OK)
{
error = OT_ERROR_FAILED;
}
return error;
}
static void prvSendBuffer( struct usart_module *pxCDCUsart, uint8_t * pcBuffer, size_t xBufferLength )
{
const portTickType xBlockMax100ms = 100UL / portTICK_RATE_MS;
if( xBufferLength > 0 )
{
usart_write_buffer_job( pxCDCUsart, pcBuffer, xBufferLength );
/* Wait for the Tx to complete so the buffer can be reused without
corrupting the data that is being sent. */
xSemaphoreTake( xTxCompleteSemaphore, xBlockMax100ms );
}
}
/**
* \internal
* \brief USART interrupt callback function
*
* Called by USART driver when transmit is complete.
*
* * \param module USART module causing the interrupt (not used)
*/
static void usart_tx_callback(struct usart_module *const module)
{
/* Data ready to be sent */
if (udi_cdc_is_rx_ready()) {
/* Transmit next data */
ui_com_rx_start();
tx_data = udi_cdc_getc();
usart_write_buffer_job(&usart_module_edbg, &tx_data, 1);
} else {
/* Fifo empty then Stop UART transmission */
usart_disable_callback(&usart_module_edbg, USART_CALLBACK_BUFFER_TRANSMITTED);
ui_com_rx_stop();
}
}
void usart_read_callback(const struct usart_module *const usart_module)
{
//usart_write_buffer_job(&usart_instance, (uint8_t *) rx_buffer, MAX_RX_BUFFER_LENGTH);
usart_write_buffer_job(&usart_instance, (uint8_t *) rx_buffer, 1);
}
//////////////////////////////////////////////////////////////////////////
// TCC Callback Function
// -> This function only toggles the LED when TCC is triggered
static void tcc_callback_function( struct tcc_module *const module_instance ) {
usart_write_buffer_job(&irda_master, slave_tx_buffer, 1); // Send only one character
port_pin_toggle_output_level(LED_DEBUG); // Toggle LED
}
void usart_rxCallbackBluetooth( struct usart_module *const usart_module )
{
usart_write_buffer_job( &usart_instanceBluetooth,
(uint8_t *)rx_bufferBluetooth,
MAX_CALLBACK_BUFFER_LEN);
}
void usart_rxCallbackFTDI( struct usart_module *const usart_module )
{
usart_write_buffer_job( &usart_instanceFTDI,
(uint8_t *)rx_bufferFTDI,
MAX_CALLBACK_BUFFER_LEN);
}
