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.
app_uart_event.evt_type = APP_UART_TX_EMPTY;
m_event_handler(&app_uart_event);
}
}
}
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 Function for the handling of the ON_CTS_LOW event.
*/
static void on_cts_low(void)
{
switch (m_current_state)
{
case UART_OFF:
NRF_UART0->ENABLE = (UART_ENABLE_ENABLE_Enabled << UART_ENABLE_ENABLE_Pos);
NRF_UART0->TASKS_STARTRX = 1;
if (FIFO_LENGTH(m_tx_fifo) != 0)
{
action_tx_send();
}
else
{
m_current_state = UART_READY;
}
break;
case UART_WAIT_CLOSE:
m_current_state = UART_ON;
break;
default:
// Nothing to do.
break;
}
}
/**@brief Function for the UART Interrupt handler.
*
* @details UART interrupt handler to process TX Ready when TXD is available, RX Ready when a byte
* is received, or in case of error when receiving a byte.
*/
void UART0_IRQHandler(void)
{
// Handle reception
if (NRF_UART0->EVENTS_RXDRDY != 0)
{
uint32_t err_code;
// Clear UART RX event flag
NRF_UART0->EVENTS_RXDRDY = 0;
// Write received byte to FIFO
err_code = app_fifo_put(&m_rx_fifo, (uint8_t)NRF_UART0->RXD);
if (err_code != NRF_SUCCESS)
{
app_uart_evt_t app_uart_event;
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_evt_t app_uart_event;
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.
}
}
// Handle transmission.
if (NRF_UART0->EVENTS_TXDRDY != 0)
{
// Clear UART TX event flag.
NRF_UART0->EVENTS_TXDRDY = 0;
on_uart_event(ON_TX_READY);
}
// Handle errors.
if (NRF_UART0->EVENTS_ERROR != 0)
{
uint32_t error_source;
app_uart_evt_t app_uart_event;
// Clear UART ERROR event flag.
NRF_UART0->EVENTS_ERROR = 0;
// Clear error source.
error_source = NRF_UART0->ERRORSRC;
NRF_UART0->ERRORSRC = error_source;
app_uart_event.evt_type = APP_UART_COMMUNICATION_ERROR;
app_uart_event.data.error_communication = error_source;
m_event_handler(&app_uart_event);
}
}
static void rng_start(void)
{
if (FIFO_LENGTH(m_rng_cb.rand_pool) <= m_rng_cb.rand_pool.buf_size_mask)
{
nrf_rng_event_clear(NRF_RNG_EVENT_VALRDY);
nrf_rng_int_enable(NRF_RNG_INT_VALRDY_MASK);
nrf_rng_task_trigger(NRF_RNG_TASK_START);
}
}
uint32_t app_fifo_peek(app_fifo_t * p_fifo, uint16_t index, uint8_t * p_byte)
{
if (FIFO_LENGTH() > index)
{
fifo_peek(p_fifo, index, p_byte);
return NRF_SUCCESS;
}
return NRF_ERROR_NOT_FOUND;
}
uint32_t app_fifo_put(app_fifo_t * p_fifo, uint8_t byte)
{
if (FIFO_LENGTH() <= p_fifo->buf_size_mask)
{
fifo_put(p_fifo, byte);
return NRF_SUCCESS;
}
return NRF_ERROR_NO_MEM;
}
uint32_t app_fifo_get(app_fifo_t * p_fifo, uint8_t * p_byte)
{
if (FIFO_LENGTH() != 0)
{
fifo_get(p_fifo, p_byte);
return NRF_SUCCESS;
}
return NRF_ERROR_NOT_FOUND;
}
static void action_tx_ready()
{
// Get next byte from FIFO.
if (FIFO_LENGTH(m_tx_fifo) != 0)
{
action_tx_send();
}
else
{
action_tx_stop();
}
}
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);
}
void RNG_IRQHandler(void)
{
if (nrf_rng_event_get(NRF_RNG_EVENT_VALRDY) &&
nrf_rng_int_get(NRF_RNG_INT_VALRDY_MASK))
{
nrf_rng_event_clear(NRF_RNG_EVENT_VALRDY);
uint32_t nrf_error = app_fifo_put(&m_rng_cb.rand_pool, nrf_rng_random_value_get());
if ((FIFO_LENGTH(m_rng_cb.rand_pool) > m_rng_cb.rand_pool.buf_size_mask) || (nrf_error == NRF_ERROR_NO_MEM))
{
rng_stop();
}
}
}
ret_code_t nrf_drv_rng_bytes_available(uint8_t * p_bytes_available)
{
ret_code_t result;
ASSERT(m_rng_cb.state == NRF_DRV_STATE_INITIALIZED);
#ifndef SOFTDEVICE_PRESENT
result = NRF_SUCCESS;
*p_bytes_available = FIFO_LENGTH(m_rng_cb.rand_pool);
#else
result = sd_rand_application_bytes_available_get(p_bytes_available);
#endif // SOFTDEVICE_PRESENT
return result;
}
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;
}
}