CN115408320A - Method for generating serial port simulation data - Google Patents

Abstract

The invention provides a method for generating serial port simulation data, which is used for verifying data transmitted by a stored user space; in the serial _ start _ tx, after the data sent by the user space is successfully checked, a return message is assembled, and for each byte in the return message, a tty _ insert _ flip _ char method is sequentially called to store the data into a data buffer area of a tty _ buffer; calling a tty _ flip _ buffer _ push method to add tty _ buffead.work to a global work queue and returning message data to a user space; the invention utilizes the serial port drive of linux to generate the simulation data, does not need a third-party tool, does not need other real serial port equipment, and greatly improves the generation efficiency of the serial port simulation data.

Description

A method of generating serial port analog data

technical field

The invention relates to the field of serial port data simulation calculations, in particular to a method for generating serial port simulation data.

Background technique

The statements in this section merely provide background art related to the present invention and do not necessarily constitute prior art.

When developing serial port-related projects, sometimes there are not enough serial port devices or no related devices at all. At this time, some method is needed to simulate the serial port data.

The inventors found that the current general method of obtaining simulation is:

(1) Through the virtual serial port, a pair of serial ports are virtualized, one is used for the project program to obtain data, and the other is used for data simulation software to generate simulated data, but there are few virtual serial port tools under Linux and the application is not very convenient;

(2) Connect multiple devices A to A and B to B through a USB-to-serial device. One of the devices is used for the project program, and the other ones are used to generate analog data. This method requires multiple USB-to-serial devices , not suitable for test scenarios that require a large number of serial devices.

Contents of the invention

In order to solve the deficiencies in the prior art, the present invention provides a method for generating serial port simulation data, which uses the serial port driver of linux to generate simulation data without the need for third-party tools or other real serial port devices, which greatly improves the The generation efficiency of the serial port analog data is improved.

In order to achieve the above object, the present invention adopts the following technical solutions:

The first aspect of the present invention provides a method for generating serial port simulation data.

A method for generating serial port analog data, comprising the following processes:

Serial driver registration, add serial port uart_port, where the ops of uart_port is uart_ops type;

When the user space calls write to send data to the serial port driver through the device file, the callback function set in start_tx in the uart_ops structure is called. The function set by start_tx in the callback function is serial_start_tx, and the data sent by the user space is stored in circ_buf. If the data is not If it crosses the end of the buffer, it will be protected in the first form, otherwise it will be saved in the second form; verify the data sent by the saved user space;

In serial_start_tx, after the data sent by the user space is verified successfully, the returned message is assembled, and for each byte in the returned message, the tty_insert_flip_char method is called in turn to save the data into the data buffer of tty_buffer;

Call the tty_flip_buffer_push method to add tty_bufhead.work to the global work queue, and return the message data to the user space.

As an optional implementation, the callback function is: void(*start_tx)(struct uart_port*).

As an optional implementation, serial port driver registration includes:

Use the uart_register_driver method to register the serial port driver uart_driver to the kernel.

Further, uart_driver includes device name and major version number and minor version number, and the device name is the name displayed under /dev.

Further, the serial port driver has a layered structure, including the core layer tty_core and the driver layer tty_driver, the tty_driver is encapsulated in the uart_driver structure, and the driver layer tty_driver includes circuit planning.

As an optional implementation, use uart_add_one_port to add the serial port uart_port.

As an optional implementation, return message data to user space, including:

When the user space reads the serial port data through the device file, it calls n_tty_read of the serial port framework;

The data sent to the user space is stored in the read_buf of n_tty_data. If there is data to read, the data will be sent to the user space; if there is no data to read, n_tty_read will sleep, waiting for the scheduling thread to get data from the global queue, and Call flush_to_ldisc to copy data from tty_bufhead.tail.data to tty_struct.disc_data.read_buf.

As an optional implementation, the n_tty_read function includes:

static ssize_t n_tty_read(struct tty_struct *tty, struct file*file, unsigned char__user*buf, size_t nr).

As an optional implementation, the function of flush_to_ldisc is void flush_to_ldisc(struct work_struct*work), where the parameter work is work in tty_bufhead.

As an optional implementation, call the tty_insert_flip_char method in turn to save the data into the data buffer of tty_buffer, where the first two bytes of the returned message are written into the buffer, including the following process:

Write the first byte, 1 is the value of the first byte, tty_insert_flip_char(tty,1,0);

Write the second byte, 3 is the value of the second byte, tty_insert_flip_char(tty,3,0);

After the data is assembled, call the tty_flip_buffer_push method to send the data.

Compared with prior art, the beneficial effect of the present invention is:

The method for generating serial port simulation data described in the present invention utilizes the serial port driver of linux to generate simulation data without the need for third-party tools or other real serial port devices, which greatly improves the generation efficiency of serial port simulation data.

Advantages of additional aspects of the invention will be set forth in the description which follows, and in part will be obvious from the description, or may be learned by practice of the invention.

Description of drawings

The accompanying drawings constituting a part of the present invention are used to provide a further understanding of the present invention, and the schematic embodiments of the present invention and their descriptions are used to explain the present invention and do not constitute improper limitations to the present invention.

Fig. 1 is a serial port driver structure provided by an embodiment of the present invention.

FIG. 2 is a schematic diagram of a hierarchical structure of a serial port driver provided by an embodiment of the present invention.

FIG. 3 is a schematic diagram of a serial port structure provided by an embodiment of the present invention.

Fig. 4 is a schematic diagram of the data structure of circ_buf provided by the embodiment of the present invention.

Detailed ways

The present invention will be further described below in conjunction with the accompanying drawings and embodiments.

It should be noted that the following detailed description is exemplary and intended to provide further explanation of the present invention. Unless defined otherwise, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention belongs.

It should be noted that the terminology used here is only for describing specific embodiments, and is not intended to limit exemplary embodiments according to the present invention. As used herein, unless the context clearly dictates otherwise, the singular is intended to include the plural, and it should also be understood that when the terms "comprising" and/or "comprising" are used in this specification, they mean There are features, steps, operations, means, components and/or combinations thereof.

In the case of no conflict, the embodiments and the features in the embodiments of the present invention can be combined with each other.

Example 1:

As shown in Figure 1, Embodiment 1 of the present invention provides a method for generating serial port analog data, including the following process:

1) Register the serial port driver

Use the uart_register_driver method to register the serial port driver uart_driver to the kernel. The uart_driver contains the device name (that is, the name displayed under /dev), the major version number and the minor version number. The uart_driver structure is shown in Figure 1.

The hierarchical structure of the serial port driver (see Figure 2) is divided into the core layer (tty_core) and the driver layer (tty_driver). The uart_driver structure encapsulates the tty_driver, and the driver layer also includes the line discipline.

2) Add serial port

Use uart_add_one_port to add a serial port uart_port, the ops of uart_port is uart_ops type, this type defines the callback function of various operations of the serial port. Among them, serial_start_tx is a method called when sending data to the serial port driver, and it is also a method that needs to be focused on in the present invention.

3) Receive data sent to the driver

The various data structures involved in this part and the associations in each data structure are shown in Figure 3.

When the user space calls write to send data to the serial port driver through the device file (such as: /dev/ttyS1), it will call the callback function set in start_tx in the uart_ops structure. The prototype of this function is: void(*start_tx)(struct uart_port *). The following assumes that the function set by start_tx is serial_start_tx. The data sent by the user space is stored in circ_buf, and the structure of circ_buf is shown in Figure 4. If the data does not cross the end of the buffer, the data saving mode is as shown in (1) in FIG. 4 , otherwise it is as shown in (2) in FIG. 4 .

According to the above, the data sent by the user space can be obtained, and the data can be verified.

4) Return mock data

In serial_start_tx, after the data sent by the user space is verified successfully, the return message can be assembled. For each byte in the returned message, the tty_insert_flip_char method is called in turn; tty_insert_flip_char finally saves the data to the data buffer of tty_buffer in Figure 3.

Finally, call the tty_flip_buffer_push method to add tty_bufhead.work in Figure 3 to the global work queue.

The process of returning message data to user space is as follows:

When user space reads serial port data through a device file (such as: /dev/ttyS1), it will call n_tty_read of the serial port framework. The prototype of this function is: static ssize_t n_tty_read(struct tty_struct*tty, struct file*file, unsigned char__user*buf, size_t nr);

The data sent to the user space is stored in the read_buf of n_tty_data in Figure 3. If there is data to be read, the data will be sent to the user space; if there is no data to be read, n_tty_read will sleep, waiting for the scheduling thread to get from the above global queue Get the data and call flush_to_ldisc to copy the data from tty_bufhead.tail.data to tty_struct.disc_data.read_buf;

The prototype of flush_to_ldisc is void flush_to_ldisc(struct work_struct*work), and the function parameter work is work in tty_bufhead.

5) Driver installation

Write the Makefile script, enter make to compile, and a .ko file will be generated after the compilation is successful;

Enter insmod name.ko to install the driver. After the installation is successful, the corresponding driver file will be generated in the /dev directory.

Specifically, the solution provides the following specific examples:

S1: Register serial port driver

Use the uart_register_driver method to register the serial port driver uart_driver to the kernel, and uart_driver contains the device name (that is, the name displayed under /dev) and the major and minor version numbers.

S2: Add serial port

Use uart_add_one_port to add a serial port uart_port, the ops of uart_port is uart_ops type, this type defines the callback function of various operations of the serial port, where serial_start_tx is the method called when sending data to the serial port, which is also the focus of this invention method.

S3: Receive data sent to the driver

The method to process the data sent to the serial port driver is serial_start_tx, and the parameter type of this method is uart_port;

uart_port->state->xmit saves the data sent to the serial port driver, and all the data can be traversed through xmit->buf and xmit->tail;

Data can be stored in local arrays for later use. Next, the received message can be verified.

S4: return simulated data

uart_port->state->port is of tty_port type, and the message to be sent is written into the buffer of the driver through tty_insert_flip_char.

To write the first two bytes of the returned message into the buffer, you can use the following method:

Write the first byte, 1 is the value of the first byte;

tty_insert_flip_char(tty,1,0);

Write the second byte, 3 is the value of the second byte;

tty_insert_flip_char(tty,3,0);

After the data is assembled, call the tty_flip_buffer_push method to send the data.

S5: Simulate a serial port line with multiple devices

Change the 0th data of pkg_buf to the 0th data of snd_buf. The disadvantage of this method is that in most data cases, the returned data are the same.

Another method is to define a global array, such as (take modbus03 function code as an example):

char test[][7]={01,03,04,01,0x1D,01,0xFA,02,03,04,01,0x1E,01,0xFB,03,03,04,01,0x1C,01,0xFC };

Later, according to the slave address in S3, select the corresponding array data, calculate the CRC check code and return the data.

S6: Driver installation

Write the Makefile script, enter make to compile, and a .ko file will be generated after the compilation is successful;

Enter insmod name.ko to install the driver. After the installation is successful, the corresponding driver file will be generated in the /dev directory.

The above descriptions are only preferred embodiments of the present invention, and are not intended to limit the present invention. For those skilled in the art, the present invention may have various modifications and changes. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principles of the present invention shall be included within the protection scope of the present invention.

Claims (10)

1. A method for generating serial port analog data, characterized in that: Including the following process: Serial driver registration, add serial port uart_port, where the ops of uart_port is uart_ops type; When the user space calls write to send data to the serial port driver through the device file, the callback function set in start_tx in the uart_ops structure is called. The function set by start_tx in the callback function is serial_start_tx, and the data sent by the user space is saved. If the data does not span At the end of the buffer, it is protected in the first form, otherwise it is saved in the second form; the data sent by the saved user space is verified; In serial_start_tx, after the data sent by the user space is verified successfully, the returned message is assembled, and for each byte in the returned message, the tty_insert_flip_char method is called in turn to save the data into the data buffer of tty_buffer; Call the tty_flip_buffer_push method to add tty_bufhead.work to the global work queue, and return the message data to the user space. 2. the method for generating serial port simulation data as claimed in claim 1, is characterized in that: The callback function is: void(*start_tx)(struct uart_port*). 3. the method for generating serial port simulation data as claimed in claim 1, is characterized in that: Serial driver registration, including: Use the uart_register_driver method to register the serial port driver uart_driver to the kernel. 4. the method for generating serial port simulation data as claimed in claim 3, is characterized in that: uart_driver includes the device name and the major version number and minor version number, and the device name is the name displayed under /dev. 5. the method for generating serial port simulation data as claimed in claim 3, is characterized in that: The serial port driver is a layered structure, including the core layer tty_core and the driver layer tty_driver. The tty_driver is encapsulated in the uart_driver structure, and the driver layer tty_driver includes circuit planning. 6. the method for generating serial port simulation data as claimed in claim 1, is characterized in that: Use uart_add_one_port to add the serial port uart_port. 7. the method for generating serial port simulation data as claimed in claim 1, is characterized in that: Return message data to user space, including: When the user space reads the serial port data through the device file, it calls n_tty_read of the serial port framework; The data sent to the user space is stored in the read_buf of n_tty_data. If there is data to read, the data will be sent to the user space; if there is no data to read, n_tty_read will sleep, waiting for the scheduling thread to get data from the global queue, and Call flush_to_ldisc to copy data from tty_bufhead.tail.data to tty_struct.disc_data.read_buf. 8. the method for generating serial port simulation data as claimed in claim 1, is characterized in that: n_tty_read function, including: static ssize_t n_tty_read(struct tty_struct *tty, struct file*file, unsignedchar__user*buf, size_t nr). 9. the method for generating serial port simulation data as claimed in claim 1, is characterized in that: The function of flush_to_ldisc is void flush_to_ldisc(struct work_struct*work), where the parameter work is work in tty_bufhead. 10. the method for generating serial port simulation data as claimed in claim 1, is characterized in that: Call the tty_insert_flip_char method in turn to save the data into the data buffer of tty_buffer, where the first two bytes of the returned message are written into the buffer, including the following process: Write the first byte, 1 is the value of the first byte, tty_insert_flip_char(tty,1,0); Write the second byte, 3 is the value of the second byte, tty_insert_flip_char(tty,3,0); After the data is assembled, call the tty_flip_buffer_push method to send the data.

Images