UART read interrupt

Hi Harsha,

You should be able to set up the up the UART read mode to UART_MODE_CALLBACK like so:

    ...
    UART_Handle uart;
    UART_Params uartParams;
    ...
    UART_Params_init(&uartParams);
    ...
    uartParams.readMode = UART_MODE_CALLBACK; // sets up RX for callback mode
    uartParams.readCallback = myUART_readCallBack; // your callback function
    ...
    uart = UART_open(Board_UART0, &uartParams);
    ...

Your callback function prototype should look similar to this:

void myUART_readCallback(UART_Handle handle, void *ptr, size_t size);

The second argument should be the read buffer, and the third argument is the amount read.

Fair warning: in this mode, UART_read() will return immediately. Once it has completed, your callback function will be called. To kill a read in progress, you must call UART_readCancel(). Be careful with parallel reads as it will reset the UART status back to OK. Hope this helps.

Gilbert

I may have misinterpreted your original question, but what I showed you in my first post may still work. The callback is called upon the completion of UART_read(), so a call to UART_read() must be made first. Here is a small example that you can find in the TI Drivers API guide. This case will configure the UART to receive continously in UART_MODE_CALLBACK, 16 bytes at the time and transmit them back via UART TX. Note that UART_reads() inside the read callback are safe to perform.

#define MAX_NUM_RX_BYTES    1000   // Maximum RX bytes to receive in one go
#define MAX_NUM_TX_BYTES    1000   // Maximum TX bytes to send in one go
uint32_t wantedRxBytes;            // Number of bytes received so far
uint8_t rxBuf[MAX_NUM_RX_BYTES];   // Receive buffer
uint8_t txBuf[MAX_NUM_TX_BYTES];   // Transmit buffer
// Callback function
static void readCallback(UART_Handle handle, void *rxBuf, size_t size)
{
    // Copy bytes from RX buffer to TX buffer
    for(size_t i = 0; i < size; i++)
        txBuf[i] = ((uint8_t*)rxBuf)[i];
    // Echo the bytes received back to transmitter
    UART_write(handle, txBuf, size);
    // Start another read, with size the same as it was during first call to
    // UART_read()
    UART_read(handle, rxBuf, wantedRxBytes);
}
static void taskFxn(UArg a0, UArg a1)
{
    UART_Handle handle;
    UART_Params params;
    // Init UART and specify non-default parameters
    UART_Params_init(&params);
    params.baudRate      = 9600;
    params.writeDataMode = UART_DATA_BINARY;
    params.readMode      = UART_MODE_CALLBACK;
    params.readDataMode  = UART_DATA_BINARY;
    params.readCallback  = readCallback;
    // Open the UART and initiate the first read
    handle = UART_open(Board_UART, &params);
    wantedRxBytes = 16;
    int rxBytes = UART_read(handle, rxBuf, wantedRxBytes);
    while(true); // Wait forever
}

How are you interfacing with the CC2650? Are you using a different board or serial communication over USB?

Gilbert