C PIC32 USART_BufferAddRead lost bytes - c

Question

in my project I need to connect over UART a PIC32MZ2048EFH144 and an external device. I set the USART peripheral in this way using Harmony v1.1:
CONFIG_USE_DRV_USART=y
CONFIG_DRV_USART_DRIVER_MODE="STATIC"
CONFIG_DRV_USART_INTERRUPT_MODE=y
CONFIG_DRV_USART_BYTE_MODEL_SUPPORT=n
CONFIG_DRV_USART_READ_WRITE_MODEL_SUPPORT=n
CONFIG_DRV_USART_BUFFER_QUEUE_SUPPORT=y
CONFIG_DRV_USART_SUPPORT_TRANSMIT_DMA=n
CONFIG_DRV_USART_SUPPORT_RECEIVE_DMA=n
CONFIG_DRV_USART_INSTANCES_NUMBER=2
CONFIG_DRV_USART_CLIENTS_NUMBER=2
CONFIG_DRV_USART_PERIPHERAL_ID_IDX1="USART_ID_4"
CONFIG_DRV_USART_BAUD_RATE_IDX1=9600
CONFIG_DRV_USART_XMIT_INT_PRIORITY_IDX1="INT_PRIORITY_LEVEL1"
CONFIG_DRV_USART_XMIT_INT_SUB_PRIORITY_IDX1="INT_SUBPRIORITY_LEVEL0"
CONFIG_DRV_USART_RCV_INT_PRIORITY_IDX1="INT_PRIORITY_LEVEL1"
CONFIG_DRV_USART_RCV_INT_SUB_PRIORITY_IDX1="INT_SUBPRIORITY_LEVEL0"
CONFIG_DRV_USART_ERR_INT_PRIORITY_IDX1="INT_PRIORITY_LEVEL1"
CONFIG_DRV_USART_ERR_INT_SUB_PRIORITY_IDX1="INT_SUBPRIORITY_LEVEL0"
CONFIG_DRV_USART_OPER_MODE_IDX1="DRV_USART_OPERATION_MODE_NORMAL"
CONFIG_DRV_USART_INIT_FLAG_WAKE_ON_START_IDX1=n
CONFIG_DRV_USART_INIT_FLAG_AUTO_BAUD_IDX1=n
CONFIG_DRV_USART_INIT_FLAG_STOP_IN_IDLE_IDX1=n
CONFIG_DRV_USART_LINE_CNTRL_IDX1="DRV_USART_LINE_CONTROL_8NONE1"
CONFIG_DRV_USART_HANDSHAKE_MODE_IDX1="DRV_USART_HANDSHAKE_NONE"
CONFIG_DRV_USART_XMIT_QUEUE_SIZE_IDX1=10
CONFIG_DRV_USART_RCV_QUEUE_SIZE_IDX1=10
CONFIG_DRV_USART_STATIC_RX_MODES_IDX1="USART_HANDSHAKE_MODE_FLOW_CONTROL"
CONFIG_DRV_USART_STATIC_OP_MODES_IDX1="USART_ENABLE_TX_RX_USED"
CONFIG_DRV_USART_STATIC_LINECONTROL_MODES_IDX1="USART_8N1"
CONFIG_DRV_USART_STATIC_TX_ENABLE_IDX1=y
CONFIG_DRV_USART_STATIC_RX_ENABLE_IDX1=y
CONFIG_DRV_USART_STATIC_TX_INTR_MODES_IDX1="USART_TRANSMIT_FIFO_NOT_FULL"
CONFIG_DRV_USART_STATIC_RX_INTR_MODES_IDX1="USART_RECEIVE_FIFO_ONE_CHAR"
At the start, the external device sends a wake-up message that I receive correctly and reply to with a wake-up ack.
After this sequence, I send a requestDevID ... at this point I have some trouble. Through the oscilloscope, I can see that the external device answers correctly to this request but in my code I don't get the whole message.
The answer is: 0xFA 0xFF 0x01 0x04 0x07 0x78 0x26 0x1A 0x3D
What I see (when I stop the debug) is: 0x78 0x26 0x1A 0x3D 0x07
My code is as follow:
void mti710USART1BufferHandler(DRV_USART_BUFFER_EVENT bufferEvent, DRV_USART_BUFFER_HANDLE hBufferEvent, uintptr_t context){
switch(bufferEvent){
case DRV_USART_BUFFER_EVENT_COMPLETE:{
if (context == 1){
// to-do
flag = 1;
countFlag += 1;
}
break;
case DRV_USART_BUFFER_EVENT_ERROR:{
if (context == 1){
// to-do
flag = -1;
}
}
break;
case DRV_USART_BUFFER_EVENT_ABORT:
break;
default:
break;
}
}
bool mti710Initialize(MTi710INSInitDriver_t mti710Init){
mtiData.dvrMTi710INSIndex = mti710Init.dvrMTi710INSIndex;
mtiData.drvUART.handle = DRV_HANDLE_INVALID;
mtiData.drvUART.baudrate = 115200;
memset(&mtiData.drvUART.TX.buffer, 0x00, sizeof(mtiData.drvUART.TX.buffer));
memset(&mtiData.drvUART.RX.buffer, 0x00, sizeof(mtiData.drvUART.RX.buffer));
mtiData.drvUART.handle = DRV_USART_Open(mtiData.dvrMTi710INSIndex, DRV_IO_INTENT_READWRITE | DRV_IO_INTENT_NONBLOCKING);
if (mtiData.drvUART.handle != DRV_HANDLE_INVALID) {
if (mti710SetBaudrate(mtiData.drvUART.handle, mtiData.drvUART.baudrate)){
DRV_USART_BufferEventHandlerSet(mtiData.drvUART.handle, mti710USART1BufferHandler, (uintptr_t) 1);
mtiData.drvMti710INSState = MTi710INS_STATE_IDLE;
return true;
}
}
return false;
}
static void UARTRead(uint8_t* readBuffer, uint32_t bufferSize){
USART_ReceiverOverrunErrorClear_Default(DRV_USART_INDEX_1);
while (DRV_USART_ClientStatus(mtiData.drvUART.handle) != DRV_USART_CLIENT_STATUS_READY);
DRV_USART_BufferAddRead(mtiData.drvUART.handle, &(mtiData.drvUART.RX.bufferHandle), readBuffer, bufferSize);
}
...
...
uint32_t mti710ReadDeviceID(struct XbusParser* parser, const uint32_t timeout_us){
struct XbusMessage requestId = {XMID_ReqDid, 0, NULL};
mtiData.drvMti710INSState = MTi710INS_REQ_READ_ID;
if (flag == 0){
mti710WriteData(&requestId);
flag = 0;
}
mti710ReadData(9);
if (flag == 1){
XbusParser_parseBuffer(parser, (uint8_t*)&mtiData.drvUART.RX.buffer[0], sizeof(mtiData.drvUART.RX.buffer));
flag = 0;
return parser->currentMessage.mid == XMID_DeviceId ? (uint32_t)parser->currentMessage.data : -1;
} else {
return -1;
}
}
Any idea of my mistakes?
regards,
Vincenzo.

Answer 1

First thing:
When you read a hardware register, like the UART RX register, from within your application code, you must disable the UART RX interrupt.
The UART RX register is a shared resource.
UART RX register is shared by the the application code, (executed in background), and the interrupt code (executed in foreground).
If you don't disable the UART RX interrupt than your application code might be interrupted in the middle of the reading and get errors.
Shared resources must be read this way:
char a;
uart__disable_rx_interrupt(); // Begin of critical section
a = UART_RX_REGISTER;
uart__enable_rx_interrupt(); // End of critical section
Yet:
The application code should not disable too frequently the UART RX interrupt because the UART interface may miss some incoming data.
It happened to me back in 1996.
The ideal code application code would be at 9600 Baudrate:
char a;
sleep(100); // 100 ms
uart__disable_rx_interrupt(); // Begin of critical section
a = UART_RX_REGISTER;
uart__enable_rx_interrupt(); // End of critical section
printf(a);
One last thing;
Often, data are placed in a ring buffer
sleep(100); // 100 ms
uart__disable_rx_interrupt(); // Begin of critical section
a = UART_RX_REGISTER;
uart__write_in_ring_buffer(a);
uart__enable_rx_interrupt(); // End of critical section
uart__write_in_ring_buffer(&ch);
printf(ch);
I suggest you to read Jean Labrosse's book: "https://www.amazon.it/Embedded-Systems-Building-Blocks-Ready/dp/0879304405"
Study the UART device driver which Jean wrote making use of ring buffer.