WO2019019295A1

WO2019019295A1 - Ring data buffering implementation method based on synchronization mechanism for embedded system

Info

Publication number: WO2019019295A1
Application number: PCT/CN2017/101335
Authority: WO
Inventors: 赖志威; 曾宪玮; 解亚琦
Original assignee: 广州路派电子科技有限公司
Priority date: 2017-07-26
Filing date: 2017-09-12
Publication date: 2019-01-31
Also published as: CN107368374A; CN107368374B

Abstract

Disclosed is a ring data buffering implementation method based on a synchronization mechanism for an embedded system, the method comprising: when data is written under a first working state, switching to a second working state; when data continues to be written under the second working state, if a buffer is filled with newly added data, entering a fourth working state; under the second working state, reading the data of the buffer, and if the size of the read data is smaller than the size of buffered data in the buffer, entering a third working state, otherwise, entering the fourth working state; and under the third working state, when data is read and no data in the buffer can be read, entering the first working state, and when the data is written into the buffer, if the buffer is filled with data through writing, entering the fourth working state. The method uses a semaphore synchronization mechanism built into an embedded operating system, an original ring buffer is stronger, a configurable and transplantable ring buffer is used, the method is applicable to different software systems and different hardware systems, and the requirements of practical application can be better met.

Description

Ring data buffer implementation method for embedded system based on synchronization mechanism

Technical field

The invention relates to a ring data buffer implementation method for an embedded system based on a synchronization mechanism.

Background technique

In embedded communication programs, there is often a scenario where the program needs to parse the received data while receiving data from the communication interface. The specific scenario is: embedded system in the system application of collecting and parsing car data, the system must collect data according to the real-time data to express to the user in a certain form, or make some logical operations based on the data, etc. Time-consuming work. Such scenarios generally have the following constraints:

1) Due to real-time requirements, it is necessary to read the data while parsing the data. The data cannot be parsed until the data is completely received, and the next frame data cannot be received after parsing one frame of data;

2) Data parsing requires compatibility performance and memory space utilization efficiency, especially in embedded system environments where memory and other resources are limited, so it is necessary to reduce direct copy between memory and allocate appropriate size cache space.

The above background application scenarios are usually implemented using the ring buffer method.

The general ring buffer implementation method is as follows: the ring buffer usually has a read pointer and a write pointer, the read pointer points to the readable data in the ring buffer, and the write pointer points to a writable buffer in the ring buffer, which is read by the mobile. The pointer and write pointer can be used to read and write data from the buffer.

1, 2 and 3 are schematic diagrams of the operation of a ring buffer. Figure 1 is the initial state of the ring buffer, you can see that both the read pointer and the write pointer point to the first buffer; Figure 2 is the case after adding a data to the ring buffer, you can see that the write pointer has moved To the position of data block 2, and the read pointer does not move; Figure 3 shows the state after the ring buffer has been read and added. It can be seen that two data have been added to the ring buffer and one data has been read.

The above is the basic implementation principle and model of the prior art ring buffer. There are many problems in practical applications: 1) The read pointer and the write pointer may overlap, which may result in the read data being inaccurate. Indeed; 2) when the speed at which the external module reads data from the cache cannot keep up with the speed of writing data to the cache, there will be a problem of discontinuity before and after the read data frame, for example, referring to the ring buffer in Figure 3 above. Suppose the read pointer is kept at position 2, the moment is defined as T0, and the write pointer is continuously incremented. When the write pointer has jumped from position 6 to number 1, the time is defined as T1, and then continues to increment. To position 4, the data at position 3 at time T1 is no longer the data at time T0; this situation is not allowed in applications where the requirement for maintaining the continuity of the acquired data frame is high; for example, In the application of communication between two relatively independent modules or systems, in order to ensure the accuracy and security of the data, the communication data is usually defined as the "frame header + data + checksum" format, and here " The frame header is usually split into two or more linked data and sent to another system, and the "checksum" is calculated according to one frame of data. The data sender and receiver are based on the "frame header". And "checksum" to judge the validity of the data, and to exclude the interference data; if such a communication method uses the above-mentioned defective ring buffer, the original continuity between many data frames and data It is possible that the system at the data receiving end may be corrupted and the communication data cannot be analyzed correctly and efficiently.

At present, there are literatures that use the software counter method to realize the read and write data to the ring buffer. The basic implementation principle is as follows: the position of the read pointer and the write pointer are simultaneously determined when reading data and writing data, so as to ensure that the read and write data does not occur. The above conflicts, from these two position differences, can be used to calculate how much space is left to write data; but such a structure will consume CPU resources because it has to perform logical judgment operations.

Summary of the invention

In view of the above problems in the prior art, an object of the present invention is to provide a ring data buffer implementation method for an embedded system based on a synchronization mechanism that avoids the above-mentioned technical drawbacks.

In order to achieve the above object, the technical solution provided by the present invention is as follows:

A method for implementing a ring data buffer based on a synchronization mechanism in an embedded system, comprising switching between four working states; the four working states are:

Working state 1: There is no readable data in the ring buffer;

Working state 2: There is sufficient memory in the ring buffer to store more data;

Working state three: sufficient data is buffered in the ring buffer;

Working state four: there is no writable buffer space in the ring buffer;

The switching process of the four working states is:

When the data is written in the working state, it switches to the working state 2;

When the working state 2 continues to write data, if the buffer is filled with the newly added data, it enters the working state 4, and if the newly added data does not fill the buffer, it remains in the working state 2;

In the working state 2, the data of the buffer is read. If the size of the read data is smaller than the size of the data buffered by the buffer, it enters the working state 3. If the size of the read data exceeds or equals the data buffered by the buffer, Go into work status four;

In the working state three, when reading data, when the buffer has no data to read, it enters the working state. When writing data to the buffer, if the buffer is full of data, it enters the working state four.

Further, when data is read in the ring buffer area in the working state, the ring buffer is processed according to the actual use requirement in two cases:

1) directly return a data with an error flag to the program that called the ring buffer;

2) The program hangs here for a period of time. When data is written to the ring buffer during this time period, the ring buffer will immediately return a unit size of cache data to the program that calls the ring buffer; Waiting for this time, no data is still written to the ring buffer, then the ring buffer returns a data with an error flag to the program that called the ring buffer.

Further, when the data is continuously written to the ring buffer area under the working state four, the structure is processed according to the actual use requirement in two cases:

2) The program hangs here for a period of time; when other cached data is taken out of the ring buffer space during this time period, the shape buffer structure will immediately save the data and return the data without the error flag to call the The program of the ring buffer; if no other cached data is fetched from the ring buffer while waiting for this time, the ring buffer returns a data with an error flag to the program that called the ring buffer.

Further, the ring data buffer implementation method embeds a synchronization mechanism of the embedded system, and the synchronization mechanism is implemented on the ring buffer, and is divided into three steps: initialization, write buffer, and read buffer.

Further, the initialized input has two parameters: Max_Index and Unit_Size; Max_Index defines the maximum signal scalar value of the write semaphore and the read semaphore; Unit_Size defines the number of bytes per read buffer or write buffer.

Further, the input parameters of the write buffer are Block, TimeOut, and Value; Block determines that No use suspend mode, TimeOut determines the time to suspend, and Value is the data to be written to the ring buffer.

The method for implementing the ring data buffering in the embedded system based on the synchronization mechanism provided by the invention uses the semaphore synchronization mechanism of the embedded operating system, and the original ring buffer is more robust, adopting configurable and portable Ring buffer, suitable for different software systems and different hardware systems, can achieve good results in applications of single hardware systems or communication between different hardware systems, and can be well satisfied. The need for practical applications.

DRAWINGS

1 is a schematic diagram of an initial state of a ring buffer of the prior art;

2 is a schematic diagram of a state in which a data is added to a ring buffer in the prior art;

3 is a schematic diagram of a state in which a ring buffer of the prior art is read and added;

4 is a schematic diagram of a switching process of four working states according to the present invention;

Figure 5 is a flowchart of initialization of the synchronization mechanism;

Figure 6 is a flow chart of the write buffer of the synchronization mechanism;

Figure 7 is a flow chart of the read buffer of the synchronization mechanism.

Detailed ways

The present invention will be further described in conjunction with the accompanying drawings and specific embodiments. It is understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention. All other embodiments obtained by a person of ordinary skill in the art based on the embodiments of the present invention without creative efforts are within the scope of the present invention.

As shown in FIG. 4, a ring data buffer implementation method for an embedded system based on a synchronization mechanism includes switching between four working states;

The four working states are:

1. Working state 1: There is no readable data in the ring buffer; when reading data in the ring buffer under working state 1, the ring buffer will be processed according to the actual use requirements in two cases:

2) The program hangs (blocks) here for a period of time. When data is written to the ring buffer during this time period, the ring buffer will immediately return a unit size of cache data to call the ring. The program of the buffer; if no data is written to the ring buffer while waiting for this time, the ring buffer returns a data with an error flag to the program that called the ring buffer.

2. Working state 2: There is sufficient memory in the ring buffer to store more data; in the working state 2, writing data to the ring buffer does not cause any error, and valid data is written into the buffer.

3. Working state 3: sufficient data is buffered in the ring buffer; in the working state 3, the data is read in the ring buffer without any error, and the valid cached data is returned.

4. Working state 4: There is no writable buffer space in the ring buffer; in the working state 4, when writing data to the ring buffer, the structure will be processed according to the actual use requirements:

2) The program hangs (blocks) here for a period of time; when other cached data is fetched from the ring buffer space during this time period, the shape buffer structure will immediately save the data and return the data without the error flag. The program that calls the ring buffer; if no other cached data is fetched from the ring buffer while waiting for this time, the ring buffer returns a data with an error flag to the program that called the ring buffer. .

The switching process of the four working states is:

When the data is written in the working state 1 (for example, 5 unit data), it is switched to the working state 2;

In working state 2, the data of the buffer is read. If the size of the read data (for example, 4 unit data) is smaller than the buffered data size, it enters the working state 3, if the read data size (for example, 7 Unit data) exceeds or equals the data buffered by the buffer, and enters the working state 4;

In working state 3, when reading data, when the buffer has no data to read, it enters working state 1. When writing data to the buffer, if the buffer is filled with data, it enters working state 4.

From the switching effect of the above four working states, the cacheable writable space and the readable data of the ring buffer are mutually exclusive, that is, when one unit data is written to the ring buffer, the ring buffer can be The rewritten circular buffer space is reduced by one unit, and the readable buffer data is one more unit size; on the contrary, whenever a unit of data is fetched from the ring buffer, it can be read from the ring buffer. Cache data is reduced by one unit, and the ring buffer will be one more unit. A small space to store newly written data.

A key technique in the above ring buffer is the synchronization between the size of the writable data and the size of the readable cache data. Generally, the embedded operating system will have a synchronization mechanism component (API), and the synchronization mechanism implementation principle and usage method in different embedded operating systems are basically similar. You can make full use of the synchronization mechanism that comes with these systems to embed in the above ring buffer.

The ring data buffer implementation method for the embedded system based on the synchronization mechanism is embedded with the synchronization mechanism of the embedded system, and the synchronization mechanism is implemented on the ring buffer, and is divided into three steps: initialization, write buffering, and Read buffer

As shown in Figure 5, the initialized input has two parameters, Max_Index and Unit_Size. Max_Index defines the maximum signal scalar value of the write semaphore (Write_Sem) and read semaphore (Read_Sem). Unit_Size defines the number of bytes per read buffer or write buffer (one unit data size). The initial value of Write_Sem is defined as Max_Index, because the data in the buffer area is empty, that is, the Max_Index data can be written (if the data is not read or the buffer is cleared), the same principle The initial value of Read_Sem is defined as 0 (the data is not started at the beginning). Readable). The initialization data buffer size is Unit_Size x Max_Index (Max_Index unit data). Both Write_Pointer and Read_Pointer are initialized to 0, which means that the data read into the ring buffer and the write data are initially pointed to the first address of the buffered data.

As shown in Figure 6, the input parameters of the write buffer are Block, TimeOut and Value. Block determines whether to use the suspended (blocked) mode, and TimeOut determines the time to suspend (block). Value is the data to be written to the ring buffer. Pend(x,x) and Accept(x) in Figure 6 are functions of blocking semaphore acquisition or non-blocking semaphore acquisition, respectively. Blocking semaphore acquisition function: If a specific semaphore is not obtained (the Write_Sem semaphore is 0 in Figure 6), it will block. If the semaphore is still not available during the TimeOut period, it will exit the blocking. Status and return data with error flag (err=1), if it is obtained, it returns, the specific semaphore is decremented by 1, and the returned data (err=0) does not contain error flag; non-blocking semaphore Get function: If a specific semaphore is acquired (Write_Sem above), return a data without error flag (err=0), otherwise return data with error flag (err=1). There is no blocking of the non-blocking semaphore acquisition function call process. Then, according to the data err, it is judged whether the user data (Value) is further written to the specific position of the data buffer Buffer, and after the data is written, the Read_Sem is incremented here by the function Add(x), and when it is incremented to be larger than the semaphore When the maximum scalar value is Max_Index, Read_Sem will not be incremented anymore. The corresponding write pointer is incremented cyclically. When it is incremented to be greater than or equal to Max_Index, the write pointer points to the first address of the buffered data. Finally, return the return value err obtained when acquiring a specific semaphore.

As shown in FIG. 7, the difference between the read buffer and the write buffer is mainly that the specific semaphore to be acquired here is the read semaphore (Read_Sem), and after the data is successfully read, the write semaphore (Write_Sem) is incremented. The cyclic increment is the read pointer, which returns the data err with or without the error flag and the data read from a specific location in the buffer.

The blocking type semaphore acquisition function Pend(x, x) mentioned in the above read buffer and write buffer, the non-blocking type semaphore acquisition function Accept(x), and the x semaphore increment function Add(x), in each Embedded operating systems with semaphores have their own prototypes, such as functions in the UCOS operating system: OSSemPend(), OSSemAccept(), OSSemPost(); functions in the Linux operating system: sem_wait(), sem_trywait() , sem_post(). The benefits of these functions are to ease the pressure of software writing and to make efficient use of resources.

The above-mentioned embodiments are merely illustrative of the embodiments of the present invention, and the description thereof is not to be construed as limiting the scope of the invention. It should be noted that a number of variations and modifications may be made by those skilled in the art without departing from the spirit and scope of the invention. Therefore, the scope of the invention should be determined by the appended claims.

Claims

A method for implementing a ring data buffer based on a synchronization mechanism in an embedded system, comprising: switching between four working states; the four working states are:

Working state 1: There is no readable data in the ring buffer;

Working state 2: There is sufficient memory in the ring buffer to store more data;

Working state three: sufficient data is buffered in the ring buffer;

Working state four: there is no writable buffer space in the ring buffer;

The switching process of the four working states is:

When the data is written in the working state, it switches to the working state 2;

When the working state 2 continues to write data, if the buffer is filled with the newly added data, it enters the working state 4, and if the newly added data does not fill the buffer, it remains in the working state 2;

In the working state 2, the data of the buffer is read. If the size of the read data is smaller than the size of the data buffered by the buffer, it enters the working state 3. If the size of the read data exceeds or equals the data buffered by the buffer, Go into work status four;

In the working state three, when reading data, when the buffer has no data to read, it enters the working state. When writing data to the buffer, if the buffer is full of data, it enters the working state four.
The buffering method for an embedded system according to claim 1, wherein when the data is read in the ring buffer area in the working state, the ring buffer is processed according to the actual use requirement in two cases:

1) directly return a data with an error flag to the program that called the ring buffer;

2) The program hangs here for a period of time. When data is written to the ring buffer during this time period, the ring buffer will immediately return a unit size of cache data to the program that calls the ring buffer; Waiting for this time, no data is still written to the ring buffer, then the ring buffer returns a data with an error flag to the program that called the ring buffer.
The ring data buffer implementation method for an embedded system based on a synchronization mechanism according to any of claims 1-2, characterized in that, in the working state four, when the data is continuously written into the ring buffer area, the structure is based on The actual use requirements are handled in two cases:

1) Directly return a data with an error flag to the program that called the ring buffer.

2) The program hangs here for a period of time; when other cached data is taken out of the ring buffer space during this time period, the shape buffer structure will immediately save the data and return the data without the error flag to call the The program of the ring buffer; if no other cached data is fetched from the ring buffer while waiting for this time, the ring buffer returns a data with an error flag to the program that called the ring buffer.
The ring data buffer implementation method for an embedded system based on a synchronization mechanism according to any of claims 1-3, wherein the ring data buffer implementation method embeds a synchronization mechanism of an embedded system, and the synchronization mechanism is Implemented on a ring buffer, it is divided into three steps: initialization, write buffer, and read buffer.
The ring data buffer implementation method for an embedded system based on a synchronization mechanism according to claim 1, wherein the initialized input has two parameters: Max_Index and Unit_Size; and Max_Index defines a maximum signal of the write semaphore and the read semaphore. Scalar value; Unit_Size defines the number of bytes per read buffer or write buffer.
The ring data buffer implementation method for an embedded system based on a synchronization mechanism according to claim 1, wherein the input parameters of the write buffer are Block, TimeOut, and Value; and Block determines whether to use the suspended mode, and TimeOut determines The time to suspend, Value is the data to be written to the ring buffer.