RE: problems with transferring large datasets from computer to nRF over UARTE

Susheel Nuguru — Wed, 11 Aug 2021 07:04:25 GMT

seems you have a good control on this ahjr, Please do care to come back here to update me with your findings. I am confident that the UART should function correctly (especially when you are seeing no errors) . Could be a race condition somewhere in the logic.

RE: problems with transferring large datasets from computer to nRF over UARTE

ahjr — Mon, 09 Aug 2021 14:33:43 GMT

Hi Susheel,

Thanks for responding. UART_BUF_SIZE is 1 in my code. Sorry about the confusion, if it were anything else your addition would be necessary. For UARTE errors: when I used certain baud rates (like 19200) I was seeing a 1 in the error register. Once I changed the baud I no longer saw any errors, even when bytes were missing.

I tried to simplify the code to try to isolate the problem. I removed the UART-based state machine and simply defaulted to the "load 64kB into RAM" state. Once it receives 64kB, it resets the index to 0 and waits for 64kB new bytes. I tried it around 250 times and I missed zero bytes (CRC checked as well). It's a temporary fix. I will continue to investigate the UART-based state machine. I know that the nRF can reliably receive 64kB over UART, and I know that the state machine works, but when I combine the two it breaks in ways that make no sense.

I will also try flow control. I have fairly robust error handling with CRC, but flow control can't hurt.

RE: problems with transferring large datasets from computer to nRF over UARTE

Susheel Nuguru — Mon, 09 Aug 2021 06:12:01 GMT

Hi Ahjr,

Thanks for clear description. Will definitely save us time as it is faster for me to understand the problem. Few thoughts while I am reading your information.

Not using flow control is ok as long as you have a solid error handling mechanism. It looks like all your ISR is doing at any error (EVENTS_ERROR) is that it is clearing that event and flushing RX. This flush will make you lose received bytes unless you have a mechanism to tell to the peer to retransmit those missed bytes. Also it would be interesting to see what error occurred (if any) before you flush out all bytes so that we might attempt to solve the source of this error.
You are using UARTE (EasyDMA), so unless you have UART_BUF_SIZE set to 1, your handling of data in the ISR is wrong. When you get EVENTS_ENDRX, it means that you have received UART_BUF_SIZE of new data in the receive buffer (which you set to uart_buf_DK_RX). So you need to extract and process that many bytes for every EVENTS_ENDRX. So your ISR event processing could be something like below

void UARTE0_UART0_IRQHandler(void) {

    uint8_t uart_rx_byte;
    uint8_t count;

    // debug
    app_dbg.num_ISR_UARTE0_UART0_IRQHandler++;

    if (NRF_UARTE0->EVENTS_ERROR == 0x00000001) {
        // clear the error and continue? (Susheel: This below code means loss of data)
        NRF_UARTE0->EVENTS_ERROR = 0x00000000;
        NRF_UARTE0->TASKS_FLUSHRX = 0x00000001;
        NRF_UARTE0->TASKS_STARTRX = 0x00000001;
    }

    if (NRF_UARTE0->EVENTS_ENDRX == 0x00000001) {
        // byte received from computer

        // clear
        NRF_UARTE0->EVENTS_ENDRX = 0x00000000;

        // debug
        app_dbg.num_ISR_UARTE0_UART0_IRQHandler_ENDRX++;

        count = UART_BUF_SIZE;
        
        while(count-- != 0)
        {
        if(app_vars.programmer_state == PROGRAMMER_WAIT_4_CMD_ST) {
                uart_rx_byte = app_vars.uart_buf_DK_RX[0];
                app_vars.uart_RX_command_buf[app_vars.uart_RX_command_idx++] = uart_rx_byte;

                if((uart_rx_byte=='\n')||(uart_rx_byte=='\r')) { // \r for debugging w/ putty, \n for the python scripts
                    app_vars.uart_RX_command_idx = 0; // reset index to receive the next command
                    if(memcmp(app_vars.uart_RX_command_buf,UART_TRANSFERSRAM,sizeof(UART_TRANSFERSRAM))==0) { // enter transfer SRAM state
                        app_vars.programmer_state = PROGRAMMER_SRAM_LD_ST;
                        app_vars.uart_RX_command_idx = 0;
                        print_sram_started_msg();
                    }
                    // else - erroneous command, clear the buffer and reset to default state
                    else {
                        memset(app_vars.uart_RX_command_buf,0,sizeof(app_vars.uart_RX_command_buf));
                        app_vars.uart_RX_command_idx = 0;
                        app_vars.programmer_state = PROGRAMMER_WAIT_4_CMD_ST;
                    }
                }
                else if (app_vars.uart_RX_command_idx > MAX_COMMAND_LEN) { // max length exceeded w/out return character, reset buffer
                    memset(app_vars.uart_RX_command_buf,0,sizeof(app_vars.uart_RX_command_buf));
                    app_vars.uart_RX_command_idx = 0;
                    app_vars.programmer_state = PROGRAMMER_WAIT_4_CMD_ST;
                }
            }
            else if (app_vars.programmer_state == PROGRAMMER_SRAM_LD_ST) {
                uart_rx_byte = app_vars.uart_buf_DK_RX[0];
                app_vars.instruction_memory[app_vars.uart_RX_command_idx++] = uart_rx_byte;
                if(app_vars.uart_RX_command_idx == MEM_SIZE) { // finished w/ the 64kB memory
                    // after loading memory - reset state, index, and command buffer
                    app_vars.programmer_state = PROGRAMMER_SRAM_LD_DONE;
                    print_sram_done_msg();
                    app_vars.programmer_state = PROGRAMMER_WAIT_4_CMD_ST;
                    app_vars.uart_RX_command_idx = 0;
                    memset(app_vars.uart_RX_command_buf,0,sizeof(app_vars.uart_RX_command_buf));
                }
            }
        }
    }
}