Visual data sending platform and data homogenization processing method thereof

Abstract

The invention provides a visual data sending platform and a data homogenization processing method thereof. The visual data sending platform comprises a management layer, a pipeline layer derived from the management layer and an application layer derived from the management layer or the pipeline layer. According to the method, a root module responds to time code board hardware interruption or system thread simulation interruption, a management layer scans a sub-module list and calls application layer processes of the sub-modules, so that the application layer processes of all modules in a platform are executed in series under the same interruption; the management layer calculates a time interval of process cycle calling; and the pipeline layer reads a frame of original data of the receiving buffer area, puts the frame of original data into a data segment of the sending buffer area, and performs homogenization processing of data stream sending according to delay time calculated by an accumulation period of time interval superposition and a data period. In order to make the sending platform more convenient to edit, the dynamic library only exports one function CRun* GetObj (), generates an instance and returns a pointer to realize DLL external calling, and an editable visual data sending platform with a data homogenization function is established through a tree structure.

Description

Technical Field

[0001] The present invention relates to the technical field of electronic digital data processing, and in particular to a visual data sending platform and a data homogenization processing method thereof. Background Art

[0002] In the early days of tracking a single target, all dynamic library modules were placed on a telemetry terminal and run, and the output device was a serial port. Later, when it was necessary to track multiple targets, multiple demodulation terminals, solution terminals, and communication terminals were used to form a local area network for distributed processing.

[0003] The local area network is generally data-driven. The communication terminal sends the same amount of data to the user as the data collected when the process responds, regardless of the data cycle. This strategy is simple to implement, has a small code size, and reduces resource usage. As long as the bit rate of the data source is correct, there will be no problems.

[0004] However, the communication terminal has both data generated by itself and data from other terminals. If the bit rate of the data source is uneven, the bit rate is sometimes fast and sometimes slow. When the bit rate is fast, the amount of data in a single cycle will increase several times, exceeding the limit of the user's stress test, resulting in the user program being unable to handle it.

[0005] Using DLL to encapsulate the functional modules of the functional platform can reduce the memory space occupied, but it is limited to the 4G virtual address space when loaded into the memory. Other DLLs outside cannot be accessed from within the DLL. When used, it is usually exported variables, function pointers or class pointers to be called outside the DLL.

[0006] The part that needs to be exported must first be declared inside the DLL with _declspec(dllexport), and when used outside the DLL, _declspec(dllimport) must be declared.

[0007] Most dynamic libraries are encapsulated with pure functions and are process-oriented. It is more convenient and safer to export Get functions to obtain global variables, such as global variable int xx, read the value of the variable int getxx(){return xx}, and rewrite the value of the variable setxx(int ​​a){xx=a}. Each instance needs to export and save a "group" of function pointers; multiple instances require saving many "groups", which makes interface writing troublesome and memory-intensive, and the program development experience is very poor.

[0008] In addition, C++ can only generate a single instance of a pure function encapsulated DLL each time it is loaded into memory, and multiple calls also use the same virtual address space, calling the same instance. If you want to generate multiple instances, you need to exit the framework platform first, copy the DLL and rename it, add the renamed DLL file name and command line parameters to the configuration file, and restart the framework. Because it is impossible to add modules in real time in the program, and it is also troublesome to leave the window, exit the software, and find and modify the configuration file on the hard disk, the experience of using the program is also very poor.

[0009] Therefore, there is a need for a data transmission platform and a data transmission method that can perform data homogenization and is easy to use. Summary of the invention

[0010] The present invention aims to solve the problem of homogenization and convenient use of telemetry data transmission, and provides a visual data transmission platform and a data homogenization processing method thereof: the time interval of process loop call is calculated through the management layer; the pipeline layer reads a frame of original data in the receiving buffer and puts it into the data segment of the sending buffer (protocol package is performed when the protocol is selected), and the data stream transmission is homogenized according to the delay time calculated by the cumulative cycle of the time interval superposition and the data cycle; in order to make the sending platform more convenient to edit, the dynamic library only exports one function CRun*GetObj(), generates an instance and returns a pointer, realizes DLL external call, and builds an editable visual data transmission platform with data homogenization function through a tree structure.

[0011] The present invention provides a visual data transmission platform, which encapsulates the application class of the application layer through a dynamic link library DLL, and enables the parent module to search for the submodule and read and write the variables of the submodule and call the function through a tree structure outside the DLL; the root module responds to the hardware interruption of the code board or the system thread simulation interruption, scans the submodule list at the management level and calls the application layer process of the submodule, so that the application layer processes of all modules in the platform are executed in series under the same interruption, so that the telemetry data is sent evenly;

[0012] The visual data sending platform includes a management layer, a pipeline layer derived from the management layer, and an application layer which is partially derived from the management layer and partially derived from the pipeline layer.

[0013] The management layer uses CRun as the process base class, including the process interface that responds to interrupts, the start and stop flags of the control process, and the display interface; the process interface function calculates the time interval of the process loop call, scans the sub-module list and calls the application layer process of the sub-module; the display interface function displays the time interval of the process log;

[0014] The pipeline layer overloads the process interface function to achieve the uniform processing of data stream transmission. It includes input ports, output ports and algorithm interfaces; the algorithm interface function reads a frame of raw data from the receiving buffer and puts it into the data segment of the sending buffer (protocol grouping is performed when the protocol is selected); when overloading the process interface function, the management layer process is called first, and then the delay time is calculated based on the cumulative cycle of the time interval superposition and the data cycle, and the uniform processing of data stream transmission is performed;

[0015] The application layer includes a timer module, a channel chain monitoring module and a data packet module, which are added and set in sequence; the timer module is derived from the management layer and sets the time code board; the channel chain monitoring module allows users to identify whether the output port of the channel is still working normally when the channel stops sending data; the data packet module inherits the data flow sending uniformization processing of the pipeline layer, and can draw curves according to the application overload display interface function or overload algorithm interface function through different algorithms to generate various types of result data and output them to the output port.

[0016] The visual data transmission platform described in the present invention, as a preferred mode, uses variables to describe attributes and functions to implement methods in the class structure. The DLL only exports one function CRun*GetObj(). Each time GetObj() is called outside the DLL, an instance is generated inside the DLL, and a base class pointer is returned outside the DLL and saved in the submodule list and mapped to the sub-leaf of the tree structure; the parent module outside the DLL searches for the submodule through the tree structure and reads and writes the variables and calls the functions of the submodule;

[0017] The function CRun*GetObj() includes only two statements: CRun*p=new application class; return p; the function CRun*GetObj() generates an instance and obtains the instance address and assigns it to the pointer p, and then returns the pointer for external use of the DLL.

[0018] The visual data transmission platform described in the present invention is, as a preferred mode, a process base class structure of the management layer includes a topological structure and can add submodules; when the start / stop flag bRun in the submodule is 1, the system thread is started to independently call the application layer process of the submodule, and the process of the parent module no longer calls the application layer process of the submodule. When the start / stop flag bRun is 0, the application layer process of the submodule is called as a function by the parent module process to realize serial execution.

[0019] The management layer includes the property page pointer CPropertyPage*, the import parameter LaodPara(FILE*f), and the save parameter SavePara(FILE*f). The property page pointer allows multiple dialog boxes to be combined and set together.

[0020] According to different task requirements, modify the value of the variable through the parameter setting dialog box in the property page. When the framework exits, call each module SavePara(FILE*f) to write the variable back to the configuration file. When entering the framework next time, call each module LoadPara(FILE*f) to import the parameters of the previous task from the configuration file.

[0021] A visual data sending platform described in the present invention is, as a preferred method, derived from the management layer by the pipeline layer, and the process interface function is overloaded to achieve uniform processing of data stream sending: the cumulative period is divided by the data period and rounded to obtain the number of frames n read when sending, and one frame of data is sent n times. Each time the sending is successful, the cumulative period is subtracted from the data period to retain the delay, and the cumulative period includes the delay.

[0022] The pipeline layer manages input and output devices. The device management options support no device, shared memory, file, serial port, and network.

[0023] The pipeline layer can overload the display interface function to display the original hexadecimal code of the data stream;

[0024] Directed pipeline: Under the premise that the pipeline layer does not change the algorithm for processing telemetry data streams, different applications can be expanded by only changing the input and output devices; data streams are output to files for data storage, and input from files for data playback; shared memory input and output are data exchange between dynamic libraries; network and serial port input and output are distributed processing between terminals; data streams are sent to printers for raw data printing, data streams are sent to image decoders for picture and video playback, and data streams are sent to GPS solution terminals to calculate positioning data and then sent to the projection screen to display the motion trajectory of the tracked target. The pipeline layer is used as a built-in application module for users.

[0025] The visualized data sending platform described in the present invention, as a preferred mode, has an application layer that supports timers, channel link monitoring, route selection and packet assembly, GPS solution and full-frame arrangement, and directional pipelines.

[0026] The timer module is directly derived from the management layer. The timer module is in search mode and can use the time code board for hardware timing. When the time code board cannot be found, the system thread simulation timing is automatically started. When hardware timing is used, the timing period and data period are integer multiples or reverse integer multiples.

[0027] The channel chain monitoring module includes process interface, algorithm interface and output device, but does not include input device. The output device port can be shared and opened. The output devices of the channel chain monitoring module and the data packet module select the same port, and the data of the channel chain monitoring module and the data packet module do not affect each other.

[0028] When the cumulative period of one or more data packet modules included in the channel link monitoring module is greater than 1s, the channel link monitoring module outputs a link monitoring frame or a reframe and clears the cumulative period of each data packet module.

[0029] The data segment of the chain monitoring frame is filled with the time word containing the current time. The time word is updated once per second and the sending frequency is 1 time / s.

[0030] The reframe is the last data packet sent in the channel. The method for obtaining the reframe is: the data packet module sends the data that has been sent in this round to the channel chain monitoring module through Up to overwrite the buffer. When the channel chain monitoring module contains at least two data packets, the last data to be sent will not be overwritten.

[0031] The data packet module generates various types of data segments through different algorithms. If the instruction packet is transmitted, the parameter segment in the instruction packet can also be generated. The data packet module includes a link monitoring module, a path selection module, a solution module, a directional pipeline module, and a full frame arrangement module.

[0032] The application layer reloads the display interface and then draws the curve. The display window interface can pop up a floating menu to select display log, display original code, and display curve.

[0033] The visualized data sending platform described in the present invention is preferably installed on a communication terminal, and at least two demodulation terminals, a solution terminal and a communication terminal form a local area network to perform distributed telemetry data processing.

[0034] The intermediate frequency signal of the demodulation terminal is demodulated by hardware to generate sub-frame data, which is converted into full-frame data that can be directly used by users through full-frame arrangement, and then distributed to the communication terminal and the solution terminal through the group address broadcast of the network. Full-frame arrangement includes synchronizing sub-frame data into full-frame data, removing full-frames with errors, and correcting time words.

[0035] The solution terminal extracts the GPS raw data from the sub-frame channels in the full-frame data, displays the satellite channels and parameter indicators, draws the satellite sky map, obtains the GPS positioning data and sends it to the communication terminal;

[0036] The visual data transmission platform of the communication terminal receives full-frame data and puts it into shared memory, and outputs fast-changing parameters through sub-frames, slow-changing parameters through sub-frames, or computer words through multiple full-frames; fast-changing parameters include voltage, current and temperature; slow-changing parameters include full-frame count, impact, vibration and pressure. Shared memory allows multiple routing modules to access it simultaneously.

[0037] The communication terminal packages the GPS positioning data, fast-changing parameters, slowly-changing parameters and computer words into protocol packages, and then sends them to the user according to different data cycle timings.

[0038] A visual data sending platform described in the present invention, as a preferred embodiment, the input port includes a receiving buffer for protocol unpacking; the output port includes a sending buffer for protocol packet assembly; the input port and the output port support no device, shared memory, file, serial port, network; the protocol list options include no protocol, intra-regional protocol, inter-regional protocol and network protocol.

[0039] The present invention provides a data homogenization processing method for a visual data sending platform, comprising the following steps:

[0040] S1, the data packet module uses the pipeline layer process and overloads the algorithm function;

[0041] S2, the pipeline layer process calls the management layer process: records the current time and calculates the time interval based on the last recorded time and the current time, then scans the sub-module list and calls the application layer process of each sub-module in turn;

[0042] S3, the pipeline layer accumulates the cycle and continuously superimposes the time interval; the receiving port receives the original data and puts it into the receiving buffer; the length of the received data is divided by the length of the data frame, and the remainder is rounded to zero to obtain the current receiving count, and it is accumulated into the receiving count.

[0043] When the sending count is less than the receiving count and there is data in the receiving buffer, the accumulated period is divided by the data period and rounded to get the number of frames n read during sending to implement homogenization processing.

[0044] S4. When n>0, the algorithm function is called, and the data packet module converts the original data in the receiving buffer into result data and puts it into the data segment of the sending buffer (protocol grouping is performed when the protocol is selected) to obtain the data to be output; the data packet length PL is obtained according to the data protocol, and the output end sends PL bytes;

[0045] When the transmission is successful: the transmission count + 1; the cumulative cycle minus the data cycle to obtain the delay time; the data in the transmission buffer is copied to the transmission buffer of the channel link monitoring module as a reframe standby; the frame number n is read minus 1; return to step S4;

[0046] S5, when there is no data packet sent on the channel and the sending conditions are met, the channel link monitoring module sends a link monitoring frame or a reframe, and no equalization processing is required;

[0047] S51, the channel chain monitoring module reloads the pipeline layer process: calls the management layer process, calculates the time interval, scans the sub-module list and calls the sub-module process;

[0048] S52, when the cumulative period of all data packet modules is greater than 1s: if the link monitoring frame is selected, the link monitoring frame will overwrite the sending buffer; if the re-frame is selected, the data packet module has overwritten the sending buffer of the channel link monitoring module through Up after completing the data transmission to obtain the re-frame;

[0049] S53, executing the sending function of the output device;

[0050] S54, sending is completed, and the accumulated cycle of each data packet module is cleared.

[0051] The data homogenization processing method of a visual data sending platform described in the present invention is, as a preferred embodiment, the channel chain monitoring module includes a telemetry data channel chain monitoring module and an external measurement data channel chain monitoring module; a slowly changing parameter data packet module and a rapidly changing parameter data packet module are added under the telemetry data channel chain monitoring module; a positioning data data packet module is added under the external measurement data channel chain monitoring module;

[0052] In step S1, the slowly changing parameter data packet module, the rapidly changing parameter data packet module and the positioning data data packet module all use pipeline layer processes and overload algorithm functions;

[0053] The process response in step S2 is: calculate the time interval; (there is no submodule in the lower layer)

[0054] In step S51, the application layer process of the telemetry data channel link monitoring module calls the management layer process through the overloaded pipeline layer process: calculates the time interval, scans the sub-module list and calls the application layer processes of the slowly changing parameter data packet module and the rapidly changing parameter data packet module; then the application layer process of the external measurement data channel link monitoring module calls the management layer process through the overloaded pipeline layer process: calculates the time interval, scans the sub-module list and calls the application layer process of the positioning data packet module.

[0055] The data homogenization processing method of a visualization data sending platform described in the present invention is, as a preferred method, in step S4, when the data packet module is a routing module, the routing method can be: selecting subframe routing, sub-frame routing, multiple full-frame routing, and converting the full-frame data into routing data through an algorithm function; when the data packet module is a solution module, the GPS raw data is converted into positioning data through an algorithm function.

[0056] The present invention has the following advantages: the present invention uses the topological structure of the management layer to call the application layer processes of all modules in the platform for serial execution when the root module responds to the hardware interruption of the code board or the system thread simulation interruption; the management layer calculates the time interval, the pipeline layer calculates the receiving count, the number of frames read during sending and the delay time, so that the telemetry data is sent evenly; the device management of the pipeline layer realizes the directional pipeline characteristics and reduces the version maintenance cost; the application layer inherits the device management and data flow homogenization processing of the channel layer, and only needs to overload the algorithm interface, simplifying the workload of secondary development; in order to make the sending platform more convenient to edit, the dynamic library only exports one function CRun*GetObj(), generates an instance and returns a pointer, realizes DLL external call, and builds an editable visual data sending platform with data homogenization function through a tree structure. BRIEF DESCRIPTION OF THE DRAWINGS

[0057] Figure 1 A schematic diagram of the derivation relationship and process call relationship of a visual data sending platform and a data homogenization processing method thereof;

[0058] Figure 2 The present invention is a schematic diagram of detailed process calling relationships of a visual data sending platform and its data homogenization processing method. DETAILED DESCRIPTION

[0059] The technical solutions in the embodiments of the present invention will be described clearly and completely below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, rather than all the embodiments.

[0060] Example 1

[0061] like Figures 1-2 As shown, a visual data sending platform and a data homogenization processing method thereof;

[0062] The background of this embodiment is: based on a certain transmission protocol, the user's receiving terminal is equipped with a metronome, requiring the sending terminal to strictly send data according to the 50ms timing; supports multiple sending channels; each sending channel supports sending more than two data packets; when there is no data in the sending channel, the link monitor or reframe is sent every 1s; the data period (50ms, 100ms, 200ms) is optional.

[0063] The application analysis of this embodiment is as follows:

[0064] In the early days of tracking a single target, all dynamic library modules were put into a telemetry terminal for operation, and the output device was a serial port. Later, it was necessary to track multiple targets, and the resources of one terminal were not enough. Currently, multiple demodulation terminals, solution terminals, and communication terminals are used to form a local area network for distributed processing. The data transmission within the local area network uses data drive, and the minimum timing cycle is selected in the program. There is no need to know the data cycle and no need for encapsulation protocol; the communication terminal sends data to the outside in a unified manner, using time drive. The property setting dialog box can be popped up to modify the timing cycle and data cycle, and the data is encapsulated and sent using the protocol.

[0065] The communication terminal has data generated by other terminals, such as the subframe data generated by the intermediate frequency signal of the demodulation terminal after hardware demodulation, which is converted into full-frame data that can be directly used by users through full-frame sorting (including synchronization of subframe data into full-frame data, elimination of full-frame with errors, and correction of time words), and then distributed to the communication terminal and the solution terminal through the network group address broadcast; the solution terminal selects the GPS raw data from the subframe of the full-frame data, displays the satellite channel and parameter indicators, draws the satellite sky map, and sends the solved positioning data to the communication terminal. The communication terminal also has its own data, such as receiving the full-frame data from the demodulation terminal into the shared memory (allowing multiple selection modules to access at the same time), selecting fast-changing parameters (such as voltage, current, temperature, etc.) through subframes, slowly changing parameters (such as full-frame count, impact, vibration, pressure, etc.) through subframes, or computer words through multiple full frames. Various data are packaged and grouped by protocols at the communication terminal, and then sent regularly according to different data cycles.

[0066] After sorting out and summarizing various data flows, it is concluded that each data packet module should include three parts: the input device collects the original data, the process algorithm generates the result data, and the output device sends the result data.

[0067] Input and output use device management to select different device modules. The advantage of using device management is that it reduces the maintenance cost of versions. There are 16 combinations of input and output, and there is no need to prepare 16 versions and modify each version when changing the algorithm. Currently, the device list selection items support no device, shared memory, file, serial port, and network. The process of the device module is the input read function and the output write function; therefore, each device module has a buffer: the output device is the send buffer, which is used for protocol packet assembly; the input device is the receive buffer, which is used for protocol depacketization.

[0068] Because the protocol is involved in communication with the external network outside the LAN, the protocol is available for selection in the device module, so that the data packet can be completed by one module. The protocol list selection items support no protocol, intra-region, inter-region, and network.

[0069] 1. Selection of dynamic library DLL packaging method in this embodiment:

[0070] This method uses C++ to encapsulate the functional module into DLL. This method chooses to encapsulate each application module into an application class, which is object-oriented.

[0071] In the class structure, variables are used to describe properties, and functions are used to implement methods. The DLL only exports one function CRun*GetObj(), which only includes two statements in the function body. CRun*p=new application class; return p; these two statements first generate an instance and return a pointer. Every time GetObj() is called outside the DLL, an instance will be generated inside the DLL, and a base class pointer will be returned outside the DLL and saved in the submodule list and mapped to the sub-leaf of the tree structure. In this way, outside the DLL, through the tree structure, the upper-level module searches for the lower-level module and reads and writes the variables and calls the functions therein. For example, CRun*p=GetObj(); read the value of the variable p->xx; rewrite the value of the variable p->xx=a; the calling process is p->Run();

[0072] 2. Classes have two other powerful features: derivation and overloading.

[0073] Derivation can be done multiple times, and the derived class can be used as a base class to derive new classes again. Common things can be encapsulated in the structure of the base class, and the classes derived from the base class have these variables and functions. For example, the data stream sending homogenization process is encapsulated in the pipeline layer process, and the processes of the classes derived from the pipeline have this attribute, so there is no need to study this attribute repeatedly.

[0074] Overloading means that the function in the derived class can realize different personality from the function with the same name in the base class. For example, in the display interface, the process base class management layer displays the time interval of the process log; the derived pipeline layer displays the hexadecimal original code of the data stream after overloading; and the derived application layer draws the curve after overloading. The display window interface can pop up a floating menu, and you can choose to display the log, display the original code, or display the curve according to your needs.

[0075] 2.1 Management layer: CRun as the process base class

[0076] The structure of the process base class contains the topology and related operations:

[0077] CRun*Up; / / parent module pointer

[0078] CRun*Dn

[10] ; / / Submodule list

[0079] Add submodule:

[0080] (You can read the module name from the configuration file or select it from the submodule list that pops up in the tree control window)

[0081] aCreate a new module

[0082] b Append the new module pointer to the parent module's submodule list

[0083] c Save the parent module pointer to the Up

[0084] The process interface Run() calculates the time interval of the process loop call, scans the sub-module list and calls the application layer process of the sub-module;

[0085] Provide the start and stop flag bRun of the control process. When bRun=1, the system thread is started to independently call the submodule process, and the parent module process no longer calls the submodule process. (Each data packet uses an independent thread to call the process according to the data cycle cycle, and one interrupt sends one frame of data to improve execution efficiency; the data cycle needs to be greater than or equal to 50ms.) When bRun=0, the submodule process is called as a function by the parent module process to achieve serial execution.

[0086] Provides the display interface Draw() to display the time interval of the process log. Provides the property page pointer CPropertyPage* (allows multiple dialog boxes to be combined and set together). Provides the import parameter LaodPara(FILE*f) and the save parameter SavePara(FILE*f). According to different task requirements, the value of the variable can be modified through the parameter setting dialog box in the property page. When the framework exits, call each module SavePara(FILE*f) to write the variable back to the configuration file. The next time you enter the framework, call LoadPara(FILE*f) to import the parameters of the last task from the configuration file.

[0087] 2.2 Pipeline layer: derived from the management layer, overloads the process interface function to achieve uniform processing of data stream sending; provides algorithm interface function, reads a frame of raw data from the receiving buffer and puts it into the data segment of the sending buffer (performs protocol packaging when selecting the protocol) int to(char*, char*, int); overloads the display interface function to display the hexadecimal original code of the data stream; adds input and output device management, and the device selection items support no device, shared memory, file, serial port, and network; the output device contains a receiving buffer to complete the protocol packaging; the input device contains a sending buffer to complete the protocol unpacking; the protocol selection items support no protocol, intra-region, inter-region, and network.

[0088] Directed pipeline: The pipeline layer does not change the algorithm for processing telemetry data streams, and different applications can be expanded by only changing the input and output devices. For example, outputting data streams to files is data storage; input from files is data playback; input and output of shared memory is data exchange between dynamic libraries; input and output of networks and serial ports is distributed processing between terminals; sending to printers to print raw data, sending to image decoders to play pictures and images, sending to GPS solution terminals to calculate positioning data and then sending to projection screens to display motion trajectories, etc. The pipeline layer is used as a built-in application module for users.

[0089] 2.3 Application layer: derived from the pipeline layer, inherits the directional pipeline characteristics of device management and data transmission uniformity processing; overloads algorithm functions according to different applications; overloads display functions to draw different curves. Since the management layer and pipeline layer provide a large number of basic functions, it is convenient to focus only on data algorithm processing during secondary development, and the scalability is extremely strong. Currently, it supports timers, channel chain monitoring, route selection and package assembly, GPS solution, full frame sorting, and directional pipelines.

[0090] 3. Visual management window

[0091] The communication terminal selects the tree structure window according to the needs, and provides a floating menu to add, delete, copy, paste, and rename modules. When the 'Add' item is selected, a list of process modules pops up for selection. Currently, modules such as timer, channel chain monitor, route selection and package assembly, directional pipeline, full frame arrangement, and positioning solution are supported. Select the timer module as the root module, add multiple channel chain monitor modules under the timer, and add multiple data packet modules under the channel chain monitor module.

[0092] 3.1 Timer Module

[0093] The timer module does not require input devices and output devices and is directly derived from the management layer.

[0094] The timer module uses the search mode. In addition to the time code board hardware timing, when the time code board hardware is not found, the system thread simulation timing is started automatically. The thread is controlled by the operating system time slice. When the system resources are insufficient, the timing cycle is unstable and it is easy to cause delays. For example, the timing cycle of 50ms becomes 60ms. However, the thread debugger can still be used in the absence of hardware.

[0095] In terms of process control, when bRun=0, the hardware interrupt only serially controls the modules that have external network transmissions, such as the channel link monitoring module and the routing module; when bRun=1, the data exchange modules within the LAN still enable their own threads, such as the full-frame sorting module and the directional pipeline module.

[0096] 3.2 Channel chain monitoring module

[0097] Link monitoring is used to allow users to identify that the channel is still working normally when it stops sending data; rather than being able to distinguish whether the lack of data is due to normal suspension of transmission or hardware failure.

[0098] The channel module has no input devices, but has processes, algorithms, and output devices.

[0099] This method requires that the output device port can be shared and opened, and the output devices of the channel chain monitoring module and each data packet module under it select the same port. Each module sends its own data, and the data do not affect each other. This method is more efficient and occupies less resources than using shared memory for transition in the middle, especially when the data packets of different lengths under the channel are put into the shared memory at the same time, which is more difficult to manage.

[0100] When the cumulative period of each data packet under the channel is greater than 1s, the channel sends a link monitor and clears the cumulative period of each data packet. If you choose to send a link monitor frame, the data segment of the link monitor frame is filled with the time word containing the current time. The time word is updated once per second and the sending frequency is 1 time / s. If you choose to send a reframe, the situation is more complicated. Although the protocol does not explicitly require it, this method still uses the habit of treating the last data packet data in the channel as a reframe to overwrite the channel link monitor module sending buffer. However, many data packet modules do not know whether they are the last to stop sending. They can only overwrite the link monitor module's sending buffer with the data sent each time for each data packet. The data that is not covered in the end must be the last data to stop sending; compared with precise positioning (determining which submodule list has the smallest cumulative period before the channel link monitor meets the trigger condition), this processing logic is the simplest.

[0101] There are two ways to implement reframing: the data packet module pushes data - the data packet module uses Up to overwrite the sent data to the channel chain monitoring module's sending buffer, to (o->Buf, Up->o->Buf, PL); the channel chain monitoring module pulls data - the channel chain monitoring module scans and calls each data packet module process, saves the data packet's sending count before calling, and determines after calling that the sending count increases, that is, there is data to be sent, and copies the sent data from the data packet module's sending buffer to (Dn[k]->o->Buf, o->Buf, PL). The push method is simpler and can directly call the base class process; the pull method requires saving the sending count in advance and then calling the data packet module process, and then analyzing it, which is not exactly the same as the base class process and needs to be overloaded.

[0102] 3.3 Data Packet Module

[0103] The process of the data packet module generates various types of data segments through different algorithms. If the instruction packet is transmitted, the parameter segment in the instruction packet can also be generated. If there is no requirement for chain monitoring and sending multiple data packets in the channel, a single data packet module can also be used as an independent channel module.

[0104] The data cycle is the best for the process cycle of the data packet, that is, one interrupt sends one frame of data. If the cycle is smaller than the data cycle, the data is collected too early, there is no data or it is incomplete, and it will also exit and wait for the next cycle to process (from the perspective of the device, the cycle is too small, which is one-tenth of the data cycle, the process function calls are too dense, and the bottom stack entry and exit time is too large, which affects the CPU performance and even causes the cycle to slow down and interrupt delay). If the cycle is too large, which is more than ten times the data cycle, it will definitely cause data backlogs. More than ten frames of data or a large packet of data must be sent continuously, otherwise it will cause data delays; and there is no opportunity for uniform processing, and the instantaneous bit rate is off the charts. Both extremes are undesirable when exchanging data with external devices (displays, hard disks, communication ports, etc.).

[0105] There are two ways to handle the process of data transfer function: data driven and time driven.

[0106] aData-driven means that the process sends as much data as it collects when responding, regardless of the data cycle, and finishes the work as quickly as possible, leaving the idle time for the main functions in each terminal. This strategy is simple to implement, has a small code size, and reduces resource usage. As long as the bit rate of the data source is correct, there will be no problem. This method is usually used in a local area network.

[0107] b. If the bit rate of the data source is uneven, the bit rate is sometimes fast and sometimes slow. When it is fast, the amount of data in a single cycle will increase several times, exceeding the limit of the user's stress test, and the user program cannot handle it. At this time, the sender can only use time-driven to process the data evenly.

[0108] When b1 has hardware interrupt requirements, there is usually only one time code board in the terminal. When the data cycles are inconsistent, coordination is required. Fortunately, the timing cycle and data cycle sent in this application are integer multiples, or inverse integer multiples. Under precise timing, sometimes one interruption continuously sends multiple frames of data or a large packet; sometimes multiple interruptions only send one frame of data.

[0109] b2 When there is no requirement to use hardware interrupts, each data packet can use its own data cycle as the timing cycle to start an independent system thread, and use the system thread to simulate the hardware timing interrupt. The system thread is controlled by the operating system time slice. The advantage is that each data packet is in the best cycle efficiency; the disadvantage is that the delay of the timing interval far less than 50ms is somewhat large due to the influence of system resources. In this solution, the timer module happens to use the system thread to simulate hardware timing when the time code board cannot be searched. The method of counting the number of interrupts cannot eliminate the delay. The only way to retain the delay is to use the time alignment method, and when the delay accumulates to a data cycle, send one more frame of data. Specific implementation: divide the cumulative cycle (including the delay) by the data cycle and round it to get the number of frames read when sending n, execute n times to send a frame of data, and each time the sending is successful, subtract the data cycle from the cumulative cycle to retain the delay.

[0110] like Figure 1 As shown, a method for uniformly processing sent data includes the following steps:

[0111] Step 1: Create a project environment

[0112] 1.1 After the software is started, it reads information from the configuration file line by line.

[0113] 1.2 Restore the module from the information line

[0114] 1.21 Find the corresponding dynamic library name.dll through the module name at the front of the information line

[0115] 1.22 Export the CRun*GetObj() function, which contains:

[0116] CRun*p=new application class; / / Create module instance

[0117] return p; / / Return instance pointer

[0118] 1.23 Call this function to get the instance pointer CRun*p=GetObj()

[0119] 1.24 Save p to the submodule list and map it to the sub-leaf of the tree control window

[0120] 1.3 Restore parameters from the INFO line

[0121] Load the command line parameters through p->LoadPara(FILE*f) to restore the module parameters to the settings when the task exited last time;

[0122] The management layer derives the pipeline layer, and the pipeline layer derives the application layer. Each layer has its own parameters.

[0123] 1.31 Management layer, the module name is followed by the process start / stop flag bRun and Childk indicating that there are k submodules in the submodule list, and there will be at least k cycles to read out all k submodules. Finally, the user name is given.

[0124] For example:

[0125] Timer bRun1, Child2, data transmission

[0126] Channel chain monitoring bRun0, Child2, telemetry parameter channel

[0127] Pick bRun0, Child0, jsjz

[0128] GPS solves bRun0, Child0, positioning data

[0129] 1.32 Pipeline layer, with input and output devices, each device occupies 3 lines of information

[0130] A line includes the device name and command line arguments; for example:

[0131] No equipment

[0132] Shared memory memory address 0

[0133] File path and file name

[0134] moxa port 1, bit rate 9600

[0135] Network source ipx.xxx, destination ipx.xxx, group ipx.xxx, port number 0

[0136] A line includes the protocol name and the corresponding field parameters, and writes the fields into the send buffer, leaving the data segment for the application algorithm to fill in. For example:

[0137] No agreement

[0138] In area, Axx, Cxx, Bxx, L0

[0139] Inter-region, Axx, Cxx, Sxx, Dxx, Mxx, Bxx, L0, P0

[0140] Network, Mxx, Bxx, L0

[0141] A line contains data flow information, with input and output separated. For example

[0142] For the routing module, the data cycle is 50 and the data length is xx;

[0143] For the GPS solution module, the data cycle is 100 and the data length is xx;

[0144] 1.33 Application layer, a single line of information, including command line parameters. For example

[0145] For the timer module, the timing type and timing period;

[0146] For the routing module, routing mode, frame structure, and point mapping table;

[0147] The base class structure contains the topology:

[0148] CRun*Up; / / Pointer to the upper parent module

[0149] CRun*Dn

[10] ; / / List of submodules to be mounted: module array

[0150] 1.34 Append the new module to the parent module's list of submodules

[0151] 1.35 and save the parent module pointer to the new module's Up, Up = p (if it is the root, Up = NULL).

[0152] 1.4 If k>0, k-1, repeat sub-steps 1.21-1.35

[0153] 1.5 Read the entire configuration file in a loop, obtain the topology of the entire task, and display it completely in the tree control window.

[0154] From the function of topological structure, it can be divided into

[0155] 1.6 Add a timer module to the root of the tree control.

[0156] 1.7 Add multiple channel chain monitoring modules under the timer module.

[0157] 1.8 Add various data packet modules under the channel chain monitoring module.

[0158] set up

[0159] 1.9 Channel (chain monitoring) module and sub (data packet) module, their output devices open the same port at the same time.

[0160] step2: process control

[0161] The process base class (all classes derived from the base class have this process) is mainly used to calculate the time interval of the cycle, scan the sub-module list and call its application layer process.

[0162] Process Response

[0163] aRecord the current time

[0164] b calculates the time interval, which is equal to the current time minus the previous time

[0165] c scan submodule list

[0166] { / / Start of loop body, for each submodule

[0167] d Application layer process that calls the submodule

[0168] e is not scanned yet, repeat step de

[0169] } / / Scan completed, exit the loop

[0170] Exit Process

[0171] The pipeline process (all classes derived from the pipeline have this process) implements the sending frequency equalization processing: when the cumulative period (including delay) is greater than or equal to the data period, a frame of data is sent; when the sending is completed, the cumulative period minus the data period retains the delay.

[0172] Algorithm function: read a frame of raw data from the receiving buffer and put it into the data segment of the sending buffer (protocol grouping is performed when the protocol is selected);

[0173] Process Response

[0174] a calls the base class process (calculate the time interval, scan the submodule list and call its application layer process)

[0175] b cumulative cycle continuous superposition time interval

[0176] c Input device receives raw data and puts it into the receiving buffer

[0177] Success, receive count + round (received data length / data frame length) and the remainder is zero

[0178] / / For example, a large packet containing 10 frames of data is received in 1 second

[0179] d If the send count < receive count, there is data in the receive buffer

[0180] d1 calculates the number of frames read when sending n = round up (accumulated cycle / data cycle)

[0181] { / / The loop body starts, for each frame of data

[0182] eWhen n>0

[0183] f calls the algorithm function

[0184] Read a frame of raw data in the receive buffer

[0185] Data segment placed in the send buffer (protocol grouping is performed when a protocol is selected)

[0186] g Obtain the data packet length PL according to different protocols

[0187] h Output device sends PL byte, sending count + 1

[0188] iAccumulated period minus data period

[0189] j If Up is the chain monitoring module, read the data in the send buffer

[0190] Put it into the sending buffer of the channel chain monitoring module;

[0191] k, n-1, jump back to step e

[0192] } / / End of loop

[0193] Exit Process

[0194] 2.1 Initialization: Select the minimum value of the timing period as 50ms

[0195] 2.2 Timer module responds to hardware interrupts

[0196] Process response / / Because it is derived from the base class, the base class process is used directly by default

[0197] Calculate time interval

[0198] Scan the channel chain monitor list and call the channel chain monitor process;

[0199] Exit Process

[0200] 2.3 Channel chain monitoring module

[0201] Derived from the pipeline, inheriting the output device; overload process: calling the management process, sending a link monitor or reframe when there is no data packet sent on the channel and the conditions are met, no equalization processing is required.

[0202] Process Response

[0203] a calls the process base class (calculate the time interval, scan the submodule list and call its application layer process)

[0204] b When the cumulative period of all data packets is greater than 1s

[0205] {

[0206] b1 If you choose to send a link monitor, the link monitor frame will overwrite the send buffer;

[0207] (If reframe is selected, the data packet module has overwritten the send buffer of the channel link monitoring module through Up after completing data transmission)

[0208] b2 executes the sending function of the output device;

[0209] b3 sending completed, clear the accumulated cycle of each data packet module;

[0210] }

[0211] Exit Process

[0212] 2.4 Data Packet Module

[0213] Use pipeline process by default (skip scanning submodules since there are no submodules).

[0214] Overload algorithm functions.

[0215] For the path selection module, the path selection method can be selected from sub-frame path selection, sub-frame path selection, and multiple full-frame point selection; through the algorithm function, the original data (full-frame data) is converted into result data (selected fast-changing parameters or slowly-changing parameters).

[0216] For the solution module, the GPS raw data is converted into result data (positioning data) through the algorithm function.

[0217] The situation in Table 1 is as follows: the solution terminal generates positioning data, the data cycle is 100ms, and the transmission uses a 50ms thread simulation interrupt and data drive. When replaying data, file acquisition and network transmission use independent threads. In order to avoid affecting the transmission process, the acquisition cycle is selected as 1s, causing the solution terminal output to send 10 frames of data every 1s, and the instantaneous bit rate has increased by 10 times. Later, the user cannot handle it, and needs to evenly process the transmission frequency at the communication terminal, sending a frame of data every 100ms.

[0218] Table 1. The communication terminal uses the hardware interrupt of the time code board and the sending status of the timing period of 50ms

[0219]

[0220]

[0221] As shown in Table 1, this method solves the problem of inaccurate instantaneous bit rate. The bold time in the relative time indicates the data, and the same applies to the following.

[0222] Table 2. Communication terminal uses thread software to simulate interrupts. Resources are tight. The timing cycle is 50ms and the real-time monitoring is 60ms.

[0223]

[0224]

[0225] As shown in Table 2, the instantaneous bit rate is not accurate and the interruption time interval is not accurate. Although it is not ideal, the uniformity is optimized from 10 frames in 1s to 3 frames in 300ms. The instantaneous bit rate does not reach 2 times the standard and does not exceed the stress resistance limit of the receiving software.

[0226] Table 3 shows the sending status of the communication terminal using thread software simulation interrupt, tight resources, timing cycle selection of 50ms, real-time monitoring of 60ms, and data cycle of 50ms.

[0227]

[0228] As shown in Table 3, when the delay time accumulates to one data cycle, an additional frame of data is sent. The mechanism implemented is that when the accumulated cycle is n times the data cycle, it is sent n times continuously. Table 4 shows the sending status when the communication terminal uses thread software simulation interrupt, resources are tight, the timing cycle is selected as 50ms, the real-time monitoring is 60ms, the data cycle is 25ms, and n = rounded (accumulated cycle / data cycle)>1

[0229]

[0230]

[0231] As shown in Table 4, when n>1, the bit rate in a single interrupt response will change. For example, if a file is played back with a 1-second interrupt to read 10 packets of data, the original instantaneous bit rate will be excessively damaged. Unless the user has special requirements, it is best for each data packet to use its own data cycle as the timing cycle for sending data if conditions permit.

[0232] The above description is only a preferred specific implementation manner of the present invention, but the protection scope of the present invention is not limited thereto. Any technician familiar with the technical field can make equivalent replacements or changes according to the technical scheme and inventive concept of the present invention within the technical scope disclosed by the present invention, which should be covered by the protection scope of the present invention.

Claims

1. A visual data transmission platform, characterized in that: The application class of the application layer is encapsulated through the dynamic link library DLL. The parent module searches for the submodule and reads, writes and calls the submodule variables through the tree structure outside the DLL. The root module responds to the hardware interrupt of the code board or the system thread simulation interrupt, scans the submodule list at the management level and calls the application layer process of the submodule, so that the application layer processes of all modules in the platform are executed in series under the same interrupt, so that the telemetry data is sent evenly. The visual data transmission platform includes a management layer, a pipeline layer derived from the management layer, and an application layer partially derived from the management layer and partially derived from the pipeline layer; The management layer uses CRun as the process base class, including a process interface that responds to interrupts, a start / stop flag for controlling the process, and a display interface; the process interface function calculates the time interval for process loop calls, scans the submodule list, and calls the application layer process of the submodule; the display interface function displays the time interval for process logs; The pipeline layer overloads the process interface function to achieve the homogenization of data stream transmission; including input ports, output ports and algorithm interfaces; the algorithm interface function reads a frame of raw data from the receiving buffer and puts it into the data segment of the sending buffer (protocol grouping is performed when the protocol is selected); when overloading the process interface function, the management layer process is first called, and then the delay time is calculated according to the cumulative cycle of the time interval superposition and the data cycle, and the homogenization of data stream transmission is performed; The application layer includes a timer module, a channel chain monitoring module and a data packet module which are added and set in sequence; the timer module is derived from the management layer and sets the time code board; the channel chain monitoring module enables the user to identify whether the output port of the channel is still working normally when the channel stops sending data; the data packet module inherits the data stream sending uniformization processing of the pipeline layer, and can draw curves according to the application overload display interface function or overload algorithm interface function to generate various types of result data through different algorithms and output them to the output port.

2. A visual data sending platform according to claim 1, characterized in that: The visual data sending platform uses variables to describe properties and functions to implement methods in the class structure; the DLL only exports one function CRun*GetObj(), and each time GetObj() is called outside the DLL, an instance is generated inside the DLL, and a returned base class pointer is obtained outside the DLL and saved in the submodule list and mapped to the sub-leaf of the tree structure; the parent module outside the DLL searches for the submodule through the tree structure and reads and writes the variables and calls the functions of the submodule; The function CRun*GetObj() only includes two statements: CRun*p=new application class; return p; the function CRun*GetObj() generates an instance and obtains the instance address and assigns it to the pointer p, and then returns the pointer to the DLL for external use.

3. A visual data transmission platform according to claim 1, characterized in that: The process base class structure of the management layer includes a topological structure and can add submodules; when the start / stop flag bRun in the submodule is 1, the system thread is started to independently call the application layer process of the submodule, and the process of the parent module no longer calls the submodule process; when the start / stop flag bRun is 0, the application layer process of the submodule is called as a function by the parent module process to achieve serial execution; The management layer includes a property page pointer CPropertyPage*, an import parameter LaodPara (FILE*f), and a save parameter SavePara (FILE*f); the property page pointer allows multiple dialog boxes to be combined and set together; According to different task requirements, modify the value of the variable through the parameter setting dialog box in the property page. When the framework exits, call each module SavePara(FILE*f) to write the variable back to the configuration file. When entering the framework next time, call each module LoadPara(FILE*f) to import the parameters of the previous task from the configuration file.

4. A visual data transmission platform according to claim 1, characterized in that: The pipeline layer is derived from the management layer, and the process interface function is overloaded to realize the uniform processing of data stream transmission: the cumulative cycle is divided by the data cycle and then rounded to get the number of frames n read when sending, and one frame of data is sent n times. Each time the transmission is successful, the cumulative cycle is subtracted from the data cycle retention delay, and the cumulative cycle includes the delay; The pipeline layer manages input devices and output devices, and the device management options support no device, shared memory, file, serial port, and network; The pipeline layer can overload the display interface function to display the original hexadecimal code of the data stream; Directed pipeline: Under the premise that the pipeline layer does not change the algorithm for processing the telemetry data stream, different applications can be expanded by only changing the input and output devices; Outputting data stream to a file is for data storage, and inputting data from a file is for data playback; The input and output of shared memory is the data exchange between dynamic libraries; the input and output of network and serial ports is the distributed processing between terminals; The data stream is sent to the printer to print the original data, the data stream is sent to the image decoder to play pictures and videos, and the data stream is sent to the GPS solution terminal to calculate the positioning data and then sent to the projection screen to display the movement trajectory of the tracked target; the pipeline layer is used as a built-in application module for users to use.

5. A visual data transmission platform according to claim 1, characterized in that: The application layer supports timers, channel link monitoring, route selection and packet assembly, GPS calculation and full frame arrangement, and directional pipeline; The timer module is directly derived from the management layer; the timer module is in search mode and can use the time code board for hardware timing, and automatically starts the system thread simulation timing when the time code board cannot be found; during hardware timing, the timing period and the data period are integer multiples or reverse integer multiples; The channel chain monitoring module includes a process interface, an algorithm interface and an output device, but does not include an input device; the output device port can be shared and opened, the output devices of the channel chain monitoring module and the data packet module both select the same port, and the data of the channel chain monitoring module and the data packet module do not affect each other; When the cumulative period of one or more data packet modules included in the channel link monitoring module is greater than 1s, the channel link monitoring module outputs a link monitoring frame or a reframe and clears the cumulative period of each data packet module; The data segment of the chain monitoring frame is filled with a time word containing the current time, the time word is updated once per second, and the sending frequency is 1 time / s; The reframe is the last data packet data stopped in the channel. The reframe is obtained by: the data packet module sends the data that has been sent in this round to the channel chain monitoring module through Up to cover the buffer. When the channel chain monitoring module contains at least two data packets, the last data to be stopped is not covered; The data packet module generates various types of data segments through different algorithms. If the instruction packet is transmitted, the parameter segment in the instruction packet can also be generated; the data packet module includes a link monitoring module, a path selection module, a solution module, a directional pipeline module, and a full frame sorting module; The application layer overloads the display interface function and then draws the curve; the display window interface can pop up a floating menu for selecting display log, display original code, and display curve.

6. A visual data transmission platform according to claim 1, characterized in that: The visual data transmission platform is installed on a communication terminal, and at least two demodulation terminals, a solution terminal and the communication terminal form a local area network to perform distributed telemetry data processing; The intermediate frequency signal of the demodulation terminal generates subframe data after hardware demodulation, which is converted into full-frame data that can be directly used by the user through full-frame arrangement, and then distributed to the communication terminal and the solution terminal through the group address broadcast of the network; the full-frame arrangement includes synchronizing the subframe data into full-frame data, eliminating the full-frame with error code and correcting the time word; The solution terminal extracts GPS raw data from the subframes in the subframe channel of the full-frame data, displays satellite channels and parameter indicators, draws a satellite sky map, obtains GPS positioning data and sends it to the communication terminal; The visual data sending platform of the communication terminal receives the full frame data and puts it into the shared memory, and selects the fast-changing parameters through the sub-frame, selects the slow-changing parameters through the sub-frame, or selects the computer words through multiple full-frames; the fast-changing parameters include voltage, current and temperature; the slow-changing parameters include full-frame count, impact, vibration and pressure; the shared memory allows multiple selection modules to access it at the same time; The communication terminal performs protocol encapsulation and packaging of the GPS positioning data, the fast-changing parameters, the slowly-changing parameters and the computer words, and then sends them to the user at different data cycle times.

7. A visual data transmission platform according to claim 1, characterized in that: The input port includes the receiving buffer for protocol unpacking; the output port includes the sending buffer for protocol packet assembly; the input port and the output port support no device, shared memory, file, serial port, network; the protocol list options include no protocol, intra-region protocol, inter-region protocol and network protocol.

8. The data homogenization processing method of a visualization data transmission platform according to any one of claims 1 to 7, characterized in that: The following steps are involved: S1, the data packet module uses the pipeline layer process and overloads the algorithm function; S2, the process of the pipeline layer calls the process of the management layer: records the current time and calculates the time interval according to the last recorded time and the current time, then scans the sub-module list and calls the application layer process of each sub-module in turn; S3, the pipeline layer accumulation cycle continuously superimposes the time interval; the receiving port receives the original data and puts it into the receiving buffer; the length of the received data is divided by the length of the data frame, and the remainder is rounded to zero to obtain the current receiving count, and the count is accumulated into the receiving count; When the sending count is less than the receiving count, there is data in the receiving buffer, the accumulated period is divided by the data period and then rounded to obtain the number of frames n read during sending to implement homogenization processing; S4, when n>0, the algorithm function is called, the data packet module converts the original data in the receiving buffer into the result data and puts it into the data segment of the sending buffer for protocol packetization to obtain the data to be output; the data packet length PL is obtained according to the data protocol, and the output end sends PL bytes; When the transmission is successful: the transmission count + 1; the cumulative cycle minus the data cycle to obtain the delay time; the data in the transmission buffer is copied to the channel link monitoring module transmission buffer as a reframe standby; the frame number n is read minus 1; Return to step S4; S5, when there is no data packet to be sent on the channel and the sending condition is met, the channel link monitoring module sends a link monitoring frame or a reframe, and no homogenization processing is required; S51, the channel chain monitoring module reloads the pipeline layer process: calls the management layer process, calculates the time interval, scans the sub-module list and calls the application layer process of the sub-module; S52, when the accumulated period of all data packet modules is greater than 1s: if the link monitoring frame is selected, the link monitoring frame is used to cover the sending buffer; if the reframe is selected, the data packet module has obtained the reframe by overwriting the sending buffer of the channel link monitoring module through Up after completing data transmission; S53, executing the sending function of the output device; S54, sending is completed, and the accumulated cycle of each data packet module is cleared.

9. The data homogenization processing method of a visualization data transmission platform according to claim 8, characterized in that: The channel chain monitoring module includes a telemetry data channel chain monitoring module and an external measurement data channel chain monitoring module; a slowly changing parameter data packet module and a rapidly changing parameter data packet module are added under the telemetry data channel chain monitoring module; a positioning data data packet module is added under the external measurement data channel chain monitoring module; In step S1, the slowly changing parameter data packet module, the rapidly changing parameter data packet module and the positioning data data packet module all use pipeline layer processes and overload algorithm functions; The process response in step S2 is: calculate the time interval; (there is no submodule in the lower layer); In step S51, the application layer process of the telemetry data channel link monitoring module calls the management layer process through the overloaded pipeline layer process: calculates the time interval, scans the sub-module list and calls the application layer process of the slowly changing parameter data packet module and the rapidly changing parameter data packet module; then the application layer process of the external measurement data channel link monitoring module calls the management layer process through the overloaded pipeline layer process: calculates the time interval, scans the sub-module list and calls the application layer process of the positioning data packet module.

10. The data homogenization processing method of a visualization data transmission platform according to claim 8, characterized in that: In step S4, when the data packet module is a routing module, the routing method can be: selecting subframe routing, sub-frame routing, and multiple full-frame routing points, and converting the full-frame data into routing data through an algorithm function; when the data packet module is a solution module, the GPS raw data is converted into positioning data through an algorithm function.

Images