Node simulation and monitoring system and method based on time-triggered protocol, electronic equipment, medium and program product

Abstract

The invention provides a node simulation and monitoring system and method based on a time-triggered protocol, electronic equipment, a medium and a program product. The system comprises a node module, a message module and an interactive interface module. The node module is used for defining and simulating a plurality of specific nodes in the TTP network; the message module is used for managing a data structure transmitted by the TTP network and comprises a message packet and a message parameter; the interactive interface module is constructed based on a Qt framework and provides a graphical interface for node selection, message classification selection, parameter input / display and performance index visualization. According to the invention, flexible simulation of TTP network nodes and deep monitoring and performance analysis of network data can be supported at the same time, the problems of single function, poor interactivity and insufficient expansibility in the prior art are solved, and the development and test efficiency and user experience of the TTP network are remarkably improved.

Description

Technical Field

[0001] This application relates to the field of communication network testing and monitoring technology, and in particular to a node simulation and monitoring system and method, electronic equipment, media and program products based on a time-triggered protocol. Background Technology

[0002] Time-Triggered Protocol (TP) is a deterministic real-time communication protocol used in safety-critical fields, widely applied in avionics, rail transportation, and automotive control. During the research, development, integration, testing, and maintenance phases of TTP networks, dedicated host computer software tools are typically needed to simulate network node behavior and monitor network data in order to verify the correctness of the network protocol, evaluate network performance, and diagnose faults.

[0003] Currently, tools used for TTP networks in the market and academia can be mainly divided into two categories: simulation tools and monitoring tools.

[0004] The first category consists of network simulation and testing tools, such as the CANoe.TTP plugin from Vector GmbH in Germany. These tools typically employ a client / server (C / S) architecture, with their core function being the configuration and simulation of one or more virtual TTP nodes. They can interact with the real network to perform conformance testing and partial functional testing. They usually possess deep protocol parsing engines and offline analysis capabilities. However, these tools have significant limitations: First, their sending and receiving modules are often tightly coupled, resulting in strong hardware dependencies and a rigid system architecture, making functional expansion and customization difficult. Second, while they support multi-node configuration, their ability to flexibly and cost-effectively replace any specific node in the network for targeted testing in actual simulation tasks is insufficient. Third, these tools primarily focus on protocol-level simulation and testing, lacking in-depth analysis capabilities that provide real-time, intuitive visualization of overall network performance (such as end-to-end latency and link throughput).

[0005] The second category consists of network monitoring and analysis tools, such as TTP Monitor based on NI LabVIEW or some open-source projects (like OpenTTP Viewer). These tools primarily operate through passive listening, capturing network traffic (e.g., using PCAP technology) to mirror and display data on the TTP bus. They can present basic information such as message identifiers and data bytes in tabular or simple chart formats, and some tools even offer lightweight browser-based access. However, these tools also have significant limitations: First, they can only passively receive and display data, unable to actively construct and send test messages conforming to the TTP protocol, meaning they lack the ability to actively simulate nodes and cannot be used for active testing scenarios such as injecting test stimuli or simulating node failures. Second, their data analysis capabilities are relatively superficial, usually limited to message parsing, making it difficult to parse the raw byte stream into physical parameters with clear engineering significance (such as voltage, temperature, and switching states) based on user-defined signal mapping relationships, let alone calculate and display high-order performance indicators in real time. Third, their graphical user interfaces (GUIs) are mostly developed based on outdated frameworks such as LabWindows / CVI or Microsoft Foundation Classes (MFC), resulting in poor user interface interaction and poor cross-platform portability, making it difficult to adapt to the needs of modern software development and deployment.

[0006] Therefore, there is an urgent need in this field for a TTP host computer solution that can deeply integrate simulation and monitoring functions, has a user-friendly interface and good cross-platform capabilities, and can provide rich performance analysis data. Summary of the Invention

[0007] This application provides a node simulation and monitoring system and method based on a time-triggered protocol to solve the problems of limited functionality, poor interactivity, and insufficient scalability in existing technologies.

[0008] In a first aspect, this application provides a node simulation and monitoring system based on a time-triggered protocol, comprising: The node module is used to define and simulate multiple specific nodes in a TTP network. Each specific node includes a node name, node identifier, a list of sent / received message parameters, and a list of sent / received message packets. The message module is used to manage the data structure of TTP network transmission, including message packets and message parameters. The message parameters correspond to specific fields in the message packet. The main attributes of the message packet include message packet name, msgbox_id, task_id, length, sender, and message parameter list. The main attributes of the message parameters include parameter name, message category, data type, source / destination node, message packet, starting offset in the message packet, and length in the message packet. The interactive interface module, built on the Qt framework, provides a graphical interface for node selection, message category selection, parameter input / display, and performance indicator visualization. In simulation mode, the system is configured such that the node module can simulate the behavior of any selected node, receive user-input message parameter values ​​through the interactive interface module, assemble them into message packet byte streams through the message module, and send them to the TTP network. It can also receive message packet byte streams from the TTP network, parse them through the message module, and display them through the interactive interface module. In monitoring mode, the system passively receives and parses TTP network data streams, and displays message parameter values ​​and network performance indicators in real time through the interactive interface module.

[0009] Preferably, the interactive interface module includes: The sending function interface includes a target node selection control, a message category selection control, a message parameter input control corresponding to the selected message category, and a sending trigger control; The receiving / monitoring interface includes a source node selection control, a message category selection control, a message parameter display control corresponding to the selected message category, a data synchronization control, and a network performance indicator visualization area.

[0010] Preferably, the message packets in the message module are mapped to MSGBOX in the TTP design tool and include message packet name, message packet identifier, task identifier, length, sender, and message parameter list attributes.

[0011] Preferably, the network performance indicators include at least one of the following: message transmission latency and network throughput.

[0012] Secondly, this application also provides a node simulation and monitoring method based on a time-triggered protocol, applied to the aforementioned node simulation and monitoring system based on a time-triggered protocol, comprising the following steps: System initialization steps: Run the host computer program, initialize the hardware interface, and initialize the simulation node or monitoring node according to the mode selected by the user; Graphical interface display steps: Display the interactive interface built based on the Qt framework; Simulation transmission steps: Respond to user operations on the interface, obtain the selected target node, message category and input message parameter values, convert the message parameter values ​​into byte stream data of the corresponding message packet, and send them to the TTP network; Simulation receiving and monitoring steps: Receive message packet byte streams from the TTP network, parse the message parameter values ​​according to the predefined mapping relationship between message parameters and message packet fields, and update and display them on the interface; at the same time, calculate and visualize network performance indicators.

[0013] Preferably, the simulation receiving and monitoring step further includes: the user selects the source node and message category through the interface to filter the message parameters to be displayed, and updates the interface to display the latest parsed data by triggering the synchronization control.

[0014] Preferably, the network performance indicators include at least one of the following: message transmission latency and network throughput.

[0015] Thirdly, this application also provides an electronic device, including: a processor, a memory, and a program stored in the memory and executable on the processor, wherein when the program is executed by the processor, it implements the steps of the node simulation and monitoring method based on the time-triggered protocol described above.

[0016] Fourthly, this application also provides a computer-readable storage medium storing a computer program, which, when executed by a processor, implements the steps of the above-described node simulation and monitoring method based on a time-triggered protocol.

[0017] Fifthly, a computer program product includes computer instructions that, when executed by a processor, implement the steps of the above-described node simulation and monitoring method based on a time-triggered protocol.

[0018] Compared with the prior art, this application has the following significant advantages: 1. Highly integrated functions: It integrates node simulation (send / receive) and network monitoring (performance analysis) functions into one platform, so that the main tasks of TTP network development and testing can be completed on one platform, which improves work efficiency.

[0019] 2. High simulation flexibility: Through configurable node modules, it is possible to simulate any node in the network topology, flexibly replacing physical nodes for testing, reducing testing costs and complexity.

[0020] 3. In-depth monitoring and analysis: It can not only monitor raw packets, but also parse out parameters with business significance, and calculate and display key performance indicators such as latency and throughput in real time, providing intuitive data support for network performance evaluation.

[0021] 4. High software quality: Developed using the Qt framework, the interface is beautiful and the interaction is smooth. The code structure is clear, maintainable and scalable, and it natively supports multiple operating systems such as Windows and Linux, making it easy to deploy and promote. Attached Figure Description

[0022] To more clearly illustrate the technical solutions in this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0023] Figure 1 This is a schematic diagram of the structure of the host computer node module provided in Embodiment 1 of this application; Figure 2 This is a schematic diagram of the structure of the host computer message module provided in Embodiment 2 of this application; Figure 3 This is a schematic diagram of the structure of the host computer interaction interface module provided in Embodiment 3 of this application; Figure 4 This is a flowchart illustrating the working principle of the host computer provided in Embodiment 4 of this application. Detailed Implementation

[0024] To make the objectives, technical solutions, and advantages of this application clearer, the technical solutions of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0025] The terms "first," "second," etc., used in the specification, claims, and accompanying drawings of this application are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such use of data can be interchanged where appropriate so that the embodiments described herein can be implemented in a sequence other than that illustrated or described herein.

[0026] This embodiment provides a node simulation and monitoring system based on a time-triggered protocol, including a node module, a message module, and an interactive interface module. The node module defines and simulates multiple specific nodes in a TTP network. Each specific node inherits from an abstract node class containing common member variables and event handling functions, and includes a node name, node identifier, a list of sent / received message parameters, and a list of sent / received message packets. The message module manages the data structure transmitted in the TTP network, including message packets and message parameters. Message parameters correspond to specific fields in the message packet. The main attributes of a message packet include the message packet name, msgbox_id, task_id, length, sender, and message parameter list. The main attributes of a message parameter include the parameter name, message category, data type, source / target node, message packet, starting offset within the message packet, and length within the message packet. The interactive interface module, built on the Qt framework, provides a graphical interface for node selection, message category selection, parameter input / display, and performance indicator visualization. In simulation mode, the system is configured such that the node module can simulate the behavior of any selected node, receive user-input message parameter values ​​through the interactive interface module, assemble them into message packet byte streams through the message module, and send them to the TTP network. It can also receive message packet byte streams from the TTP network, parse them through the message module, and display them through the interactive interface module. In monitoring mode, the system passively receives and parses TTP network data streams, and displays message parameter values ​​and network performance indicators in real time through the interactive interface module.

[0027] See Figures 1 to 4 The present invention provides a node simulation and monitoring system based on the Time Trigger Protocol (TTP). Its core lies in the collaborative design of three major modules. The following is a detailed description of a specific application scenario—a 4M TTP network of an airborne power system. The TTP network includes eight nodes: LBPCU, RBPCU, LGCU, RGCU, RPDU11M1, RPDU11M2, RPDU12M1, and RPDU12M2.

[0028] like Figure 1As shown, the node module configuration in this embodiment adopts an object-oriented design approach. First, an abstract node base class (e.g., AbstractTTPNode) is defined. This class encapsulates the common attributes (such as node_id, node_name) and common behavioral interfaces (such as the virtual function handleMessage() for handling network events) of all TTP nodes. Then, for each specific physical node in the network, a concrete node class derived from this abstract base class is created (e.g., LBPCU_Node, RGCU_Node). In addition to inheriting the common attributes, each concrete node class also possesses its own unique attributes, such as pointers or references to its own list of send / receive message parameters and message packets. This design allows the system to flexibly configure and simulate any node in the network by simply instantiating different concrete node class objects.

[0029] like Figure 2 As shown, in this embodiment, the message module is the key to connecting user logic and network byte stream. This module mainly contains two core entities: MessageBox (message packet) and MessageParameter (message parameter).

[0030] The MessageBox class directly corresponds to the MSGBOX defined in TTP design tools (such as TTPDesign). Its main attributes include: msgbox_id (unique identifier), task_id, length (byte length), sender_node (pointer to the sender node), and a list of MessageParameter objects. It represents the actual data unit transmitted on the TTP network.

[0031] The MessageParameter class provides intuitive engineering meaning for users, such as "generator voltage" or "circuit breaker status." Its key attributes include: param_name, data_type (e.g., int16, uint32, bool), parent_msgbox (the associated MessageBox object), byte_offset (the starting byte position in the associated message packet), bit_length (the bit length of the field, used to handle non-byte aligned signals), and optional scaling factors and offsets for physical value conversion. Each MessageParameter object precisely describes how to extract or inject a specific user-defined parameter value from or into the MessageBox's byte stream.

[0032] When the system starts, it can read and create the above objects and their relationships in batches from the EoICD (Excel spreadsheet) or XML configuration file exported from the TTP design tool, thereby dynamically building a complete network message database.

[0033] like Figure 3 As shown, the interactive interface module in this embodiment uses the Qt framework to build the user interface, which has good cross-platform compatibility and a modern interactive experience. The main interface is organized using tabs (QTabWidgets) and mainly includes two core pages: "Simulation Sending" and "Monitoring Receiving".

[0034] The simulation sending interface features a "Target Node" dropdown selection box (QComboBox) at the top, with its option list dynamically bound to all simulable nodes in the node module. After the user selects a target node (e.g., "RGCU"), a group of message category buttons (e.g., QButtonGroup) appears in the middle of the interface. Selecting a category (e.g., "Status Information") dynamically generates input controls (e.g., QDoubleSpinBox for floating-point numbers, QCheckBox for boolean values) corresponding to all MessageParameters under that category in the main body of the interface (e.g., QDoubleSpinBox for floating-point numbers, QCheckBox for boolean values). Each control has a clear parameter name label. A "Send" button (QPushButton) is prominently displayed on the interface. When the user enters the parameters and clicks send, the interface layer passes the input values ​​to the message processing logic. Through configurable node modules, any node in the network topology can be simulated, flexibly replacing physical nodes for testing, reducing testing costs and complexity.

[0035] The monitoring receiving interface has a similar layout to the sending interface, but different functionality. At the top is a "Source Node" selection box for filtering monitored objects. Message category selection is also available. The main body of the interface dynamically generates labels (QLabels) or read-only text boxes to display parameter values. A "Synchronize" button is added for manually triggering an interface refresh. Additionally, this interface has a separate "Performance Dashboard" area (which can use QChartView) for plotting network latency curves and throughput bar charts. In-depth monitoring and analysis not only monitor raw packets but also parse out business-meaning parameters and calculate and display key performance indicators such as latency and throughput in real time, providing intuitive data support for network performance evaluation.

[0036] like Figure 4 As shown, the workflow of the node simulation and monitoring method based on the time-triggered protocol is as follows: S1: System initialization steps. Run the host computer program, initialize the hardware interface, and initialize the simulation node or monitoring node according to the mode selected by the user.

[0037] S101: Start the program and perform basic software environment initialization.

[0038] S102: Initialize the driver for the hardware board (such as the TTP-PCIe card) that communicates with the TTP network and establish a physical connection.

[0039] S2: Graphical interface display steps. Displays an interactive interface built on the Qt framework.

[0040] S201: Based on the mode specified by the user at startup or selected through the interface: If it is in "simulation" mode, the corresponding specific node class object (such as LGCU_Node) will be instantiated according to the node name selected by the user, and its state initialization will be completed.

[0041] If it is in "monitoring" mode, it will enter a passive listening state and wait for the user to specify the monitoring node through the interface.

[0042] S202: Load and display the main graphical interface based on the Qt framework.

[0043] S3: Simulation of transmission steps. Responding to user actions on the interface, the system obtains the selected target node, message category, and input message parameter values. It then converts these message parameter values ​​into byte stream data for the corresponding message packet and sends it to the TTP network.

[0044] Specifically, the user completes a series of operations on the "Simulation Sending" interface: select the target node -> select the message category -> the interface dynamically generates input controls -> the user inputs / modifies the values ​​of each message parameter -> clicks the "Send" button. The background logic responds to the click event: the message module finds the corresponding MessageBox template based on the currently selected target node and message category; then it iterates through the MessageParameter list below it, filling the byte buffer of the MessageBox with the values ​​entered by the user on the interface according to the byte_offset and bit_length of each parameter; finally, the communication module sends this buffer as a TTP message packet to the real TTP network through the hardware interface.

[0045] S4: Simulation Reception and Monitoring Steps. This step receives message packet byte streams from the TTP network, parses the message parameter values ​​according to the predefined mapping relationship between message parameters and message packet fields, and updates the display on the interface. Simultaneously, it calculates and visualizes network performance metrics. Specifically, this branch includes the reception of the simulation node and pure network monitoring.

[0046] S401: Data Reception. The communication module continuously receives message packet byte streams from the TTP network and stores them in a shared circular data buffer.

[0047] S402: Data Parsing and Display (for Monitoring / Simulation Reception). When the user selects a source node and message category on the "Monitoring Reception" interface and clicks the "Synchronize" button, the background thread filters the latest message packets from that node in the buffer. Then, the message module parses the values ​​of each parameter from the specified position of the message packet byte stream according to the mapping relationship defined in MessageParameter, and updates the corresponding display controls on the interface through Qt's signal and slot mechanism.

[0048] S403: Performance Analysis (Continuously Running in the Background): A separate performance analysis thread continuously processes all message packets in the buffer (not limited to those filtered by the interface). It calculates the transmission latency of a single message by comparing the message's send timestamp (which can be deduced from the message itself or the scheduler) and receive timestamp, and calculates the average latency, maximum / minimum latency, and jitter within a sliding time window. Simultaneously, it periodically (e.g., every second) counts the total amount of data received and calculates the real-time network throughput. These calculation results are transmitted to the interface module in real time, dynamically updating the charts and figures in the "Performance Dashboard."

[0049] The above embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application.

Claims

1. A node simulation and monitoring system based on a time-triggered protocol, characterized in that, include: The node module is used to define and simulate multiple concrete nodes in a TTP network. Each concrete node inherits from the abstract node class, which contains public member variables and event handling functions, and includes a node name, node identifier, a list of sent / received message parameters, and a list of sent / received message packets. The message module is used to manage the data structure of TTP network transmission, including message packets and message parameters. The message parameters correspond to specific fields in the message packet and have attributes such as parameter name, data type, starting offset in the message packet, and length. The interactive interface module, built on the Qt framework, provides a graphical interface for node selection, message category selection, parameter input / display, and performance indicator visualization. The system is configured as follows: In simulation mode, the node module can simulate the behavior of any selected node, receive user-input message parameter values ​​through the interactive interface module, assemble them into message packet byte streams through the message module, and send them to the TTP network. It can also receive message packet byte streams from the TTP network, parse them through the message module, and display them through the interactive interface module. In monitoring mode, the system passively receives and parses TTP network data streams, and displays message parameter values ​​and network performance indicators in real time through the interactive interface module.

2. The node simulation and monitoring system based on a time-triggered protocol according to claim 1, characterized in that, The interactive interface module includes: The sending function interface includes a target node selection control, a message category selection control, a message parameter input control corresponding to the selected message category, and a sending trigger control; The receiving / monitoring interface includes a source node selection control, a message category selection control, a message parameter display control corresponding to the selected message category, a data synchronization control, and a network performance indicator visualization area.

3. The node simulation and monitoring system based on a time-triggered protocol according to claim 1, characterized in that, The message packets in the message module are mapped to MSGBOX in the TTP design tool and include message packet name, message packet identifier, task identifier, length, sender, and message parameter list attributes.

4. The node simulation and monitoring system based on a time-triggered protocol according to claim 1, characterized in that, The network performance metrics include at least one of the following: message transmission latency and network throughput.

5. A node simulation and monitoring method based on a time-triggered protocol, applied to the node simulation and monitoring system based on a time-triggered protocol as described in any one of claims 1-4, characterized in that, Includes the following steps: System initialization steps: Run the host computer program, initialize the hardware interface, and initialize the simulation node or monitoring node according to the mode selected by the user; Graphical interface display steps: Display the interactive interface built based on the Qt framework; Simulation transmission steps: Respond to user operations on the interface, obtain the selected target node, message category and input message parameter values, convert the message parameter values ​​into byte stream data of the corresponding message packet, and send them to the TTP network; Simulation receiving and monitoring steps: Receive message packet byte streams from the TTP network, parse the message parameter values ​​according to the predefined mapping relationship between message parameters and message packet fields, and update and display them on the interface; at the same time, calculate and visualize network performance indicators.

6. The node simulation and monitoring method based on a time-triggered protocol according to claim 5, characterized in that, The simulation receiving and monitoring steps further include: the user selects the source node and message category through the interface to filter the message parameters to be displayed, and updates the interface to display the latest parsed data by triggering the synchronization control.

7. The node simulation and monitoring method based on a time-triggered protocol according to claim 5, characterized in that, The network performance metrics include at least one of the following: message transmission latency and network throughput.

8. An electronic device, characterized in that, include: A processor, a memory, and a program stored in the memory and executable on the processor, wherein the program, when executed by the processor, implements the steps of the node simulation and monitoring method based on the time-triggered protocol as described in any one of claims 5 to 7.

9. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program that, when executed by a processor, implements the steps of the node simulation and monitoring method based on the time-triggered protocol as described in any one of claims 5 to 7.

10. A computer program product, characterized in that, It includes computer instructions that, when executed by a processor, implement the steps of the node simulation and monitoring method based on the time-triggered protocol as described in any one of claims 5 to 7.

Images