Example serial_uartes does not work in SDK 15.3

[GaryD]

Hello,

I am in the process of integrating a project where I need 3 uarts to work concurrently in different configurations.  This will eventually migrate to an application where the nrf52840 will also serve as a beacon.

I have individually proven I can talk to and control each of the 3 peripherals over UART by using the ..examples/peripheral/uart example in sdk 15.3.  I am using the Segger development environment.

I was hoping it would be simple to migrate to controlling all three uart peripherals in a non-blocking mode using the serial_uartes example as a starting point.  My objective is to also include handlers that will capture and parse each uart receive port.

However, I cannot get the basic serial_uartes example to work in the first place.  I have read many of the other Devzone cases and do not see one that conclusively corrects the issue with the example.  

One of my peripherals works in handshake mode the other 2 are asynchronous.   I have also had some issues with getting handshake to function as expected (the nrf52840 must work as a DTE.  Can you tell me if the Nordic implementation  follows the "normal" set of rules as indicated below (except for the DTR) which I need to handle manually.

1.The data terminal equipment (DTE) puts the RTS line into the “On” state.

2.The data communications equipment (DCE) puts the CTS line into the “On” state.

3.The DTE puts the DTR line into the “On” state.

4.The DTR line remains in the “On” state while data is being transmitted.

I need to demo this capability to my customer as soon as possible since I have already been able to successfully talk to all three peripherals independently.  I have spent more than a week attempting to resolve this issue.

Thank you in advance for the normally quick responses from your support team.

[ovrebekk]

Hi Gary

Some work was done a while back to implement an additional UART using the PWM and SAADC peripherals for TX and RX. 

This gives you an additional UART assuming you can accept the limitations of this library, which only supports limited baudrate and no flow control or parity. 

To check it out please refer to the following case, which also lists all the limitations:
https://devzone.nordicsemi.com/f/nordic-q-a/49844/how-to-simulate-uart-with-gpio

For a full description of the flow control feature please refer to the Transmission and Reception chapters in the UARTE chapter in the datasheet. 

Essentially communication will only take place if both the RTS and CTS lines are asserted (low), and the RTS signal will be automatically de-asserted if you either stop the UART RX or if you only have 4 bytes left in the RX buffer (since some UART devices send a couple of bytes after the RTS line is de-asserted). 

Best regards
Torbjørn

[GaryD]

Thank you Torbjorn,

I worked through the corrections to the example mentioned above and have both UARTES working now.  That particular example uses polling.  Do you have and example UARTE receive handler that I could review.  I need to save the incoming stream of characters until I see a line termination (\r or \n) and then parse the line of data.  My application is low power so I cannot poll like the examples show.  

When I get to the requirement for the third serial line i will look at your suggestion for an additional UART function.  However, I can currently convert one of my serial interfaces into a TWI interface (the peripheral can handle either case but the manufacturer's examples use the UART functionality). 

I also plan to investigate deactivating one of the serials and activating it to my screen UART when I need to send data out of the port for display.  I can also do the same when I need to poll the screen for any fault information.  I believe I can just flip back and forth with different I/O lines by de-activating from one peripheral and activating on another.  Do you agree?

Would you mind clarifying what the purpose of the flush operation is for?  I cannot seem to find any documentation on it and I want to better understand it.  If I do not void the call for the flush, I sometimes get 0x0d errors (timeouts) on the flush operation.  If I just void it, it does not cause any issues but I would like to better understand why it is needed for every transaction with the serial UARTE transmit operation.

Thank you,

GaryD

[ovrebekk]

Hi Gary

Sorry for the slow response, I have been out on travel for a while. 

Yes, you should be able to dynamically re-allocate one hardware UART interface to two separate UART busses, as long as you only have to use one of them at a time. 

The flush operation allows you simulate a blocking UART write. A call to the flush function will not return until either the TX buffers are empty or the timeout is reached, which is good if you need to delay the code execution until the UART is done writing. 
It is not necessary to call this operation for the UART TX to start, and for most applications I would not expect this function to be necessary. 

I made a quick modification to the serial example to implement the event handler, and you will find the main file attached:

Fullscreen main.c Download

/**
 * Copyright (c) 2016 - 2019, 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 <stdint.h>
#include <stdbool.h>
#include <stddef.h>

#include "nrf.h"
#include "nrf_drv_clock.h"
#include "nrf_gpio.h"
#include "nrf_delay.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_drv_power.h"
#include "nrf_serial.h"
#include "app_timer.h"


#include "app_error.h"
#include "app_util.h"
#include "boards.h"

/** @file
 * @defgroup nrf_serial_example main.c
 * @{
 * @ingroup nrf_serial_example
 * @brief Example of @ref nrf_serial usage. Simple loopback.
 *
 */

#define OP_QUEUES_SIZE          3
#define APP_TIMER_PRESCALER     NRF_SERIAL_APP_TIMER_PRESCALER

static void sleep_handler(void)
{
    __WFE();
    __SEV();
    __WFE();
}

NRF_SERIAL_DRV_UART_CONFIG_DEF(m_uart0_drv_config,
                      RX_PIN_NUMBER, TX_PIN_NUMBER,
                      RTS_PIN_NUMBER, CTS_PIN_NUMBER,
                      NRF_UART_HWFC_DISABLED, NRF_UART_PARITY_EXCLUDED,
                      NRF_UART_BAUDRATE_115200,
                      UART_DEFAULT_CONFIG_IRQ_PRIORITY);

#define SERIAL_FIFO_TX_SIZE 32
#define SERIAL_FIFO_RX_SIZE 32

NRF_SERIAL_QUEUES_DEF(serial_queues, SERIAL_FIFO_TX_SIZE, SERIAL_FIFO_RX_SIZE);


#define SERIAL_BUFF_TX_SIZE 1
#define SERIAL_BUFF_RX_SIZE 1

NRF_SERIAL_UART_DEF(serial_uart, 0);

void serial_evt_handler(struct nrf_serial_s const * p_serial, nrf_serial_event_t event)
{
    char c;
    switch(event)
    {
        case NRF_SERIAL_EVENT_TX_DONE:   //!< Chunk of data has been sent.
            break;

        case NRF_SERIAL_EVENT_RX_DATA:   //!< New chunk of data has been received.
            nrf_serial_read(&serial_uart, &c, sizeof(c), NULL, 10);
            nrf_serial_write(&serial_uart, &c, sizeof(c), NULL, 0);
            break;
            
        case NRF_SERIAL_EVENT_DRV_ERR:   //!< Internal driver error.
            break;

        case NRF_SERIAL_EVENT_FIFO_ERR:  //!< RX FIFO overrun.
            break;
    }
}


NRF_SERIAL_BUFFERS_DEF(serial_buffs, SERIAL_BUFF_TX_SIZE, SERIAL_BUFF_RX_SIZE);

NRF_SERIAL_CONFIG_DEF(serial_config, NRF_SERIAL_MODE_IRQ,
                      &serial_queues, &serial_buffs, serial_evt_handler, sleep_handler);


int main(void)
{
    ret_code_t ret;

    ret = nrf_drv_clock_init();
    APP_ERROR_CHECK(ret);
    ret = nrf_drv_power_init(NULL);
    APP_ERROR_CHECK(ret);

    nrf_drv_clock_lfclk_request(NULL);
    ret = app_timer_init();
    APP_ERROR_CHECK(ret);

    // Initialize LEDs and buttons.
    bsp_board_init(BSP_INIT_LEDS | BSP_INIT_BUTTONS);

    ret = nrf_serial_init(&serial_uart, &m_uart0_drv_config, &serial_config);
    APP_ERROR_CHECK(ret);

    static char tx_message[] = "\r\nHello nrf_serial!\n\r";

    ret = nrf_serial_write(&serial_uart,
                           tx_message,
                           strlen(tx_message),
                           NULL,
                           NRF_SERIAL_MAX_TIMEOUT);
    APP_ERROR_CHECK(ret);

    while (true)
    {
#if 0
        char c;
        ret = nrf_serial_read(&serial_uart, &c, sizeof(c), NULL, 1000);
        if (ret != NRF_SUCCESS)
        {
            continue;
        }
        (void)nrf_serial_write(&serial_uart, &c, sizeof(c), NULL, 0);
        (void)nrf_serial_flush(&serial_uart, 0);
#endif   
    }
}

/** @} */

Best regards
Torbjørn

[GaryD]

Hi Torbjørn,

Unfortunately I had to move on to implement a different solution outside of Nordic.  My customer was not patient and this issue was not resolved in time.

Best regards,

GaryD

[ovrebekk]

Hi Gary

Sorry to hear that, I will consider the case closed then. 

Hopefully you will still keep us in mind for future projects ;)

Best regards
Torbjørn