rtc, keeping time

2 files changed, 1429 insertions, 0 deletions

diff --git a/drivers_nrf/uart/nrf_drv_uart.c b/drivers_nrf/uart/nrf_drv_uart.c
new file mode 100644
index 0000000..38ac5ae
--- /dev/null
+++ b/drivers_nrf/uart/nrf_drv_uart.c
@@ -0,0 +1,986 @@
+/**
+ * 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(UART)
+#include "nrf_drv_uart.h"
+#include "nrf_assert.h"
+#include "nrf_drv_common.h"
+#include "nrf_gpio.h"
+#include "app_util_platform.h"
+
+#define NRF_LOG_MODULE_NAME "UART"
+
+#if UART_CONFIG_LOG_ENABLED
+#define NRF_LOG_LEVEL       UART_CONFIG_LOG_LEVEL
+#define NRF_LOG_INFO_COLOR  UART_CONFIG_INFO_COLOR
+#define NRF_LOG_DEBUG_COLOR UART_CONFIG_DEBUG_COLOR
+#define EVT_TO_STR(event)   (event == NRF_UART_EVENT_ERROR ? "NRF_UART_EVENT_ERROR" : "UNKNOWN EVENT")
+#else //UART_CONFIG_LOG_ENABLED
+#define EVT_TO_STR(event)   ""
+#define NRF_LOG_LEVEL       0
+#endif //UART_CONFIG_LOG_ENABLED
+#include "nrf_log.h"
+#include "nrf_log_ctrl.h"
+
+#if (defined(UARTE_IN_USE) && defined(UART_IN_USE))
+    // UARTE and UART combined
+    #define CODE_FOR_UARTE(code) if (m_cb[p_instance->drv_inst_idx].use_easy_dma) { code }
+    #define CODE_FOR_UARTE_INT(idx, code) if (m_cb[idx].use_easy_dma) { code }
+    #define CODE_FOR_UART(code)   else { code }
+#elif (defined(UARTE_IN_USE) && !defined(UART_IN_USE))
+    // UARTE only
+    #define CODE_FOR_UARTE(code) { code }
+    #define CODE_FOR_UARTE_INT(idx, code) { code }
+    #define CODE_FOR_UART(code)
+#elif (!defined(UARTE_IN_USE) && defined(UART_IN_USE))
+    // UART only
+    #define CODE_FOR_UARTE(code)
+    #define CODE_FOR_UARTE_INT(idx, code)
+    #define CODE_FOR_UART(code) { code }
+#else
+    #error "Wrong configuration."
+#endif
+
+#define TX_COUNTER_ABORT_REQ_VALUE 256
+
+typedef struct
+{
+    void                   * p_context;
+    nrf_uart_event_handler_t handler;
+    uint8_t          const * p_tx_buffer;
+    uint8_t                * p_rx_buffer;
+    uint8_t                * p_rx_secondary_buffer;
+    volatile uint16_t        tx_counter;
+    uint8_t                  tx_buffer_length;
+    uint8_t                  rx_buffer_length;
+    uint8_t                  rx_secondary_buffer_length;
+    volatile uint8_t         rx_counter;
+    bool                     rx_enabled;
+    nrf_drv_state_t          state;
+#if (defined(UARTE_IN_USE) && defined(UART_IN_USE))
+    bool                     use_easy_dma;
+#endif
+} uart_control_block_t;
+
+static uart_control_block_t m_cb[UART_ENABLED_COUNT];
+
+__STATIC_INLINE void apply_config(nrf_drv_uart_t const * p_instance, nrf_drv_uart_config_t const * p_config)
+{
+    if (p_config->pseltxd != NRF_UART_PSEL_DISCONNECTED)
+    {
+        nrf_gpio_pin_set(p_config->pseltxd);
+        nrf_gpio_cfg_output(p_config->pseltxd);
+    }
+    if (p_config->pselrxd != NRF_UART_PSEL_DISCONNECTED)
+    {
+        nrf_gpio_cfg_input(p_config->pselrxd, NRF_GPIO_PIN_NOPULL);
+    }
+
+    CODE_FOR_UARTE
+    (
+        nrf_uarte_baudrate_set(p_instance->reg.p_uarte, (nrf_uarte_baudrate_t)p_config->baudrate);
+        nrf_uarte_configure(p_instance->reg.p_uarte, (nrf_uarte_parity_t)p_config->parity,
+                            (nrf_uarte_hwfc_t)p_config->hwfc);
+        nrf_uarte_txrx_pins_set(p_instance->reg.p_uarte, p_config->pseltxd, p_config->pselrxd);
+        if (p_config->hwfc == NRF_UART_HWFC_ENABLED)
+        {
+            if (p_config->pselcts != NRF_UART_PSEL_DISCONNECTED)
+            {
+                nrf_gpio_cfg_input(p_config->pselcts, NRF_GPIO_PIN_NOPULL);
+            }
+            if (p_config->pselrts != NRF_UART_PSEL_DISCONNECTED)
+            {
+                nrf_gpio_pin_set(p_config->pselrts);
+                nrf_gpio_cfg_output(p_config->pselrts);
+            }
+            nrf_uarte_hwfc_pins_set(p_instance->reg.p_uarte, p_config->pselrts, p_config->pselcts);
+        }
+    )
+    CODE_FOR_UART
+    (
+        nrf_uart_baudrate_set(p_instance->reg.p_uart, p_config->baudrate);
+        nrf_uart_configure(p_instance->reg.p_uart, p_config->parity, p_config->hwfc);
+        nrf_uart_txrx_pins_set(p_instance->reg.p_uart, p_config->pseltxd, p_config->pselrxd);
+        if (p_config->hwfc == NRF_UART_HWFC_ENABLED)
+        {
+            if (p_config->pselcts != NRF_UART_PSEL_DISCONNECTED)
+            {
+                nrf_gpio_cfg_input(p_config->pselcts, NRF_GPIO_PIN_NOPULL);
+            }
+            if (p_config->pselrts != NRF_UART_PSEL_DISCONNECTED)
+            {
+                nrf_gpio_pin_set(p_config->pselrts);
+                nrf_gpio_cfg_output(p_config->pselrts);
+            }
+            nrf_uart_hwfc_pins_set(p_instance->reg.p_uart, p_config->pselrts, p_config->pselcts);
+        }
+    )
+}
+
+__STATIC_INLINE void interrupts_enable(const nrf_drv_uart_t * p_instance, uint8_t interrupt_priority)
+{
+    CODE_FOR_UARTE
+    (
+        nrf_uarte_event_clear(p_instance->reg.p_uarte, NRF_UARTE_EVENT_ENDRX);
+        nrf_uarte_event_clear(p_instance->reg.p_uarte, NRF_UARTE_EVENT_ENDTX);
+        nrf_uarte_event_clear(p_instance->reg.p_uarte, NRF_UARTE_EVENT_ERROR);
+        nrf_uarte_event_clear(p_instance->reg.p_uarte, NRF_UARTE_EVENT_RXTO);
+        nrf_uarte_int_enable(p_instance->reg.p_uarte, NRF_UARTE_INT_ENDRX_MASK |
+                                         NRF_UARTE_INT_ENDTX_MASK |
+                                         NRF_UARTE_INT_ERROR_MASK |
+                                         NRF_UARTE_INT_RXTO_MASK);
+        nrf_drv_common_irq_enable(nrf_drv_get_IRQn((void *)p_instance->reg.p_uarte), interrupt_priority);
+    )
+    CODE_FOR_UART
+    (
+        nrf_uart_event_clear(p_instance->reg.p_uart, NRF_UART_EVENT_TXDRDY);
+        nrf_uart_event_clear(p_instance->reg.p_uart, NRF_UART_EVENT_RXTO);
+        nrf_uart_int_enable(p_instance->reg.p_uart, NRF_UART_INT_MASK_TXDRDY |
+                                       NRF_UART_INT_MASK_RXTO);
+        nrf_drv_common_irq_enable(nrf_drv_get_IRQn((void *)p_instance->reg.p_uart), interrupt_priority);
+    )
+}
+
+__STATIC_INLINE void interrupts_disable(const nrf_drv_uart_t * p_instance)
+{
+    CODE_FOR_UARTE
+    (
+        nrf_uarte_int_disable(p_instance->reg.p_uarte, NRF_UARTE_INT_ENDRX_MASK |
+                                          NRF_UARTE_INT_ENDTX_MASK |
+                                          NRF_UARTE_INT_ERROR_MASK |
+                                          NRF_UARTE_INT_RXTO_MASK);
+        nrf_drv_common_irq_disable(nrf_drv_get_IRQn((void *)p_instance->reg.p_uarte));
+    )
+    CODE_FOR_UART
+    (
+        nrf_uart_int_disable(p_instance->reg.p_uart, NRF_UART_INT_MASK_RXDRDY |
+                                        NRF_UART_INT_MASK_TXDRDY |
+                                        NRF_UART_INT_MASK_ERROR  |
+                                        NRF_UART_INT_MASK_RXTO);
+        nrf_drv_common_irq_disable(nrf_drv_get_IRQn((void *)p_instance->reg.p_uart));
+    )
+
+}
+
+__STATIC_INLINE void pins_to_default(const nrf_drv_uart_t * p_instance)
+{
+    /* Reset pins to default states */
+    uint32_t txd;
+    uint32_t rxd;
+    uint32_t rts;
+    uint32_t cts;
+
+    CODE_FOR_UARTE
+    (
+        txd = nrf_uarte_tx_pin_get(p_instance->reg.p_uarte);
+        rxd = nrf_uarte_rx_pin_get(p_instance->reg.p_uarte);
+        rts = nrf_uarte_rts_pin_get(p_instance->reg.p_uarte);
+        cts = nrf_uarte_cts_pin_get(p_instance->reg.p_uarte);
+        nrf_uarte_txrx_pins_disconnect(p_instance->reg.p_uarte);
+        nrf_uarte_hwfc_pins_disconnect(p_instance->reg.p_uarte);
+    )
+    CODE_FOR_UART
+    (
+        txd = nrf_uart_tx_pin_get(p_instance->reg.p_uart);
+        rxd = nrf_uart_rx_pin_get(p_instance->reg.p_uart);
+        rts = nrf_uart_rts_pin_get(p_instance->reg.p_uart);
+        cts = nrf_uart_cts_pin_get(p_instance->reg.p_uart);
+        nrf_uart_txrx_pins_disconnect(p_instance->reg.p_uart);
+        nrf_uart_hwfc_pins_disconnect(p_instance->reg.p_uart);
+    )
+
+    if (txd != NRF_UART_PSEL_DISCONNECTED)
+    {
+        nrf_gpio_cfg_default(txd);
+    }
+
+    if (rxd != NRF_UART_PSEL_DISCONNECTED)
+    {
+        nrf_gpio_cfg_default(rxd);
+    }
+
+    if (cts != NRF_UART_PSEL_DISCONNECTED)
+    {
+        nrf_gpio_cfg_default(cts);
+    }
+
+    if (rts != NRF_UART_PSEL_DISCONNECTED)
+    {
+        nrf_gpio_cfg_default(rts);
+    }
+
+}
+
+__STATIC_INLINE void uart_enable(const nrf_drv_uart_t * p_instance)
+{
+    CODE_FOR_UARTE(nrf_uarte_enable(p_instance->reg.p_uarte);)
+    CODE_FOR_UART(nrf_uart_enable(p_instance->reg.p_uart););
+}
+
+__STATIC_INLINE void uart_disable(const nrf_drv_uart_t * p_instance)
+{
+    CODE_FOR_UARTE(nrf_uarte_disable(p_instance->reg.p_uarte);)
+    CODE_FOR_UART(nrf_uart_disable(p_instance->reg.p_uart););
+}
+
+ret_code_t nrf_drv_uart_init(const nrf_drv_uart_t * p_instance, nrf_drv_uart_config_t const * p_config,
+                             nrf_uart_event_handler_t event_handler)
+{
+    ASSERT(p_config);
+    uart_control_block_t * p_cb = &m_cb[p_instance->drv_inst_idx];
+    ret_code_t err_code = NRF_SUCCESS;
+
+    if (p_cb->state != NRF_DRV_STATE_UNINITIALIZED)
+    {
+        err_code = NRF_ERROR_INVALID_STATE;
+        NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+        return err_code;
+    }
+
+#if (defined(UARTE_IN_USE) && defined(UART_IN_USE))
+    p_cb->use_easy_dma = p_config->use_easy_dma;
+#endif
+    apply_config(p_instance, p_config);
+
+    p_cb->handler = event_handler;
+    p_cb->p_context = p_config->p_context;
+
+    if (p_cb->handler)
+    {
+        interrupts_enable(p_instance, p_config->interrupt_priority);
+    }
+
+    uart_enable(p_instance);
+    p_cb->rx_buffer_length = 0;
+    p_cb->rx_secondary_buffer_length = 0;
+    p_cb->tx_buffer_length = 0;
+    p_cb->state = NRF_DRV_STATE_INITIALIZED;
+    p_cb->rx_enabled = false;
+    NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+    return err_code;
+}
+
+void nrf_drv_uart_uninit(const nrf_drv_uart_t * p_instance)
+{
+    uart_control_block_t * p_cb = &m_cb[p_instance->drv_inst_idx];
+
+    uart_disable(p_instance);
+
+    if (p_cb->handler)
+    {
+        interrupts_disable(p_instance);
+    }
+
+    pins_to_default(p_instance);
+
+    p_cb->state = NRF_DRV_STATE_UNINITIALIZED;
+    p_cb->handler = NULL;
+    NRF_LOG_INFO("Instance uninitialized: %d.\r\n", p_instance->drv_inst_idx);
+}
+
+#if defined(UART_IN_USE)
+__STATIC_INLINE void tx_byte(NRF_UART_Type * p_uart, uart_control_block_t * p_cb)
+{
+    nrf_uart_event_clear(p_uart, NRF_UART_EVENT_TXDRDY);
+    uint8_t txd = p_cb->p_tx_buffer[p_cb->tx_counter];
+    p_cb->tx_counter++;
+    nrf_uart_txd_set(p_uart, txd);
+}
+
+__STATIC_INLINE ret_code_t nrf_drv_uart_tx_for_uart(const nrf_drv_uart_t * p_instance)
+{
+    uart_control_block_t * p_cb = &m_cb[p_instance->drv_inst_idx];
+    ret_code_t err_code = NRF_SUCCESS;
+
+    nrf_uart_event_clear(p_instance->reg.p_uart, NRF_UART_EVENT_TXDRDY);
+    nrf_uart_task_trigger(p_instance->reg.p_uart, NRF_UART_TASK_STARTTX);
+
+    tx_byte(p_instance->reg.p_uart, p_cb);
+
+    if (p_cb->handler == NULL)
+    {
+        while (p_cb->tx_counter < (uint16_t) p_cb->tx_buffer_length)
+        {
+            while (!nrf_uart_event_check(p_instance->reg.p_uart, NRF_UART_EVENT_TXDRDY) &&
+                    p_cb->tx_counter != TX_COUNTER_ABORT_REQ_VALUE)
+            {
+            }
+            if (p_cb->tx_counter != TX_COUNTER_ABORT_REQ_VALUE)
+            {
+                tx_byte(p_instance->reg.p_uart, p_cb);
+            }
+        }
+
+        if (p_cb->tx_counter == TX_COUNTER_ABORT_REQ_VALUE)
+        {
+            err_code = NRF_ERROR_FORBIDDEN;
+        }
+        else
+        {
+            while (!nrf_uart_event_check(p_instance->reg.p_uart, NRF_UART_EVENT_TXDRDY))
+            {
+            }
+            nrf_uart_task_trigger(p_instance->reg.p_uart, NRF_UART_TASK_STOPTX);
+        }
+        p_cb->tx_buffer_length = 0;
+    }
+
+    NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+    return err_code;
+}
+#endif
+
+#if defined(UARTE_IN_USE)
+__STATIC_INLINE ret_code_t nrf_drv_uart_tx_for_uarte(const nrf_drv_uart_t * p_instance)
+{
+    uart_control_block_t * p_cb = &m_cb[p_instance->drv_inst_idx];
+    ret_code_t err_code = NRF_SUCCESS;
+
+    nrf_uarte_event_clear(p_instance->reg.p_uarte, NRF_UARTE_EVENT_ENDTX);
+    nrf_uarte_event_clear(p_instance->reg.p_uarte, NRF_UARTE_EVENT_TXSTOPPED);
+    nrf_uarte_tx_buffer_set(p_instance->reg.p_uarte, p_cb->p_tx_buffer, p_cb->tx_buffer_length);
+    nrf_uarte_task_trigger(p_instance->reg.p_uarte, NRF_UARTE_TASK_STARTTX);
+
+    if (p_cb->handler == NULL)
+    {
+        bool endtx;
+        bool txstopped;
+        do
+        {
+            endtx     = nrf_uarte_event_check(p_instance->reg.p_uarte, NRF_UARTE_EVENT_ENDTX);
+            txstopped = nrf_uarte_event_check(p_instance->reg.p_uarte, NRF_UARTE_EVENT_TXSTOPPED);
+        }
+        while ((!endtx) && (!txstopped));
+
+        if (txstopped)
+        {
+            err_code = NRF_ERROR_FORBIDDEN;
+        }
+        p_cb->tx_buffer_length = 0;
+    }
+
+    NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+    return err_code;
+}
+#endif
+
+ret_code_t nrf_drv_uart_tx(const nrf_drv_uart_t * p_instance, uint8_t const * const p_data, uint8_t length)
+{
+    uart_control_block_t * p_cb = &m_cb[p_instance->drv_inst_idx];
+    ASSERT(p_cb->state == NRF_DRV_STATE_INITIALIZED);
+    ASSERT(length>0);
+    ASSERT(p_data);
+
+    ret_code_t err_code;
+
+    CODE_FOR_UARTE
+    (
+        // EasyDMA requires that transfer buffers are placed in DataRAM,
+        // signal error if the are not.
+        if (!nrf_drv_is_in_RAM(p_data))
+        {
+            err_code = NRF_ERROR_INVALID_ADDR;
+            NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+            return err_code;
+        }
+    )
+
+    if (nrf_drv_uart_tx_in_progress(p_instance))
+    {
+        err_code = NRF_ERROR_BUSY;
+        NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+        return err_code;
+    }
+    p_cb->tx_buffer_length = length;
+    p_cb->p_tx_buffer      = p_data;
+    p_cb->tx_counter       = 0;
+
+    NRF_LOG_INFO("Transfer tx_len: %d.\r\n", p_cb->tx_buffer_length);
+    NRF_LOG_DEBUG("Tx data:\r\n");
+    NRF_LOG_HEXDUMP_DEBUG((uint8_t *)p_cb->p_tx_buffer, p_cb->tx_buffer_length * sizeof(p_cb->p_tx_buffer));
+
+    CODE_FOR_UARTE
+    (
+        return nrf_drv_uart_tx_for_uarte(p_instance);
+    )
+    CODE_FOR_UART
+    (
+        return nrf_drv_uart_tx_for_uart(p_instance);
+    )
+}
+
+bool nrf_drv_uart_tx_in_progress(const nrf_drv_uart_t * p_instance)
+{
+    return (m_cb[p_instance->drv_inst_idx].tx_buffer_length != 0);
+}
+
+#if defined(UART_IN_USE)
+__STATIC_INLINE void rx_enable(const nrf_drv_uart_t * p_instance)
+{
+    nrf_uart_event_clear(p_instance->reg.p_uart, NRF_UART_EVENT_ERROR);
+    nrf_uart_event_clear(p_instance->reg.p_uart, NRF_UART_EVENT_RXDRDY);
+    nrf_uart_task_trigger(p_instance->reg.p_uart, NRF_UART_TASK_STARTRX);
+}
+
+__STATIC_INLINE void rx_byte(NRF_UART_Type * p_uart, uart_control_block_t * p_cb)
+{
+    if (!p_cb->rx_buffer_length)
+    {
+        nrf_uart_event_clear(p_uart, NRF_UART_EVENT_RXDRDY);
+        // Byte received when buffer is not set - data lost.
+        (void) nrf_uart_rxd_get(p_uart);
+        return;
+    }
+    nrf_uart_event_clear(p_uart, NRF_UART_EVENT_RXDRDY);
+    p_cb->p_rx_buffer[p_cb->rx_counter] = nrf_uart_rxd_get(p_uart);
+    p_cb->rx_counter++;
+}
+
+__STATIC_INLINE ret_code_t nrf_drv_uart_rx_for_uart(const nrf_drv_uart_t * p_instance, uint8_t * p_data, uint8_t length, bool second_buffer)
+{
+    ret_code_t err_code;
+
+    uart_control_block_t * p_cb = &m_cb[p_instance->drv_inst_idx];
+
+    if ((!p_cb->rx_enabled) && (!second_buffer))
+    {
+        rx_enable(p_instance);
+    }
+
+    if (p_cb->handler == NULL)
+    {
+        nrf_uart_event_clear(p_instance->reg.p_uart, NRF_UART_EVENT_RXTO);
+
+        bool rxrdy;
+        bool rxto;
+        bool error;
+        do
+        {
+            do
+            {
+                error = nrf_uart_event_check(p_instance->reg.p_uart, NRF_UART_EVENT_ERROR);
+                rxrdy = nrf_uart_event_check(p_instance->reg.p_uart, NRF_UART_EVENT_RXDRDY);
+                rxto  = nrf_uart_event_check(p_instance->reg.p_uart, NRF_UART_EVENT_RXTO);
+            } while ((!rxrdy) && (!rxto) && (!error));
+
+            if (error || rxto)
+            {
+                break;
+            }
+            rx_byte(p_instance->reg.p_uart, p_cb);
+        } while (p_cb->rx_buffer_length > p_cb->rx_counter);
+
+        p_cb->rx_buffer_length = 0;
+        if (error)
+        {
+            err_code = NRF_ERROR_INTERNAL;
+            NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+            return err_code;
+        }
+
+        if (rxto)
+        {
+            err_code = NRF_ERROR_FORBIDDEN;
+            NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+            return err_code;
+        }
+
+        if (p_cb->rx_enabled)
+        {
+            nrf_uart_task_trigger(p_instance->reg.p_uart, NRF_UART_TASK_STARTRX);
+        }
+        else
+        {
+            // Skip stopping RX if driver is forced to be enabled.
+            nrf_uart_task_trigger(p_instance->reg.p_uart, NRF_UART_TASK_STOPRX);
+        }
+    }
+    else
+    {
+        nrf_uart_int_enable(p_instance->reg.p_uart, NRF_UART_INT_MASK_RXDRDY | NRF_UART_INT_MASK_ERROR);
+    }
+    err_code = NRF_SUCCESS;
+    NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+    return err_code;
+}
+#endif
+
+#if defined(UARTE_IN_USE)
+__STATIC_INLINE ret_code_t nrf_drv_uart_rx_for_uarte(const nrf_drv_uart_t * p_instance, uint8_t * p_data, uint8_t length, bool second_buffer)
+{
+    ret_code_t err_code = NRF_SUCCESS;
+    nrf_uarte_event_clear(p_instance->reg.p_uarte, NRF_UARTE_EVENT_ENDRX);
+    nrf_uarte_event_clear(p_instance->reg.p_uarte, NRF_UARTE_EVENT_RXTO);
+    nrf_uarte_rx_buffer_set(p_instance->reg.p_uarte, p_data, length);
+    if (!second_buffer)
+    {
+        nrf_uarte_task_trigger(p_instance->reg.p_uarte, NRF_UARTE_TASK_STARTRX);
+    }
+    else
+    {
+        nrf_uarte_shorts_enable(p_instance->reg.p_uarte, NRF_UARTE_SHORT_ENDRX_STARTRX);
+    }
+
+    if (m_cb[p_instance->drv_inst_idx].handler == NULL)
+    {
+        bool endrx;
+        bool rxto;
+        bool error;
+        do {
+            endrx  = nrf_uarte_event_check(p_instance->reg.p_uarte, NRF_UARTE_EVENT_ENDRX);
+            rxto   = nrf_uarte_event_check(p_instance->reg.p_uarte, NRF_UARTE_EVENT_RXTO);
+            error  = nrf_uarte_event_check(p_instance->reg.p_uarte, NRF_UARTE_EVENT_ERROR);
+        }while ((!endrx) && (!rxto) && (!error));
+
+        m_cb[p_instance->drv_inst_idx].rx_buffer_length = 0;
+
+        if (error)
+        {
+            err_code = NRF_ERROR_INTERNAL;
+        }
+
+        if (rxto)
+        {
+            err_code = NRF_ERROR_FORBIDDEN;
+        }
+    }
+    else
+    {
+        nrf_uarte_int_enable(p_instance->reg.p_uarte, NRF_UARTE_INT_ERROR_MASK | NRF_UARTE_INT_ENDRX_MASK);
+    }
+    NRF_LOG_INFO("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+    return err_code;
+}
+#endif
+
+ret_code_t nrf_drv_uart_rx(const nrf_drv_uart_t * p_instance, uint8_t * p_data, uint8_t length)
+{
+    uart_control_block_t * p_cb = &m_cb[p_instance->drv_inst_idx];
+
+    ASSERT(m_cb[p_instance->drv_inst_idx].state == NRF_DRV_STATE_INITIALIZED);
+    ASSERT(length>0);
+
+    ret_code_t err_code;
+
+    CODE_FOR_UARTE
+    (
+        // EasyDMA requires that transfer buffers are placed in DataRAM,
+        // signal error if the are not.
+        if (!nrf_drv_is_in_RAM(p_data))
+        {
+            err_code = NRF_ERROR_INVALID_ADDR;
+            NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+            return err_code;
+        }
+    )
+
+    bool second_buffer = false;
+
+    if (p_cb->handler)
+    {
+        CODE_FOR_UARTE
+        (
+            nrf_uarte_int_disable(p_instance->reg.p_uarte, NRF_UARTE_INT_ERROR_MASK | NRF_UARTE_INT_ENDRX_MASK);
+        )
+        CODE_FOR_UART
+        (
+            nrf_uart_int_disable(p_instance->reg.p_uart, NRF_UART_INT_MASK_RXDRDY | NRF_UART_INT_MASK_ERROR);
+        )
+    }
+    if (p_cb->rx_buffer_length != 0)
+    {
+        if (p_cb->rx_secondary_buffer_length != 0)
+        {
+            if (p_cb->handler)
+            {
+                CODE_FOR_UARTE
+                (
+                    nrf_uarte_int_enable(p_instance->reg.p_uarte, NRF_UARTE_INT_ERROR_MASK | NRF_UARTE_INT_ENDRX_MASK);
+                )
+                CODE_FOR_UART
+                (
+                    nrf_uart_int_enable(p_instance->reg.p_uart, NRF_UART_INT_MASK_RXDRDY | NRF_UART_INT_MASK_ERROR);
+                )
+            }
+            err_code = NRF_ERROR_BUSY;
+            NRF_LOG_WARNING("Function: %s, error code: %s.\r\n", (uint32_t)__func__, (uint32_t)NRF_LOG_ERROR_STRING_GET(err_code));
+            return err_code;
+        }
+        second_buffer = true;
+    }
+
+    if (!second_buffer)
+    {
+        p_cb->rx_buffer_length = length;
+        p_cb->p_rx_buffer      = p_data;
+        p_cb->rx_counter       = 0;
+        p_cb->rx_secondary_buffer_length = 0;
+    }
+    else
+    {
+        p_cb->p_rx_secondary_buffer = p_data;
+        p_cb->rx_secondary_buffer_length = length;
+    }
+
+    NRF_LOG_INFO("Transfer rx_len: %d.\r\n", length);
+
+
+    CODE_FOR_UARTE
+    (
+        return nrf_drv_uart_rx_for_uarte(p_instance, p_data, length, second_buffer);
+    )
+    CODE_FOR_UART
+    (
+        return nrf_drv_uart_rx_for_uart(p_instance, p_data, length, second_buffer);
+    )
+}
+
+bool nrf_drv_uart_rx_ready(nrf_drv_uart_t const * p_instance)
+{
+    CODE_FOR_UARTE
+    (
+        return nrf_uarte_event_check(p_instance->reg.p_uarte, NRF_UARTE_EVENT_ENDRX);
+    )
+    CODE_FOR_UART
+    (
+        return nrf_uart_event_check(p_instance->reg.p_uart, NRF_UART_EVENT_RXDRDY);
+    )
+}
+
+void nrf_drv_uart_rx_enable(const nrf_drv_uart_t * p_instance)
+{
+    //Easy dma mode does not support enabling receiver without setting up buffer.
+    CODE_FOR_UARTE
+    (
+        ASSERT(false);
+    )
+    CODE_FOR_UART
+    (
+        if (!m_cb[p_instance->drv_inst_idx].rx_enabled)
+        {
+            rx_enable(p_instance);
+            m_cb[p_instance->drv_inst_idx].rx_enabled = true;
+        }
+    )
+}
+
+void nrf_drv_uart_rx_disable(const nrf_drv_uart_t * p_instance)
+{
+    //Easy dma mode does not support enabling receiver without setting up buffer.
+    CODE_FOR_UARTE
+    (
+        ASSERT(false);
+    )
+    CODE_FOR_UART
+    (
+        nrf_uart_task_trigger(p_instance->reg.p_uart, NRF_UART_TASK_STOPRX);
+        m_cb[p_instance->drv_inst_idx].rx_enabled = false;
+    )
+}
+
+uint32_t nrf_drv_uart_errorsrc_get(const nrf_drv_uart_t * p_instance)
+{
+    uint32_t errsrc;
+    CODE_FOR_UARTE
+    (
+        nrf_uarte_event_clear(p_instance->reg.p_uarte, NRF_UARTE_EVENT_ERROR);
+        errsrc = nrf_uarte_errorsrc_get_and_clear(p_instance->reg.p_uarte);
+    )
+    CODE_FOR_UART
+    (
+        nrf_uart_event_clear(p_instance->reg.p_uart, NRF_UART_EVENT_ERROR);
+        errsrc = nrf_uart_errorsrc_get_and_clear(p_instance->reg.p_uart);
+    )
+    return errsrc;
+}
+
+__STATIC_INLINE void rx_done_event(uart_control_block_t * p_cb, uint8_t bytes, uint8_t * p_data)
+{
+    nrf_drv_uart_event_t event;
+
+    event.type             = NRF_DRV_UART_EVT_RX_DONE;
+    event.data.rxtx.bytes  = bytes;
+    event.data.rxtx.p_data = p_data;
+
+    p_cb->handler(&event, p_cb->p_context);
+}
+
+__STATIC_INLINE void tx_done_event(uart_control_block_t * p_cb, uint8_t bytes)
+{
+    nrf_drv_uart_event_t event;
+
+    event.type             = NRF_DRV_UART_EVT_TX_DONE;
+    event.data.rxtx.bytes  = bytes;
+    event.data.rxtx.p_data = (uint8_t *)p_cb->p_tx_buffer;
+
+    p_cb->tx_buffer_length = 0;
+
+    p_cb->handler(&event, p_cb->p_context);
+}
+
+void nrf_drv_uart_tx_abort(const nrf_drv_uart_t * p_instance)
+{
+    uart_control_block_t * p_cb = &m_cb[p_instance->drv_inst_idx];
+
+    CODE_FOR_UARTE
+    (
+        nrf_uarte_event_clear(p_instance->reg.p_uarte, NRF_UARTE_EVENT_TXSTOPPED);
+        nrf_uarte_task_trigger(p_instance->reg.p_uarte, NRF_UARTE_TASK_STOPTX);
+        if (p_cb->handler == NULL)
+        {
+            while (!nrf_uarte_event_check(p_instance->reg.p_uarte, NRF_UARTE_EVENT_TXSTOPPED));
+        }
+    )
+    CODE_FOR_UART
+    (
+        nrf_uart_task_trigger(p_instance->reg.p_uart, NRF_UART_TASK_STOPTX);
+        if (p_cb->handler)
+        {
+            tx_done_event(p_cb, p_cb->tx_counter);
+        }
+        else
+        {
+            p_cb->tx_counter       = TX_COUNTER_ABORT_REQ_VALUE;
+        }
+    )
+    NRF_LOG_INFO("TX transaction aborted.\r\n");
+}
+
+void nrf_drv_uart_rx_abort(const nrf_drv_uart_t * p_instance)
+{
+    CODE_FOR_UARTE
+    (
+        nrf_uarte_task_trigger(p_instance->reg.p_uarte, NRF_UARTE_TASK_STOPRX);
+    )
+    CODE_FOR_UART
+    (
+        nrf_uart_int_disable(p_instance->reg.p_uart, NRF_UART_INT_MASK_RXDRDY | NRF_UART_INT_MASK_ERROR);
+        nrf_uart_task_trigger(p_instance->reg.p_uart, NRF_UART_TASK_STOPRX);
+    )
+    NRF_LOG_INFO("RX transaction aborted.\r\n");
+}
+
+
+#if defined(UART_IN_USE)
+__STATIC_INLINE void uart_irq_handler(NRF_UART_Type * p_uart, uart_control_block_t * p_cb)
+{
+    if (nrf_uart_int_enable_check(p_uart, NRF_UART_INT_MASK_ERROR) &&
+        nrf_uart_event_check(p_uart, NRF_UART_EVENT_ERROR))
+    {
+        nrf_drv_uart_event_t event;
+        nrf_uart_event_clear(p_uart, NRF_UART_EVENT_ERROR);
+        NRF_LOG_DEBUG("Event: %s.\r\n", (uint32_t)EVT_TO_STR(NRF_UART_EVENT_ERROR));
+        nrf_uart_int_disable(p_uart, NRF_UART_INT_MASK_RXDRDY | NRF_UART_INT_MASK_ERROR);
+        if (!p_cb->rx_enabled)
+        {
+            nrf_uart_task_trigger(p_uart, NRF_UART_TASK_STOPRX);
+        }
+        event.type                   = NRF_DRV_UART_EVT_ERROR;
+        event.data.error.error_mask  = nrf_uart_errorsrc_get_and_clear(p_uart);
+        event.data.error.rxtx.bytes  = p_cb->rx_buffer_length;
+        event.data.error.rxtx.p_data = p_cb->p_rx_buffer;
+
+        //abort transfer
+        p_cb->rx_buffer_length = 0;
+        p_cb->rx_secondary_buffer_length = 0;
+
+        p_cb->handler(&event,p_cb->p_context);
+    }
+    else if (nrf_uart_int_enable_check(p_uart, NRF_UART_INT_MASK_RXDRDY) &&
+             nrf_uart_event_check(p_uart, NRF_UART_EVENT_RXDRDY))
+    {
+        rx_byte(p_uart, p_cb);
+        if (p_cb->rx_buffer_length == p_cb->rx_counter)
+        {
+            if (p_cb->rx_secondary_buffer_length)
+            {
+                uint8_t * p_data     = p_cb->p_rx_buffer;
+                uint8_t   rx_counter = p_cb->rx_counter;
+
+                //Switch to secondary buffer.
+                p_cb->rx_buffer_length = p_cb->rx_secondary_buffer_length;
+                p_cb->p_rx_buffer = p_cb->p_rx_secondary_buffer;
+                p_cb->rx_secondary_buffer_length = 0;
+                p_cb->rx_counter = 0;
+                rx_done_event(p_cb, rx_counter, p_data);
+            }
+            else
+            {
+                if (!p_cb->rx_enabled)
+                {
+                    nrf_uart_task_trigger(p_uart, NRF_UART_TASK_STOPRX);
+                }
+                nrf_uart_int_disable(p_uart, NRF_UART_INT_MASK_RXDRDY | NRF_UART_INT_MASK_ERROR);
+                p_cb->rx_buffer_length = 0;
+                rx_done_event(p_cb, p_cb->rx_counter, p_cb->p_rx_buffer);
+            }
+        }
+    }
+
+    if (nrf_uart_event_check(p_uart, NRF_UART_EVENT_TXDRDY))
+    {
+        if (p_cb->tx_counter < (uint16_t) p_cb->tx_buffer_length)
+        {
+            tx_byte(p_uart, p_cb);
+        }
+        else
+        {
+            nrf_uart_event_clear(p_uart, NRF_UART_EVENT_TXDRDY);
+            if (p_cb->tx_buffer_length)
+            {
+                tx_done_event(p_cb, p_cb->tx_buffer_length);
+            }
+        }
+    }
+
+    if (nrf_uart_event_check(p_uart, NRF_UART_EVENT_RXTO))
+    {
+        nrf_uart_event_clear(p_uart, NRF_UART_EVENT_RXTO);
+
+        // RXTO event may be triggered as a result of abort call. In th
+        if (p_cb->rx_enabled)
+        {
+            nrf_uart_task_trigger(p_uart, NRF_UART_TASK_STARTRX);
+        }
+        if (p_cb->rx_buffer_length)
+        {
+            p_cb->rx_buffer_length = 0;
+            rx_done_event(p_cb, p_cb->rx_counter, p_cb->p_rx_buffer);
+        }
+    }
+}
+#endif
+
+#if defined(UARTE_IN_USE)
+__STATIC_INLINE void uarte_irq_handler(NRF_UARTE_Type * p_uarte, uart_control_block_t * p_cb)
+{
+    if (nrf_uarte_event_check(p_uarte, NRF_UARTE_EVENT_ERROR))
+    {
+        nrf_drv_uart_event_t event;
+
+        nrf_uarte_event_clear(p_uarte, NRF_UARTE_EVENT_ERROR);
+
+        event.type                   = NRF_DRV_UART_EVT_ERROR;
+        event.data.error.error_mask  = nrf_uarte_errorsrc_get_and_clear(p_uarte);
+        event.data.error.rxtx.bytes  = nrf_uarte_rx_amount_get(p_uarte);
+        event.data.error.rxtx.p_data = p_cb->p_rx_buffer;
+
+        //abort transfer
+        p_cb->rx_buffer_length = 0;
+        p_cb->rx_secondary_buffer_length = 0;
+
+        p_cb->handler(&event, p_cb->p_context);
+    }
+    else if (nrf_uarte_event_check(p_uarte, NRF_UARTE_EVENT_ENDRX))
+    {
+        nrf_uarte_event_clear(p_uarte, NRF_UARTE_EVENT_ENDRX);
+        uint8_t amount = nrf_uarte_rx_amount_get(p_uarte);
+        // If the transfer was stopped before completion, amount of transfered bytes
+        // will not be equal to the buffer length. Interrupted trunsfer is ignored.
+        if (amount == p_cb->rx_buffer_length)
+        {
+            if (p_cb->rx_secondary_buffer_length)
+            {
+                uint8_t * p_data = p_cb->p_rx_buffer;
+                nrf_uarte_shorts_disable(p_uarte, NRF_UARTE_SHORT_ENDRX_STARTRX);
+                p_cb->rx_buffer_length = p_cb->rx_secondary_buffer_length;
+                p_cb->p_rx_buffer = p_cb->p_rx_secondary_buffer;
+                p_cb->rx_secondary_buffer_length = 0;
+                rx_done_event(p_cb, amount, p_data);
+            }
+            else
+            {
+                p_cb->rx_buffer_length = 0;
+                rx_done_event(p_cb, amount, p_cb->p_rx_buffer);
+            }
+        }
+    }
+
+    if (nrf_uarte_event_check(p_uarte, NRF_UARTE_EVENT_RXTO))
+    {
+        nrf_uarte_event_clear(p_uarte, NRF_UARTE_EVENT_RXTO);
+        if (p_cb->rx_buffer_length)
+        {
+            p_cb->rx_buffer_length = 0;
+            rx_done_event(p_cb, nrf_uarte_rx_amount_get(p_uarte), p_cb->p_rx_buffer);
+        }
+    }
+
+    if (nrf_uarte_event_check(p_uarte, NRF_UARTE_EVENT_ENDTX))
+    {
+        nrf_uarte_event_clear(p_uarte, NRF_UARTE_EVENT_ENDTX);
+        if (p_cb->tx_buffer_length)
+        {
+            tx_done_event(p_cb, nrf_uarte_tx_amount_get(p_uarte));
+        }
+    }
+}
+#endif
+
+#if UART0_ENABLED
+void UART0_IRQHandler(void)
+{
+    CODE_FOR_UARTE_INT
+    (
+        UART0_INSTANCE_INDEX,
+        uarte_irq_handler(NRF_UARTE0, &m_cb[UART0_INSTANCE_INDEX]);
+    )
+    CODE_FOR_UART
+    (
+        uart_irq_handler(NRF_UART0, &m_cb[UART0_INSTANCE_INDEX]);
+    )
+}
+#endif
+
+#if UART1_ENABLED
+void UARTE1_IRQHandler(void)
+{
+    CODE_FOR_UARTE_INT
+    (
+        UART1_INSTANCE_INDEX,
+        uarte_irq_handler(NRF_UARTE1, &m_cb[UART1_INSTANCE_INDEX]);
+    )
+    CODE_FOR_UART
+    (
+        uart_irq_handler(NRF_UART1, &m_cb[UART1_INSTANCE_INDEX]);
+    )
+}
+#endif
+#endif //NRF_MODULE_ENABLED(UART)
diff --git a/drivers_nrf/uart/nrf_drv_uart.h b/drivers_nrf/uart/nrf_drv_uart.h
new file mode 100644
index 0000000..88739df
--- /dev/null
+++ b/drivers_nrf/uart/nrf_drv_uart.h
@@ -0,0 +1,443 @@
+/**
+ * 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.
+ * 
+ */
+/**@file
+ * @addtogroup nrf_uart UART driver and HAL
+ * @ingroup nrf_drivers
+ * @brief UART API.
+ * @details The UART driver provides APIs for utilizing the UART peripheral.
+ *
+ * @defgroup nrf_drv_uart UART driver
+ * @{
+ * @ingroup  nrf_uart
+ *
+ * @brief    UART driver.
+ */
+
+#ifndef NRF_DRV_UART_H
+#define NRF_DRV_UART_H
+
+#include "nrf_uart.h"
+#ifdef UARTE_PRESENT
+#include "nrf_uarte.h"
+#endif
+
+#include "sdk_errors.h"
+#include "sdk_config.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UART1_ENABLED
+#define UART1_ENABLED 0
+#endif
+
+#ifndef UART0_ENABLED
+#define UART0_ENABLED 0
+#endif
+
+#define UART0_INSTANCE_INDEX 0
+#define UART1_INSTANCE_INDEX UART0_ENABLED
+#define UART_ENABLED_COUNT UART0_ENABLED + UART1_ENABLED
+
+#if defined(UARTE_PRESENT)
+    #define NRF_DRV_UART_PERIPHERAL(id)           \
+        (CONCAT_3(UART, id, _CONFIG_USE_EASY_DMA) == 1 ? \
+            (void *)CONCAT_2(NRF_UARTE, id)       \
+          : (void *)CONCAT_2(NRF_UART, id))
+#else
+    #define NRF_DRV_UART_PERIPHERAL(id)  (void *)CONCAT_2(NRF_UART, id)
+#endif
+
+// This set of macros makes it possible to exclude parts of code, when one type
+// of supported peripherals is not used.
+
+#if defined(UARTE_PRESENT)
+
+#if (UART_EASY_DMA_SUPPORT == 1)
+#define UARTE_IN_USE
+#endif
+
+#if (UART_LEGACY_SUPPORT == 1)
+#define UART_IN_USE
+#endif
+
+#if (UART_ENABLED == 1) && ((!defined(UARTE_IN_USE) && !defined(UART_IN_USE)) || ((UART_EASY_DMA_SUPPORT == 0) && (UART_LEGACY_SUPPORT == 0)))
+#error "Illegal settings in uart module!"
+#endif
+
+#elif defined(UART_PRESENT)
+#define UART_IN_USE
+#endif
+
+/**
+ * @brief Structure for the UART driver instance.
+ */
+typedef struct
+{
+    union
+    {
+#if (defined(UARTE_IN_USE))
+    NRF_UARTE_Type * p_uarte; ///< Pointer to a structure with UARTE registers.
+#endif
+#if (defined(UART_IN_USE) || (UART_ENABLED == 0))
+    NRF_UART_Type * p_uart;   ///< Pointer to a structure with UART registers.
+#endif
+    } reg;
+    uint8_t drv_inst_idx;     ///< Driver instance index.
+} nrf_drv_uart_t;
+
+/**
+ * @brief Macro for creating an UART driver instance.
+ */
+#define NRF_DRV_UART_INSTANCE(id)                            \
+{                                                            \
+    .reg          = {NRF_DRV_UART_PERIPHERAL(id)},           \
+    .drv_inst_idx = CONCAT_3(UART, id, _INSTANCE_INDEX),\
+}
+
+/**
+ * @brief Types of UART driver events.
+ */
+typedef enum
+{
+    NRF_DRV_UART_EVT_TX_DONE, ///< Requested TX transfer completed.
+    NRF_DRV_UART_EVT_RX_DONE, ///< Requested RX transfer completed.
+    NRF_DRV_UART_EVT_ERROR,   ///< Error reported by UART peripheral.
+} nrf_drv_uart_evt_type_t;
+
+/**@brief Structure for UART configuration. */
+typedef struct
+{
+    uint32_t            pseltxd;            ///< TXD pin number.
+    uint32_t            pselrxd;            ///< RXD pin number.
+    uint32_t            pselcts;            ///< CTS pin number.
+    uint32_t            pselrts;            ///< RTS pin number.
+    void *              p_context;          ///< Context passed to interrupt handler.
+    nrf_uart_hwfc_t     hwfc;               ///< Flow control configuration.
+    nrf_uart_parity_t   parity;             ///< Parity configuration.
+    nrf_uart_baudrate_t baudrate;           ///< Baudrate.
+    uint8_t             interrupt_priority; ///< Interrupt priority.
+#ifdef UARTE_PRESENT
+    bool                use_easy_dma;
+#endif
+} nrf_drv_uart_config_t;
+
+/**@brief UART default configuration. */
+#ifdef UARTE_PRESENT
+#if !UART_LEGACY_SUPPORT
+#define DEFAULT_CONFIG_USE_EASY_DMA true
+#elif !UART_EASY_DMA_SUPPORT
+#define DEFAULT_CONFIG_USE_EASY_DMA false
+#else
+#define DEFAULT_CONFIG_USE_EASY_DMA UART0_USE_EASY_DMA
+#endif
+#define NRF_DRV_UART_DEFAULT_CONFIG                                                   \
+    {                                                                                 \
+        .pseltxd            = NRF_UART_PSEL_DISCONNECTED,                             \
+        .pselrxd            = NRF_UART_PSEL_DISCONNECTED,                             \
+        .pselcts            = NRF_UART_PSEL_DISCONNECTED,                             \
+        .pselrts            = NRF_UART_PSEL_DISCONNECTED,                             \
+        .p_context          = NULL,                                                   \
+        .hwfc               = (nrf_uart_hwfc_t)UART_DEFAULT_CONFIG_HWFC,              \
+        .parity             = (nrf_uart_parity_t)UART_DEFAULT_CONFIG_PARITY,          \
+        .baudrate           = (nrf_uart_baudrate_t)UART_DEFAULT_CONFIG_BAUDRATE,      \
+        .interrupt_priority = UART_DEFAULT_CONFIG_IRQ_PRIORITY,                       \
+        .use_easy_dma       = true                                                    \
+    }
+#else
+#define NRF_DRV_UART_DEFAULT_CONFIG                                                   \
+    {                                                                                 \
+        .pseltxd            = NRF_UART_PSEL_DISCONNECTED,                             \
+        .pselrxd            = NRF_UART_PSEL_DISCONNECTED,                             \
+        .pselcts            = NRF_UART_PSEL_DISCONNECTED,                             \
+        .pselrts            = NRF_UART_PSEL_DISCONNECTED,                             \
+        .p_context          = NULL,                                                   \
+        .hwfc               = (nrf_uart_hwfc_t)UART_DEFAULT_CONFIG_HWFC,              \
+        .parity             = (nrf_uart_parity_t)UART_DEFAULT_CONFIG_PARITY,          \
+        .baudrate           = (nrf_uart_baudrate_t)UART_DEFAULT_CONFIG_BAUDRATE,      \
+        .interrupt_priority = UART_DEFAULT_CONFIG_IRQ_PRIORITY,                       \
+    }
+#endif
+
+/**@brief Structure for UART transfer completion event. */
+typedef struct
+{
+    uint8_t * p_data; ///< Pointer to memory used for transfer.
+    uint8_t   bytes;  ///< Number of bytes transfered.
+} nrf_drv_uart_xfer_evt_t;
+
+/**@brief Structure for UART error event. */
+typedef struct
+{
+    nrf_drv_uart_xfer_evt_t rxtx;      ///< Transfer details includes number of bytes transfered.
+    uint32_t                error_mask;///< Mask of error flags that generated the event.
+} nrf_drv_uart_error_evt_t;
+
+/**@brief Structure for UART event. */
+typedef struct
+{
+    nrf_drv_uart_evt_type_t type;      ///< Event type.
+    union
+    {
+        nrf_drv_uart_xfer_evt_t  rxtx; ///< Data provided for transfer completion events.
+        nrf_drv_uart_error_evt_t error;///< Data provided for error event.
+    } data;
+} nrf_drv_uart_event_t;
+
+/**
+ * @brief UART interrupt event handler.
+ *
+ * @param[in] p_event    Pointer to event structure. Event is allocated on the stack so it is available
+ *                       only within the context of the event handler.
+ * @param[in] p_context  Context passed to interrupt handler, set on initialization.
+ */
+typedef void (*nrf_uart_event_handler_t)(nrf_drv_uart_event_t * p_event, void * p_context);
+
+/**
+ * @brief Function for initializing the UART driver.
+ *
+ * This function configures and enables UART. After this function GPIO pins are controlled by UART.
+ *
+ * @param[in] p_instance    Pointer to the driver instance structure.
+ * @param[in] p_config      Initial configuration. Default configuration used if NULL.
+ * @param[in] event_handler Event handler provided by the user. If not provided driver works in
+ *                          blocking mode.
+ *
+ * @retval    NRF_SUCCESS             If initialization was successful.
+ * @retval    NRF_ERROR_INVALID_STATE If driver is already initialized.
+ */
+ret_code_t nrf_drv_uart_init(nrf_drv_uart_t const *        p_instance,
+                             nrf_drv_uart_config_t const * p_config,
+                             nrf_uart_event_handler_t      event_handler);
+
+/**
+ * @brief Function for uninitializing  the UART driver.
+ * @param[in] p_instance Pointer to the driver instance structure.
+ */
+void nrf_drv_uart_uninit(nrf_drv_uart_t const * p_instance);
+
+/**
+ * @brief Function for getting the address of a specific UART task.
+ *
+ * @param[in] p_instance Pointer to the driver instance structure.
+ * @param[in] task       Task.
+ *
+ * @return    Task address.
+ */
+__STATIC_INLINE uint32_t nrf_drv_uart_task_address_get(nrf_drv_uart_t const * p_instance,
+                                                       nrf_uart_task_t task);
+
+/**
+ * @brief Function for getting the address of a specific UART event.
+ *
+ * @param[in] p_instance Pointer to the driver instance structure.
+ * @param[in] event      Event.
+ *
+ * @return    Event address.
+ */
+__STATIC_INLINE uint32_t nrf_drv_uart_event_address_get(nrf_drv_uart_t const * p_instance,
+                                                        nrf_uart_event_t event);
+
+/**
+ * @brief Function for sending data over UART.
+ *
+ * If an event handler was provided in nrf_drv_uart_init() call, this function
+ * returns immediately and the handler is called when the transfer is done.
+ * Otherwise, the transfer is performed in blocking mode, i.e. this function
+ * returns when the transfer is finished. Blocking mode is not using interrupt so
+ * there is no context switching inside the function.
+ *
+ * @note Peripherals using EasyDMA (i.e. UARTE) require that the transfer buffers
+ *       are placed in the Data RAM region. If they are not and UARTE instance is
+ *       used, this function will fail with error code NRF_ERROR_INVALID_ADDR.
+ *
+ * @param[in] p_instance Pointer to the driver instance structure.
+ * @param[in] p_data     Pointer to data.
+ * @param[in] length     Number of bytes to send.
+ *
+ * @retval    NRF_SUCCESS            If initialization was successful.
+ * @retval    NRF_ERROR_BUSY         If driver is already transferring.
+ * @retval    NRF_ERROR_FORBIDDEN    If the transfer was aborted from a different context
+ *                                   (blocking mode only, also see @ref nrf_drv_uart_rx_disable).
+ * @retval    NRF_ERROR_INVALID_ADDR If p_data does not point to RAM buffer (UARTE only).
+ */
+ret_code_t nrf_drv_uart_tx(nrf_drv_uart_t const * p_instance,
+                           uint8_t const * const p_data, uint8_t length);
+
+/**
+ * @brief Function for checking if UART is currently transmitting.
+ *
+ * @param[in] p_instance Pointer to the driver instance structure.
+ *
+ * @retval true  If UART is transmitting.
+ * @retval false If UART is not transmitting.
+ */
+bool nrf_drv_uart_tx_in_progress(nrf_drv_uart_t const * p_instance);
+
+/**
+ * @brief Function for aborting any ongoing transmission.
+ * @note @ref NRF_DRV_UART_EVT_TX_DONE event will be generated in non-blocking mode. Event will
+ *       contain number of bytes sent until abort was called. If Easy DMA is not used event will be
+ *       called from the function context. If Easy DMA is used it will be called from UART interrupt
+ *       context.
+ *
+ * @param[in] p_instance Pointer to the driver instance structure.
+ */
+void nrf_drv_uart_tx_abort(nrf_drv_uart_t const * p_instance);
+
+/**
+ * @brief Function for receiving data over UART.
+ *
+ * If an event handler was provided in the nrf_drv_uart_init() call, this function
+ * returns immediately and the handler is called when the transfer is done.
+ * Otherwise, the transfer is performed in blocking mode, i.e. this function
+ * returns when the transfer is finished. Blocking mode is not using interrupt so
+ * there is no context switching inside the function.
+ * The receive buffer pointer is double buffered in non-blocking mode. The secondary
+ * buffer can be set immediately after starting the transfer and will be filled
+ * when the primary buffer is full. The double buffering feature allows
+ * receiving data continuously.
+ *
+ * @note Peripherals using EasyDMA (i.e. UARTE) require that the transfer buffers
+ *       are placed in the Data RAM region. If they are not and UARTE driver instance
+ *       is used, this function will fail with error code NRF_ERROR_INVALID_ADDR.
+ *
+ * @param[in] p_instance Pointer to the driver instance structure.
+ * @param[in] p_data     Pointer to data.
+ * @param[in] length     Number of bytes to receive.
+ *
+ * @retval    NRF_SUCCESS If initialization was successful.
+ * @retval    NRF_ERROR_BUSY If the driver is already receiving
+ *                           (and the secondary buffer has already been set
+ *                           in non-blocking mode).
+ * @retval    NRF_ERROR_FORBIDDEN If the transfer was aborted from a different context
+ *                               (blocking mode only, also see @ref nrf_drv_uart_rx_disable).
+ * @retval    NRF_ERROR_INTERNAL If UART peripheral reported an error.
+ * @retval    NRF_ERROR_INVALID_ADDR If p_data does not point to RAM buffer (UARTE only).
+ */
+ret_code_t nrf_drv_uart_rx(nrf_drv_uart_t const * p_instance,
+                           uint8_t * p_data, uint8_t length);
+
+
+
+/**
+ * @brief Function for testing the receiver state in blocking mode.
+ *
+ * @param[in] p_instance Pointer to the driver instance structure.
+ *
+ * @retval true  If the receiver has at least one byte of data to get.
+ * @retval false If the receiver is empty.
+ */
+bool nrf_drv_uart_rx_ready(nrf_drv_uart_t const * p_instance);
+
+/**
+ * @brief Function for enabling the receiver.
+ *
+ * UART has a 6-byte-long RX FIFO and it is used to store incoming data. If a user does not call the
+ * UART receive function before the FIFO is filled, an overrun error will appear. Enabling the receiver
+ * without specifying an RX buffer is supported only in UART mode (without Easy DMA). The receiver must be
+ * explicitly closed by the user @sa nrf_drv_uart_rx_disable. This function asserts if the mode is wrong.
+ *
+ * @param[in] p_instance Pointer to the driver instance structure.
+ */
+void nrf_drv_uart_rx_enable(nrf_drv_uart_t const * p_instance);
+
+/**
+ * @brief Function for disabling the receiver.
+ *
+ * This function must be called to close the receiver after it has been explicitly enabled by
+ * @sa nrf_drv_uart_rx_enable. The feature is supported only in UART mode (without Easy DMA). The function
+ * asserts if mode is wrong.
+ *
+ * @param[in] p_instance Pointer to the driver instance structure.
+ */
+void nrf_drv_uart_rx_disable(nrf_drv_uart_t const * p_instance);
+
+/**
+ * @brief Function for aborting any ongoing reception.
+ * @note @ref NRF_DRV_UART_EVT_RX_DONE event will be generated in non-blocking mode. The event will
+ *       contain the number of bytes received until abort was called. The event is called from UART interrupt
+ *       context.
+ *
+ * @param[in] p_instance Pointer to the driver instance structure.
+ */
+void nrf_drv_uart_rx_abort(nrf_drv_uart_t const * p_instance);
+
+/**
+ * @brief Function for reading error source mask. Mask contains values from @ref nrf_uart_error_mask_t.
+ * @note Function should be used in blocking mode only. In case of non-blocking mode, an error event is
+ *       generated. Function clears error sources after reading.
+ *
+ * @param[in] p_instance Pointer to the driver instance structure.
+ *
+ * @retval    Mask of reported errors.
+ */
+uint32_t nrf_drv_uart_errorsrc_get(nrf_drv_uart_t const * p_instance);
+
+
+#ifndef SUPPRESS_INLINE_IMPLEMENTATION
+__STATIC_INLINE uint32_t nrf_drv_uart_task_address_get(nrf_drv_uart_t const * p_instance,
+                                                       nrf_uart_task_t task)
+{
+#ifdef UART_IN_USE
+    return nrf_uart_task_address_get(p_instance->reg.p_uart, task);
+#else
+    return nrf_uarte_task_address_get(p_instance->reg.p_uarte, (nrf_uarte_task_t)task);
+#endif
+}
+
+__STATIC_INLINE uint32_t nrf_drv_uart_event_address_get(nrf_drv_uart_t const * p_instance,
+                                                        nrf_uart_event_t event)
+{
+#ifdef UART_IN_USE
+    return nrf_uart_event_address_get(p_instance->reg.p_uart, event);
+#else
+    return nrf_uarte_event_address_get(p_instance->reg.p_uarte, (nrf_uarte_event_t)event);
+#endif
+}
+#endif //SUPPRESS_INLINE_IMPLEMENTATION
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //NRF_DRV_UART_H
+/** @} */