252 lines
8.9 KiB
C
252 lines
8.9 KiB
C
/**
|
|
* Copyright (c) 2015 - 2017, Nordic Semiconductor ASA
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice, this
|
|
* list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form, except as embedded into a Nordic
|
|
* Semiconductor ASA integrated circuit in a product or a software update for
|
|
* such product, must reproduce the above copyright notice, this list of
|
|
* conditions and the following disclaimer in the documentation and/or other
|
|
* materials provided with the distribution.
|
|
*
|
|
* 3. Neither the name of Nordic Semiconductor ASA nor the names of its
|
|
* contributors may be used to endorse or promote products derived from this
|
|
* software without specific prior written permission.
|
|
*
|
|
* 4. This software, with or without modification, must only be used with a
|
|
* Nordic Semiconductor ASA integrated circuit.
|
|
*
|
|
* 5. Any software provided in binary form under this license must not be reverse
|
|
* engineered, decompiled, modified and/or disassembled.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
|
|
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
|
|
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
|
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
#include "sdk_common.h"
|
|
#if NRF_MODULE_ENABLED(APP_UART)
|
|
#include "app_uart.h"
|
|
#include "app_fifo.h"
|
|
#include "nrf_drv_uart.h"
|
|
#include "nrf_assert.h"
|
|
|
|
static nrf_drv_uart_t app_uart_inst = NRF_DRV_UART_INSTANCE(APP_UART_DRIVER_INSTANCE);
|
|
|
|
static __INLINE uint32_t fifo_length(app_fifo_t * const fifo)
|
|
{
|
|
uint32_t tmp = fifo->read_pos;
|
|
return fifo->write_pos - tmp;
|
|
}
|
|
|
|
#define FIFO_LENGTH(F) fifo_length(&F) /**< Macro to calculate length of a FIFO. */
|
|
|
|
|
|
static app_uart_event_handler_t m_event_handler; /**< Event handler function. */
|
|
static uint8_t tx_buffer[1];
|
|
static uint8_t rx_buffer[1];
|
|
static bool m_rx_ovf;
|
|
|
|
static app_fifo_t m_rx_fifo; /**< RX FIFO buffer for storing data received on the UART until the application fetches them using app_uart_get(). */
|
|
static app_fifo_t m_tx_fifo; /**< TX FIFO buffer for storing data to be transmitted on the UART when TXD is ready. Data is put to the buffer on using app_uart_put(). */
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
|
|
uint32_t app_uart_init(const app_uart_comm_params_t * p_comm_params,
|
|
app_uart_buffers_t * p_buffers,
|
|
app_uart_event_handler_t event_handler,
|
|
app_irq_priority_t irq_priority)
|
|
{
|
|
uint32_t err_code;
|
|
|
|
m_event_handler = event_handler;
|
|
|
|
if (p_buffers == NULL)
|
|
{
|
|
return NRF_ERROR_INVALID_PARAM;
|
|
}
|
|
|
|
// Configure buffer RX buffer.
|
|
err_code = app_fifo_init(&m_rx_fifo, p_buffers->rx_buf, p_buffers->rx_buf_size);
|
|
VERIFY_SUCCESS(err_code);
|
|
|
|
// Configure buffer TX buffer.
|
|
err_code = app_fifo_init(&m_tx_fifo, p_buffers->tx_buf, p_buffers->tx_buf_size);
|
|
VERIFY_SUCCESS(err_code);
|
|
|
|
nrf_drv_uart_config_t config = NRF_DRV_UART_DEFAULT_CONFIG;
|
|
config.baudrate = (nrf_uart_baudrate_t)p_comm_params->baud_rate;
|
|
config.hwfc = (p_comm_params->flow_control == APP_UART_FLOW_CONTROL_DISABLED) ?
|
|
NRF_UART_HWFC_DISABLED : NRF_UART_HWFC_ENABLED;
|
|
config.interrupt_priority = irq_priority;
|
|
config.parity = p_comm_params->use_parity ? NRF_UART_PARITY_INCLUDED : NRF_UART_PARITY_EXCLUDED;
|
|
config.pselcts = p_comm_params->cts_pin_no;
|
|
config.pselrts = p_comm_params->rts_pin_no;
|
|
config.pselrxd = p_comm_params->rx_pin_no;
|
|
config.pseltxd = p_comm_params->tx_pin_no;
|
|
|
|
err_code = nrf_drv_uart_init(&app_uart_inst, &config, uart_event_handler);
|
|
VERIFY_SUCCESS(err_code);
|
|
m_rx_ovf = false;
|
|
|
|
// Turn on receiver if RX pin is connected
|
|
if (p_comm_params->rx_pin_no != UART_PIN_DISCONNECTED)
|
|
{
|
|
#ifdef UARTE_PRESENT
|
|
if (!config.use_easy_dma)
|
|
#endif
|
|
{
|
|
nrf_drv_uart_rx_enable(&app_uart_inst);
|
|
}
|
|
|
|
return nrf_drv_uart_rx(&app_uart_inst, rx_buffer,1);
|
|
}
|
|
else
|
|
{
|
|
return NRF_SUCCESS;
|
|
}
|
|
}
|
|
|
|
|
|
uint32_t app_uart_flush(void)
|
|
{
|
|
uint32_t err_code;
|
|
|
|
err_code = app_fifo_flush(&m_rx_fifo);
|
|
VERIFY_SUCCESS(err_code);
|
|
|
|
err_code = app_fifo_flush(&m_tx_fifo);
|
|
VERIFY_SUCCESS(err_code);
|
|
|
|
return NRF_SUCCESS;
|
|
}
|
|
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
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(&app_uart_inst))
|
|
{
|
|
// 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(&app_uart_inst, tx_buffer, 1);
|
|
}
|
|
}
|
|
}
|
|
return err_code;
|
|
}
|
|
|
|
|
|
uint32_t app_uart_close(void)
|
|
{
|
|
nrf_drv_uart_uninit(&app_uart_inst);
|
|
return NRF_SUCCESS;
|
|
}
|
|
#endif //NRF_MODULE_ENABLED(APP_UART)
|