OSStatus platform_uart_receive_bytes( platform_uart_driver_t* driver, uint8_t* data_in, uint32_t expected_data_size, uint32_t timeout_ms )
{
OSStatus err = kNoErr;
//platform_mcu_powersave_disable();
require_action_quiet( ( driver != NULL ) && ( data_in != NULL ) && ( expected_data_size != 0 ), exit, err = kParamErr);
mico_rtos_get_semaphore( &driver->rx_complete, 0 );
if ( driver->rx_buffer != NULL)
{
while ( expected_data_size != 0 )
{
uint32_t transfer_size = MIN( driver->rx_buffer->size / 2, expected_data_size );
/* Set rx_size and wait in rx_complete semaphore until data reaches rx_size or timeout occurs */
driver->last_receive_result = kNoErr;
driver->rx_size = transfer_size;
/* Check if ring buffer already contains the required amount of data. */
if ( transfer_size > ring_buffer_used_space( driver->rx_buffer ) )
{
err = mico_rtos_get_semaphore( &driver->rx_complete, timeout_ms );
/* Reset rx_size to prevent semaphore being set while nothing waits for the data */
driver->rx_size = 0;
if( err != kNoErr )
goto exit;
}else {
driver->rx_size = 0;
}
err = driver->last_receive_result;
expected_data_size -= transfer_size;
// Grab data from the buffer
do
{
uint8_t* available_data;
uint32_t bytes_available;
ring_buffer_get_data( driver->rx_buffer, &available_data, &bytes_available );
bytes_available = MIN( bytes_available, transfer_size );
memcpy( data_in, available_data, bytes_available );
transfer_size -= bytes_available;
data_in = ( (uint8_t*) data_in + bytes_available );
ring_buffer_consume( driver->rx_buffer, bytes_available );
} while ( transfer_size != 0 );
}
}
else
{
err = receive_bytes( driver, data_in, expected_data_size, timeout_ms );
}
exit:
//platform_mcu_powersave_enable();
return err;
}
int UART_Recv(u8 *recvBuf, u32 bufLen, u32 timeOut)
{
while (bufLen != 0){
uint32_t transfer_size = MIN(rx_buffer.size / 2, bufLen);
/* Check if ring buffer already contains the required amount of data. */
if ( transfer_size > ring_buffer_used_space( &rx_buffer ) ) {
/* Set rx_size and wait in rx_complete semaphore until data reaches rx_size or timeout occurs */
rx_size = transfer_size;
if ( mico_rtos_get_semaphore( &rx_complete, timeOut ) != 0 ){
rx_size = 0;
return -1;
}
/* Reset rx_size to prevent semaphore being set while nothing waits for the data */
rx_size = 0;
}
bufLen -= transfer_size;
// Grab data from the buffer
do
{
uint8_t* available_data;
uint32_t bytes_available;
ring_buffer_get_data( &rx_buffer, &available_data, &bytes_available );
bytes_available = MIN( bytes_available, transfer_size );
memcpy( recvBuf, available_data, bytes_available );
transfer_size -= bytes_available;
recvBuf = ( (uint8_t*) recvBuf + bytes_available );
ring_buffer_consume( &rx_buffer, bytes_available );
} while ( transfer_size != 0 );
}
if ( bufLen != 0 ) {
return -1;
}
else{
return 0;
}
}
OSStatus MicoUartRecv( mico_uart_t uart, void* data, uint32_t size, uint32_t timeout )
{
#if RING_BUFF_ON
if (uart_interfaces[uart].rx_buffer != NULL)
{
while (size != 0)
{
uint32_t transfer_size = MIN(uart_interfaces[uart].rx_buffer->size / 2, size);
/* Check if ring buffer already contains the required amount of data. */
if ( transfer_size > ring_buffer_used_space( uart_interfaces[uart].rx_buffer ) )
{
/* Set rx_size and wait in rx_complete semaphore until data reaches rx_size or timeout occurs */
uart_interfaces[uart].rx_size = transfer_size;
#ifndef NO_MICO_RTOS
if ( mico_rtos_get_semaphore( &uart_interfaces[uart].rx_complete, timeout) != kNoErr )
{
uart_interfaces[uart].rx_size = 0;
return kTimeoutErr;
}
#else
uart_interfaces[uart].rx_complete = false;
int delay_start = mico_get_time_no_os();
while(uart_interfaces[uart].rx_complete == false){
if(mico_get_time_no_os() >= delay_start + timeout && timeout != MICO_NEVER_TIMEOUT){
uart_interfaces[uart].rx_size = 0;
return kTimeoutErr;
}
}
#endif
/* Reset rx_size to prevent semaphore being set while nothing waits for the data */
uart_interfaces[uart].rx_size = 0;
}
size -= transfer_size;
// Grab data from the buffer
do
{
uint8_t* available_data;
uint32_t bytes_available;
//platform_log("uart receive 03");
ring_buffer_get_data( uart_interfaces[uart].rx_buffer, &available_data, &bytes_available );
bytes_available = MIN( bytes_available, transfer_size );
memcpy( data, available_data, bytes_available );
transfer_size -= bytes_available;
data = ( (uint8_t*) data + bytes_available );
ring_buffer_consume( uart_interfaces[uart].rx_buffer, bytes_available );
} while ( transfer_size != 0 );
}
if ( size != 0 )
{
return kGeneralErr;
}
else
{
return kNoErr;
}
}
else
{
return platform_uart_receive_bytes( uart, data, size, timeout );
}
#else
return platform_uart_receive_bytes( uart, data, size, timeout );
#endif
// return kNoErr;
}
platform_result_t platform_uart_receive_bytes( platform_uart_driver_t* driver, uint8_t* data_in, uint32_t expected_data_size, uint32_t timeout_ms )
{
/*The following is a temporary implemenration of the UART*/
platform_result_t result = PLATFORM_SUCCESS;
wiced_assert( "bad argument", ( driver != NULL ) && ( data_in != NULL ) && ( expected_data_size != 0 ) );
if ( driver->rx_buffer != NULL )
{
while ( expected_data_size != 0 )
{
uint32_t transfer_size = MIN( driver->rx_buffer->size / 2, expected_data_size );
/* Check if ring buffer already contains the required amount of data. */
if ( transfer_size > ring_buffer_used_space( driver->rx_buffer ) )
{
wwd_result_t wwd_result;
/* Set rx_size and wait in rx_complete semaphore until data reaches rx_size or timeout occurs */
WICED_DISABLE_INTERRUPTS( );
driver->last_receive_result = PLATFORM_SUCCESS;
driver->rx_size = transfer_size;
WICED_ENABLE_INTERRUPTS( );
wwd_result = host_rtos_get_semaphore( &driver->rx_complete, timeout_ms, WICED_TRUE );
/* Reset rx_size to prevent semaphore being set while nothing waits for the data */
WICED_DISABLE_INTERRUPTS( );
driver->rx_size = 0;
WICED_ENABLE_INTERRUPTS( );
if ( wwd_result == WWD_TIMEOUT )
{
/* Semaphore timeout. breaks from the while loop */
result = PLATFORM_TIMEOUT;
break;
}
else
{
/* No timeout. retrieve result */
result = driver->last_receive_result;
}
}
expected_data_size -= transfer_size;
// Grab data from the buffer
do
{
uint8_t* available_data;
uint32_t bytes_available;
ring_buffer_get_data( driver->rx_buffer, &available_data, &bytes_available );
bytes_available = MIN( bytes_available, transfer_size );
memcpy( data_in, available_data, bytes_available );
transfer_size -= bytes_available;
data_in = ( (uint8_t*) data_in + bytes_available );
ring_buffer_consume( driver->rx_buffer, bytes_available );
} while ( transfer_size != 0 );
}
return result;
}
else
{
return result;
}
}
OSStatus platform_uart_receive_bytes( platform_uart_driver_t* driver, uint8_t* data_in, uint32_t expected_data_size, uint32_t timeout_ms )
{
OSStatus err = kNoErr;
uint32_t transfer_size;
//platform_mcu_powersave_disable();
require_action_quiet( ( driver != NULL ) && ( data_in != NULL ) && ( expected_data_size != 0 ), exit, err = kParamErr);
require_action_quiet( driver->rx_ring_buffer != NULL , exit, err = kUnsupportedErr);
while ( expected_data_size != 0 )
{
transfer_size = MIN(driver->rx_ring_buffer->size / 2, expected_data_size);
/* Check if ring buffer already contains the required amount of data. */
if ( transfer_size > ring_buffer_used_space( driver->rx_ring_buffer ) )
{
/* Set rx_size and wait in rx_complete semaphore until data reaches rx_size or timeout occurs */
driver->rx_size = transfer_size;
#ifndef NO_MICO_RTOS
if ( mico_rtos_get_semaphore( &driver->rx_complete, timeout_ms ) != kNoErr )
{
driver->rx_size = 0;
err = kTimeoutErr;
goto exit;
}
/* Reset rx_size to prevent semaphore being set while nothing waits for the data */
driver->rx_size = 0;
#else
driver->rx_complete = false;
int delay_start = mico_get_time_no_os();
while(driver->rx_complete == false) {
if(mico_get_time_no_os() >= delay_start + timeout_ms && timeout_ms != MICO_NEVER_TIMEOUT) {
driver->rx_size = 0;
err = kTimeoutErr;
goto exit;
}
}
driver->rx_size = 0;
#endif
}
expected_data_size -= transfer_size;
// Grab data from the buffer
do
{
uint8_t* available_data;
uint32_t bytes_available;
ring_buffer_get_data( driver->rx_ring_buffer, &available_data, &bytes_available );
bytes_available = MIN( bytes_available, transfer_size );
memcpy( data_in, available_data, bytes_available );
transfer_size -= bytes_available;
data_in = ( (uint8_t*)data_in + bytes_available );
ring_buffer_consume( driver->rx_ring_buffer, bytes_available );
}
while ( transfer_size != 0 );
}
require_action( expected_data_size == 0, exit, err = kReadErr);
exit:
//platform_mcu_powersave_enable();
return err;
}
platform_result_t platform_uart_receive_bytes( platform_uart_driver_t* driver, uint8_t* data_in, uint32_t expected_data_size, uint32_t timeout_ms )
{
UNUSED_PARAMETER(driver);
UNUSED_PARAMETER(data_in);
UNUSED_PARAMETER(expected_data_size);
UNUSED_PARAMETER(timeout_ms);
if ( driver->rx_ring_buffer != NULL )
{
while ( expected_data_size != 0 )
{
uint32_t transfer_size = MIN(driver->rx_ring_buffer->size / 2, expected_data_size);
/* Check if ring buffer already contains the required amount of data. */
if ( transfer_size > ring_buffer_used_space( driver->rx_ring_buffer ) )
{
/* Set rx_size and wait in rx_complete semaphore until data reaches rx_size or timeout occurs */
driver->rx_transfer_size = transfer_size;
if ( host_rtos_get_semaphore( &driver->rx_dma_complete, timeout_ms, WICED_FALSE ) != WWD_SUCCESS )
{
driver->rx_transfer_size = 0;
return PLATFORM_TIMEOUT;
}
/* Reset rx_size to prevent semaphore being set while nothing waits for the data */
driver->rx_transfer_size = 0;
}
expected_data_size -= transfer_size;
// Grab data from the buffer
do
{
uint8_t* available_data;
uint32_t bytes_available;
ring_buffer_get_data( driver->rx_ring_buffer, &available_data, &bytes_available );
bytes_available = MIN( bytes_available, transfer_size );
memcpy( data_in, available_data, bytes_available );
transfer_size -= bytes_available;
data_in = ( (uint8_t*)data_in + bytes_available );
ring_buffer_consume( driver->rx_ring_buffer, bytes_available );
}
while ( transfer_size != 0 );
}
if ( expected_data_size != 0 )
{
return PLATFORM_ERROR;
}
else
{
return PLATFORM_SUCCESS;
}
}
else
{
/* TODO: need to implement this */
return PLATFORM_UNSUPPORTED;
}
}
static OSStatus FUartRecv( platform_uart_driver_t* driver, void* data, uint32_t size, uint32_t timeout )
{
if ( driver->rx_buffer != NULL )
{
while (size != 0)
{
uint32_t transfer_size = MIN( driver->rx_buffer->size/2, size );
/* Check if ring buffer already contains the required amount of data. */
if ( transfer_size > ring_buffer_used_space( driver->rx_buffer ) )
{
/* Set rx_size and wait in rx_complete semaphore until data reaches rx_size or timeout occurs */
driver->rx_size = transfer_size;
#ifndef NO_MICO_RTOS
if ( mico_rtos_get_semaphore( &driver->rx_complete, timeout) != kNoErr )
{
driver->rx_size = 0;
return kTimeoutErr;
}
#else
driver->rx_complete = false;
int delay_start = mico_get_time_no_os();
while(driver->rx_complete == false){
if(mico_get_time_no_os() >= delay_start + timeout && timeout != MICO_NEVER_TIMEOUT){
driver->rx_size = 0;
return kTimeoutErr;
}
}
#endif
/* Reset rx_size to prevent semaphore being set while nothing waits for the data */
driver->rx_size = 0;
}
size -= transfer_size;
// Grab data from the buffer
do
{
uint8_t* available_data;
uint32_t bytes_available;
ring_buffer_get_data( driver->rx_buffer, &available_data, &bytes_available );
bytes_available = MIN( bytes_available, transfer_size );
memcpy( data, available_data, bytes_available );
transfer_size -= bytes_available;
data = ( (uint8_t*) data + bytes_available );
ring_buffer_consume( driver->rx_buffer, bytes_available );
} while ( transfer_size != 0 );
}
if ( size != 0 )
{
return kGeneralErr;
}
else
{
return kNoErr;
}
}
else
{
mico_thread_msleep(timeout);
return kNoMemoryErr;
}
}
