/** * 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)