uint32_t app_uart_put(uint8_t byte)
{
uint32_t err_code;
err_code = app_fifo_put(&m_tx_fifo, byte);
if (err_code == NRF_SUCCESS)
{
// The new byte has been added to FIFO. It will be picked up from there
// (in 'uart_event_handler') when all preceding bytes are transmitted.
// But if UART is not transmitting anything at the moment, we must start
// a new transmission here.
if (!nrf_drv_uart_tx_in_progress())
{
// This operation should be almost always successful, since we've
// just added a byte to FIFO, but if some bigger delay occurred
// (some heavy interrupt handler routine has been executed) since
// that time, FIFO might be empty already.
if (app_fifo_get(&m_tx_fifo, tx_buffer) == NRF_SUCCESS)
{
err_code = nrf_drv_uart_tx(tx_buffer, 1);
}
}
}
return err_code;
}
ret_code_t nrf_drv_rng_rand(uint8_t * p_buff, uint8_t length)
{
ret_code_t result;
ASSERT(m_rng_cb.state == NRF_DRV_STATE_INITIALIZED);
#ifndef SOFTDEVICE_PRESENT
if (FIFO_LENGTH(m_rng_cb.rand_pool) >= length)
{
result = NRF_SUCCESS;
for (uint32_t i = 0; (i < length) && (result == NRF_SUCCESS); i++)
{
result = app_fifo_get(&(m_rng_cb.rand_pool), &p_buff[i]);
}
rng_start();
}
else
{
result = NRF_ERROR_NO_MEM;
}
#else
result = sd_rand_application_vector_get(p_buff, length);
#endif // SOFTDEVICE_PRESENT
return result;
}
/*@brief Action to send next byte in the TX buffer. Called when (re-)entering the UART_ON state.
* If no more data is available in the TX buffer, the state machine will enter UART_READY state.
*/
static void action_tx_send()
{
uint8_t byte;
if (m_current_state != UART_ON)
{
// Start the UART.
NRF_UART0->TASKS_STARTTX = 1;
}
// Get next byte from FIFO.
if (app_fifo_get(&m_tx_fifo, &byte) == NRF_SUCCESS)
{
// Initiate transmission of byte.
NRF_UART0->INTENCLR = (UART_INTENSET_TXDRDY_Set << UART_INTENSET_TXDRDY_Pos);
NRF_UART0->TXD = byte;
m_current_state = UART_ON;
NRF_UART0->INTENSET = (UART_INTENSET_TXDRDY_Set << UART_INTENSET_TXDRDY_Pos);
}
else
{
// No more bytes in FIFO, terminate transmission.
NRF_UART0->TASKS_STOPTX = 1;
m_current_state = UART_READY;
}
}
uint32_t app_uart_get(uint8_t * p_byte)
{
NVIC_DisableIRQ(UART0_IRQn);
uint32_t retval = app_fifo_get(&m_rx_fifo, p_byte);
if(rx_fifo_overflow)
{
app_fifo_put(&m_rx_fifo, (uint8_t)NRF_UART0->RXD);
rx_fifo_overflow = false;
}
NVIC_EnableIRQ(UART0_IRQn);
return retval;
}
static void uart_event_handler(nrf_drv_uart_event_t * p_event, void* p_context)
{
app_uart_evt_t app_uart_event;
if (p_event->type == NRF_DRV_UART_EVT_RX_DONE)
{
// Write received byte to FIFO
uint32_t err_code = app_fifo_put(&m_rx_fifo, p_event->data.rxtx.p_data[0]);
if (err_code != NRF_SUCCESS)
{
app_uart_event.evt_type = APP_UART_FIFO_ERROR;
app_uart_event.data.error_code = err_code;
m_event_handler(&app_uart_event);
}
// Notify that new data is available if this was first byte put in the buffer.
else if (FIFO_LENGTH(m_rx_fifo) == 1)
{
app_uart_event.evt_type = APP_UART_DATA_READY;
m_event_handler(&app_uart_event);
}
else
{
// Do nothing, only send event if first byte was added or overflow in FIFO occurred.
}
if (FIFO_LENGTH(m_rx_fifo) <= m_rx_fifo.buf_size_mask)
{
(void)nrf_drv_uart_rx(rx_buffer,1);
}
}
else if (p_event->type == NRF_DRV_UART_EVT_ERROR)
{
app_uart_event.evt_type = APP_UART_COMMUNICATION_ERROR;
app_uart_event.data.error_communication = p_event->data.error.error_mask;
(void)nrf_drv_uart_rx(rx_buffer,1);
m_event_handler(&app_uart_event);
}
else if (p_event->type == NRF_DRV_UART_EVT_TX_DONE)
{
// Get next byte from FIFO.
if (app_fifo_get(&m_tx_fifo, tx_buffer) == NRF_SUCCESS)
{
(void)nrf_drv_uart_tx(tx_buffer,1);
}
if (FIFO_LENGTH(m_tx_fifo) == 0)
{
// Last byte from FIFO transmitted, notify the application.
// Notify that new data is available if this was first byte put in the buffer.
app_uart_event.evt_type = APP_UART_TX_EMPTY;
m_event_handler(&app_uart_event);
}
}
}
uint32_t app_uart_get(uint8_t * p_byte)
{
ASSERT(p_byte);
// If FIFO was full new request to receive one byte was not scheduled. Must be done here.
if (FIFO_LENGTH(m_rx_fifo) == m_rx_fifo.buf_size_mask)
{
uint32_t err_code = nrf_drv_uart_rx(rx_buffer,1);
if (err_code != NRF_SUCCESS)
{
return NRF_ERROR_NOT_FOUND;
}
}
return app_fifo_get(&m_rx_fifo, p_byte);
}
uint32_t app_uart_get(uint8_t * p_byte)
{
ASSERT(p_byte);
bool rx_ovf = m_rx_ovf;
ret_code_t err_code = app_fifo_get(&m_rx_fifo, p_byte);
// If FIFO was full new request to receive one byte was not scheduled. Must be done here.
if (rx_ovf)
{
m_rx_ovf = false;
uint32_t uart_err_code = nrf_drv_uart_rx(&app_uart_inst, rx_buffer, 1);
// RX resume should never fail.
APP_ERROR_CHECK(uart_err_code);
}
return err_code;
}
/**@brief Function for sending the next byte in the TX buffer. Called when (re-)entering the UART_ON state.
* If no more data is available in the TX buffer, the state machine will enter UART_READY state.
*/
static void action_tx_send()
{
uint8_t tx_byte;
if (m_current_state != UART_ON)
{
// Start the UART.
NRF_UART0->TASKS_STARTTX = 1;
}
if (app_fifo_get(&m_tx_fifo, &tx_byte) != NRF_SUCCESS)
{
action_tx_stop();
return;
}
NRF_UART0->INTENCLR = (UART_INTENSET_TXDRDY_Set << UART_INTENSET_TXDRDY_Pos);
NRF_UART0->TXD = tx_byte;
m_current_state = UART_ON;
NRF_UART0->INTENSET = (UART_INTENSET_TXDRDY_Set << UART_INTENSET_TXDRDY_Pos);
}
uint32_t app_uart_get(uint8_t * p_byte)
{
return app_fifo_get(&m_rx_fifo, p_byte);
}
static void uart_event_handler(nrf_drv_uart_event_t * p_event, void* p_context)
{
app_uart_evt_t app_uart_event;
uint32_t err_code;
switch (p_event->type)
{
case NRF_DRV_UART_EVT_RX_DONE:
// Write received byte to FIFO.
err_code = app_fifo_put(&m_rx_fifo, p_event->data.rxtx.p_data[0]);
if (err_code != NRF_SUCCESS)
{
app_uart_event.evt_type = APP_UART_FIFO_ERROR;
app_uart_event.data.error_code = err_code;
m_event_handler(&app_uart_event);
}
// Notify that there are data available.
else if (FIFO_LENGTH(m_rx_fifo) != 0)
{
app_uart_event.evt_type = APP_UART_DATA_READY;
m_event_handler(&app_uart_event);
}
// Start new RX if size in buffer.
if (FIFO_LENGTH(m_rx_fifo) <= m_rx_fifo.buf_size_mask)
{
(void)nrf_drv_uart_rx(&app_uart_inst, rx_buffer, 1);
}
else
{
// Overflow in RX FIFO.
m_rx_ovf = true;
}
break;
case NRF_DRV_UART_EVT_ERROR:
app_uart_event.evt_type = APP_UART_COMMUNICATION_ERROR;
app_uart_event.data.error_communication = p_event->data.error.error_mask;
(void)nrf_drv_uart_rx(&app_uart_inst, rx_buffer, 1);
m_event_handler(&app_uart_event);
break;
case NRF_DRV_UART_EVT_TX_DONE:
// Get next byte from FIFO.
if (app_fifo_get(&m_tx_fifo, tx_buffer) == NRF_SUCCESS)
{
(void)nrf_drv_uart_tx(&app_uart_inst, tx_buffer, 1);
}
else
{
// Last byte from FIFO transmitted, notify the application.
app_uart_event.evt_type = APP_UART_TX_EMPTY;
m_event_handler(&app_uart_event);
}
break;
default:
break;
}
}