How to code the STM32 serial port to receive messages more efficiently

Abstract
This article introduces the design of a circular queue data structure to achieve more stable serial port message reception and effectively prevent packet loss. I

have been studying multi-rotor aircraft and other things during this period. I haven't updated my blog. If I don't stick to it, I'm afraid it will be abandoned.

In the previous article, I simply implemented the parsing of the MAVLink protocol, demonstrated the execution of corresponding event processing according to the designed commands, and added CRC verification to achieve more stable communication. However, at the end of the above article, it was mentioned that when a packet is parsed and the corresponding event is processed, new data cannot be received until the event processing is completed and the Msg_Rev.Get state is set to RECEIVING before new data can be received. At this time, when event processing takes a certain amount of time and new data is continuously sent, it is easy to cause data loss.

How to improve the efficiency of serial port communication and avoid packet loss?

In order to improve efficiency, the first thing to think of is to use DMA. However, after consideration, it is found that the received data packets are not fixed; and even if DMA is used, if the MAVLink receive buffer is still designed to receive only one message size, the packet loss problem will still exist.

So I wonder if there is a way to implement it with software. It is like opening a cache space, putting the continuously received data there, and the packet parsing function can take out certain data from it one by one for processing. In this way, as long as the design is reasonable, the packet loss caused by software blocking can be easily solved. So what kind of cache should be designed? In fact, it is easy to think of a queue (first-in-first-out feature), and in order to use space more effectively and reasonably, the data structure of a circular queue will come to mind.

First of all, let's talk about the data structure design and the insertion and deletion operations. I won't say much. The code is as follows:

#define MAX_QUEUE_LEN (4096) // 4K
#define RW_OK 0
#define FULL_ERROR 1
#define EMPTY_ERROR 2

typedef uint8_t boolean;

typedef struct
{
    u16 MemFrontSendIndex ;
    u16 MemRearRecvIndex ;
    u16 MemLength ;
    u8 MemDataBuf[MAX_QUEUE_LEN];
} Queue_Mem_Struct , * Queue_Mem_Struct_p ;

Queue_Mem_Struct Queue_Recv ;

boolean QueueMemDataInsert(u8 data)
{
    if (MAX_QUEUE_LEN == Queue_Recv.MemLength)
    {
        return FULL_ERROR;
    }
    else
    {
        Queue_Recv.MemDataBuf[Queue_Recv.MemRearRecvIndex] = data;
        // if(++Queue_Recv.MemRearRecvIndex >= MAX_QUEUE_LEN){Queue_Recv.MemRearRecvIndex = 0;}
        Queue_Recv.MemRearRecvIndex = (Queue_Recv.MemRearRecv Index + 1) % MAX_QUEUE_LEN;
        Queue_Recv.MemLength ++ ;
        return RW_OK;
    }
}

boolean QueueMemDataDel(u8 *data)
{
    if (0 == Queue_Recv.MemLength)
    {
        return EMPTY_ERROR;
    }
    else
    {
        *data = Queue_Recv.MemDataBuf[Queue_Recv.MemFrontSendIndex] ;
        Queue_Recv.MemFrontSendIndex = (Queue_Recv.MemFrontSendIndex + 1) % MAX_QUEUE_LEN;
        Queue_Recv.MemLength -- ;
        return RW_OK;
    }
}

In this way, the data received by the serial port can be filled into the buffer Queue_Recv.MemDataBuf in sequence through the QueueMemDataInsert function. When processing, the QueueMemDataDel function is called to extract the corresponding number of data for processing. This avoids the problem of packet loss caused by the inability to receive data at the same time during the entire processing process. Of course, at this time, it is necessary to ensure that the data in the buffer is processed in time, otherwise, especially when the amount of data is large, after the queue is filled, it will cause the data to be unable to be filled in.

In addition, it will be found that the above design can be combined with the DMA method. If the design is good, the STM32 utilization and system operation efficiency can be further greatly improved!