A simulation platform and method for devices with high timing requirements

Abstract

The present invention proposes a simulation platform and method for devices with high timing requirements. The simulation platform includes: a development system, the development system includes: an object editing module to be simulated, which obtains basic information of the object to be simulated, timing feature information and ICD description information, and determines the simulation target; a resource configuration module, which determines the RTOS version, configures the application basic resource library, configures the algorithm library, the simulation device ICD template and the communication protocol to support the development of resident applications and completes the software ecosystem construction required for the deployment of resident applications; an application development module, which is used to develop resident applications for simulation devices and develop and compile timing control algorithms; an application deployment module, which is used to deploy the software ecosystem, resident applications and ICD constraints in sequence according to the constraint order. The simulation platform of the present invention realizes the synchronous simulation of the functions and performance of complex devices with high timing stability and timing reliability according to the functional characteristics and performance characteristics of the simulated object.

Description

Technical Field

[0001] The embodiments of the present disclosure relate to the field of device simulation technology, and in particular to a simulation platform and method for devices with high timing requirements. Background Art

[0002] Aerospace, aviation, navigation and other high-precision equipment usually have extremely high timing requirements. Traditional embedded simulation methods focus more on simulation functions and ignore the timing stability and reliability of simulation equipment, so their application scope is relatively narrow.

[0003] For example, in the aviation field, airborne equipment must pass airworthiness verification to ensure that the process from the generation of a signal stimulus to its sending to the bus requires N0 time with minimal fluctuation. In current simulation systems, the above process in the simulation equipment requires N1 time. Due to the lack of timing simulation control and the influence of the characteristics of the simulation equipment, N1 has a large range of fluctuations, which is quite different from the actual airborne equipment.

[0004] The application of a real-time multitasking operating system (RTOS) provides technical feasibility for achieving high-timing stability and reliability simulations. By combining an RTOS with timing simulation control technology, it is possible to achieve high-timing stability and reliability in device simulations. However, there is currently a lack of simulation platforms that utilize RTOS and the corresponding timing simulation control technology. Summary of the Invention

[0005] The purpose of the embodiments of the present disclosure is to provide a simulation platform and method for devices with high timing requirements, thereby solving the aforementioned problems existing in the prior art.

[0006] In order to achieve the above objectives, the technical solutions adopted in the embodiments of the present disclosure are as follows:

[0007] On the one hand, an embodiment of the present disclosure provides a simulation platform for devices with high timing requirements, which is applied to aviation, aerospace, and navigation-related equipment. The simulation platform includes: a development system, and the development system includes:

[0008] The object editing module to be simulated obtains the basic information, timing characteristics information and ICD description information of the object to be simulated, determines the simulation target, and simulates the timing characteristics and functional characteristics of the simulation device based on the obtained information;

[0009] The resource configuration module determines the RTOS version, configures the application basic resource library, configures the algorithm library, simulated device ICD template, and communication protocol to support the development of resident applications and complete the software ecosystem required for resident application deployment. It also has an extension library function for loading other third-party libraries, plug-ins, and API function content;

[0010] Application development module, used for developing resident applications for simulation devices and developing and compiling timing control algorithms to simulate the functional and performance characteristics of the object to be simulated;

[0011] The application deployment module uses the operating system deployment module, resource file deployment module, ICD synchronization module, communication protocol deployment module and resident application deployment module to deploy the software ecosystem, resident applications and ICD constraints in the order of constraints.

[0012] Exemplarily, the application development module includes:

[0013] The resident application code development module is used to write and develop the core functional codes for data acquisition and driving, data processing, signal reception and transmission, and special simulation functions for simulation, simulate the functional characteristics of the simulated object, and realize timing scheduling and control in combination with the timing control algorithm;

[0014] Timing simulation control algorithm development module, which develops and optimizes algorithms for controlling simulation timing to ensure that the time behavior of the simulation device is consistent with the simulated object;

[0015] ICD editing matching module edits the internal functional components and signal definitions of the simulation device, constrains the data communication interface and pins, and clarifies the data communication protocol and data packet definition to ensure functional consistency between the simulation device and the simulated object;

[0016] The compiler module compiles the generated code, algorithm and ICD information in a unified manner, generates deployable application files and ICD files, and completes the packaging of resident applications.

[0017] Exemplarily, the object-to-be-simulated editing module constructs simulation device hardware according to a preset hardware architecture standard.

[0018] Exemplarily, the simulation platform further includes: a timing optimization model, the timing optimization model being used to optimize and expand timing logic data corresponding to the device to be simulated obtained according to the measured timing;

[0019] Specifically, the method includes: identifying each timing node; obtaining the node to be optimized based on the timing node, and matching the function of the node to be optimized; and obtaining the optimized timing.

[0020] Exemplarily, the steps of identifying each timing node; obtaining a node to be optimized based on the timing node, and matching the function of the node to be optimized; and obtaining the optimized timing include:

[0021] Determine the physical functional modules during the timing execution of the timing nodes;

[0022] Based on the timing nodes, the nodes to be optimized are obtained, and the functions of the corresponding optimization nodes are matched; the front and back sides of the timing execution of the physical function module are determined, the front and back sides are identified as the nodes to be optimized, and the functions of the corresponding nodes to be optimized are matched; the functions are data feedback and safety warning;

[0023] Get the final optimized timing.

[0024] Exemplarily, the object to be simulated editing module includes:

[0025] Basic information module, used to obtain basic information of the object to be simulated;

[0026] Timing feature import module, used to obtain timing feature information of the object to be simulated;

[0027] The ICD import module is used to obtain the ICD description information of the object to be simulated.

[0028] Exemplarily, the resource configuration module includes:

[0029] The operating system configuration module is used to select the version of the real-time operating system (RTOS) to provide the runtime environment for the resident application;

[0030] Apply the basic resource library, set up the basic libraries required by the application, such as graphics library, middle layer and API interface, to provide necessary support for application development;

[0031] Algorithm library configuration module, select or add specific timing control algorithms and timers according to simulation requirements to implement the required calculation and processing logic;

[0032] The ICD configuration module stores multiple ICD templates and determines the appropriate interface control document ICD template to ensure interface compatibility between the simulation device and the simulated object. Alternatively, it can automatically parse existing ICD files and generate corresponding simulation code, and also supports dynamic updating of ICD information.

[0033] A communication protocol configuration module, configured to configure a communication protocol suitable for the simulation device;

[0034] Extension library other resource modules are used to load other third-party libraries, plug-ins, and API functions.

[0035] Exemplarily, the application deployment module includes:

[0036] Operating system deployment module, used to deploy the corresponding version of the operating system according to hardware specifications;

[0037] Resource file deployment module, used to deploy the basic resource library required to support the operation of resident applications;

[0038] ICD synchronization module, used to edit or import ICD templates that meet the requirements of simulation equipment;

[0039] Communication protocol deployment module, used to select the corresponding communication protocol according to simulation requirements;

[0040] The resident application deployment module is used to collect all compiled executable files, library files and other related resources.

[0041] Exemplarily, the simulation platform further includes a test system, and the test system includes:

[0042] The object under test synchronization module is used to synchronize the information of the object under test and generate the test GUI, internal components, and communication interface list resources;

[0043] Test library management module, used to edit and manage test cases;

[0044] Test module, used to test the object under test;

[0045] The test evaluation module is used to perform subjective and objective test evaluation and generate test reports.

[0046] Exemplarily, the object synchronization module includes:

[0047] The ICD synchronization and confirmation module synchronizes the object under test by connecting to the simulation device to obtain the deployed ICD file and combining it with the ICD file synchronized by the simulation platform development system;

[0048] The object set generation module parses the ICD content and generates an ICD object set;

[0049] The GUI generation module generates GUI images according to the ICD object set.

[0050] Exemplarily, the test library management module includes:

[0051] Test case import module, used to import external test cases;

[0052] Test case editing module, for editing the contents of new test cases and existing test cases;

[0053] The test case management module manages newly created or externally imported test cases, including adding, deleting, modifying and screening;

[0054] The test library management module is used to save imported test cases or edited test cases.

[0055] Exemplarily, the test module includes:

[0056] ICD object list display module, used for object-centric test query and synchronous test information display;

[0057] Test case configuration module, which assigns test cases to ICD objects;

[0058] Test deployment module, used to deploy the test sequence and test mode;

[0059] The test driver module generates a test drive script based on the test and associated test cases of the test deployment module, and generates a test data stimulus signal;

[0060] The test monitor and result recording module is used to monitor the test process and record / save the test process data and use case test results.

[0061] Exemplarily, the test evaluation module includes:

[0062] Test generation data synchronization module, loading and synchronizing test process and result data;

[0063] Test process playback module, GUI images and ICD object lists for graphical and intuitive data test process playback;

[0064] The test report generation module synchronizes test records / saves data and combines test process playback to achieve subjective and objective evaluation of the test and generate test report files.

[0065] Exemplarily, the simulation platform further includes: a graphical user interface, which is used to interact with each module, and the user accesses and operates each functional module in the platform through the interface.

[0066] Another aspect of the present disclosure provides a simulation method for devices with high timing requirements, using the above-mentioned simulation platform. The method includes:

[0067] According to the determined object to be simulated, configure the corresponding timer model and algorithm prototype, as well as the corresponding ICD template file, and select the required resident operating system, application basic resource library and communication protocol from the basic library;

[0068] Edit the ICD template file to generate an ICD file;

[0069] Load the timer model and algorithm prototype, and edit the timing simulation control algorithm code based on the timer model and algorithm prototype as well as the imported timing characteristic information of the object to be simulated;

[0070] According to actual development needs, select the corresponding configuration from the application basic resource library to edit the resident application code;

[0071] Compile the ICD file, the timing simulation control algorithm code file and the resident application code file into an executable file;

[0072] Deploy the executable file to the hardware device to be simulated.

[0073] Exemplarily, the simulation method further includes a testing method;

[0074] The test method includes:

[0075] Connect the simulation device to the simulation platform via wired or wireless signals;

[0076] Based on the ICD information of the device to be simulated, confirm whether the device under test is consistent with the device described in the ICD after the connection is established, wherein the connection data includes: the device, its internal functional components, interface functions, and the number of interfaces;

[0077] Deploy test activities based on imported test cases, modify test cases and specify test objects according to different test requirements, and drive simulation devices for testing after deployment.

[0078] Monitor and record the test process in real time, and display the test information in real time;

[0079] Record test information, generate test reports, and evaluate simulation device performance based on the test reports.

[0080] Another aspect of the disclosed embodiment provides an emulation terminal, including the platform described above.

[0081] The beneficial effects of the embodiments of the present disclosure are:

[0082] The simulation platform of the disclosed embodiment adopts RTOS and timing simulation control algorithm development modules according to the functional characteristics and performance characteristics of the simulated object, and realizes synchronous simulation of the functions and performances of complex simulated objects through more universal communication interfaces and communication protocols. On the basis of ensuring the reliability of the simulation, it effectively reduces the difficulty of simulating the technology of equipment with high timing stability and timing reliability in the fields of aerospace, aviation, navigation, etc. BRIEF DESCRIPTION OF THE DRAWINGS

[0083] Figure 1 This is a schematic diagram of a simulation platform architecture for devices with high timing requirements according to an embodiment of the present disclosure;

[0084] Figure 2 This is a schematic diagram of another simulation platform architecture for devices with high timing requirements according to an embodiment of the present disclosure;

[0085] Figure 3 This is a schematic diagram of a simulation process for devices with high timing requirements according to an embodiment of the present disclosure;

[0086] Figure 4 This is a schematic diagram of a simulation hardware test process for a simulation platform for devices with high timing requirements according to an embodiment of the present disclosure;

[0087] Figure 5 This is a schematic diagram of the workflow of a synchronization module of an object under test in a simulation platform for devices with high timing requirements according to an embodiment of the present disclosure;

[0088] Figure 6 This is a schematic diagram of the workflow of a test library management module of a simulation platform for devices with high timing requirements according to an embodiment of the present disclosure;

[0089] Figure 7 This is a schematic diagram of the workflow of a test module of a simulation platform for devices with high timing requirements according to an embodiment of the present disclosure;

[0090] Figure 8 This is a workflow diagram of a test and evaluation module of a simulation platform for devices with high timing requirements according to an embodiment of the present disclosure. DETAILED DESCRIPTION

[0091] In order to make the purpose, technical solutions and advantages of the embodiments of the present disclosure more clear, the embodiments of the present disclosure are further described in detail below with reference to the accompanying drawings. It should be understood that the specific implementation methods described herein are only used to explain the embodiments of the present disclosure and are not intended to limit the embodiments of the present disclosure.

[0092] On the one hand, the simulation platform for devices with high timing requirements provided by the embodiments of the present disclosure is a simulation device platform for "high, precise and specialized" device simulation. The platform uses the inherent characteristics of the real-time operating system based on the functional characteristics (which can be understood as frequency domain characteristics) and performance characteristics (which can be understood as time domain characteristics) of the simulated object, and realizes synchronous simulation of the functions and performances of complex simulated objects through more general communication interfaces and communication protocols. On the basis of ensuring the reliability of the simulation, it effectively reduces the technical difficulty of simulating "high, precise and specialized" devices in the fields of aerospace, aviation, navigation, etc.; by constructing hardware architecture standards, simulation platform development systems, and simulation platform testing systems, it realizes the development and support of resident software for running simulation hardware devices during the design and development of simulation hardware, and supports closed-loop testing of hardware and software.

[0093] like Figure 1As shown, on the one hand, an embodiment of the present disclosure proposes a simulation platform for devices with high timing requirements, which is applied to aviation, aerospace and aviation-related equipment. The simulation platform includes: a development system and a test system, wherein the development system is used to develop resident applications for simulation devices that meet hardware architecture standards, and is mainly composed of modules such as a simulation object editing module, a resource configuration module, an application development module, and an application deployment module; the simulation test system is used to perform hardware and software testing on the developed simulation devices, and is mainly composed of modules such as a test object synchronization module, a test library management module, a test module, and a test evaluation module.

[0094] The disclosed embodiments construct a simulation device platform for high-precision, cutting-edge device simulation, integrating development and testing systems. Simulation device hardware can be built using pre-designed hardware architecture standards, enabling development tasks such as resource configuration, application development, simulation testing, and report generation for the simulation hardware device within a single platform. The platform includes multiple built-in development and test cases, enabling rapid deployment of simulation devices and avoiding duplication of development.

[0095] like Figure 2 As shown, the hardware architecture standard, for example, a pre-set specification standard for embedded simulation devices, includes a hardware interface standard (HK-FD-Hport-s), a peripheral standard (HK-FD-HPeriph-s), a kernel standard (HK-FD-Hcore-s), a HAL interface standard HK-FD-HAL-s (HK-FD-HAL-s), and an RTOS interface standard (HK-FD-RTOS-s), which is used to constrain the development of embedded hardware devices.

[0096] The hardware architecture adopts the above-mentioned hardware architecture standard, which is mainly composed of a five-layer structure. The bottom layer is the simulation device hardware external interface layer, the second layer is the embedded peripherals, the third layer is the embedded processor core, the fourth layer is the real-time operating system, and the fifth layer is the resident application.

[0097] According to the hardware architecture standard, the hardware architecture of the simulation device is realized as follows:

[0098] Hardware interface standards (HK-FD-Hport-s): These define all physical connections and communication protocols between simulation devices and external systems or components, ensuring compliance with specific requirements. Based on this standard, you can select or design the appropriate interface circuits to ensure that the simulation device can correctly receive input signals and send output signals.

[0099] Peripheral Standard (HK-FD-HPeriph-s): This specifies all peripheral device types and configurations supported by the emulated device, ensuring peripheral compatibility and performance. Based on this standard, you can determine which sensors, actuators, or other peripherals need to be integrated and ensure they function as expected.

[0100] Core Standard (HK-FD-Hcore-s): This standard defines the selection, configuration, and performance parameters of the core processing unit of the simulation device to ensure that the simulation device has sufficient computing power. This includes the selection of processor architecture, instruction set support, memory management strategy, etc., to ensure that the simulation device has sufficient computing power to meet performance requirements.

[0101] HAL Interface Standard (HK-FD-HAL-s): The Hardware Abstraction Layer (HAL) provides a mechanism for developing upper-layer software independently of the underlying hardware implementation. Building a HAL according to this standard improves software portability and reusability while simplifying the software development process. Providing a standard interface for the Hardware Abstraction Layer allows software development to be independent of the specific hardware implementation, improving software portability.

[0102] RTOS Interface Standard (HK-FD-RTOS-s): A real-time operating system (RTOS) is a key component of many embedded systems. This standard defines the services and interfaces that an RTOS should provide, as well as key behaviors such as task scheduling and interrupt handling, to ensure the system's real-time responsiveness.

[0103] The simulation platform development system is used for the development of resident applications for simulation device hardware. The resident application refers to a combination of supporting timing scheduling, data processing, signal acquisition and driving functions running on the simulation device hardware platform and RTOS system, and is packaged in the form of an application program. In the development system, the development of resident applications for embedded simulation hardware devices developed on the platform is mainly supported through but not limited to the following modules.

[0104] The object editing module to be simulated is mainly composed of a basic information module, a timing feature import module, and an ICD import module. The basic information, timing feature information, and ICD description information of the object to be simulated are obtained through the above modules respectively, and the key attribute information such as the performance characteristics and functional characteristics of the device to be simulated are clarified to determine the simulation target. The object to be simulated is also the hardware device to be simulated, where the basic information includes: device category, device name, device serial number, etc. For example, aviation equipment / ARJ21 aircraft / avionics equipment / EFIS control box / C6233-20200702; Timing feature information: refers to the time series characteristics of the device operation, such as signal processing delay, response time, and task execution cycle. ICD description information: internal functional components of the device and physical signal definitions, device communication interface description, device communication protocol and communication data packet definition, etc.

[0105] The object editing module of the embodiment of the present disclosure utilizes the function window and built-in components of the object editing module to edit and import the basic information, timing characteristic information, and ICD description information of the device to be simulated to achieve performance and function matching between the object to be simulated and the simulation object, ensuring that the simulation results meet the characteristics of the object to be simulated.

[0106] It should be noted that the object-to-be-simulated editing module primarily supports manual editing via visually categorized input controls within each module's windows, and supports the import of standard-format table file information via the data import dialog box. Furthermore, the timing information import module incorporates an image recognition algorithm and supports the import of timing diagrams for editing timing characteristics, or directly importing the timing control source code of the simulated device. This allows for editing the performance and functional characteristics of the object to be simulated, and based on this, the timing performance and functional characteristics of the simulated device can be simulated. The object-to-be-simulated editing module can also build simulated device hardware according to pre-set hardware architecture standards.

[0107] The resource configuration module is mainly composed of the operating system configuration module, application basic resource library, algorithm library configuration module, ICD configuration module, communication protocol configuration module and other resource management modules of the extension library; through the above modules, the resources required by the device can be configured, such as operating system, communication protocol, algorithm library and other resources to support the code development of resident software.

[0108] The function of the resource configuration module is to configure the simulation resources by using the function window of the resource configuration module through processes such as selecting the RTOS version, configuring the application basic resource library, configuring the algorithm library, selecting the simulation device ICD template, and selecting the communication protocol. It is used to support the development and implementation of resident applications, and at the same time complete the software ecosystem construction required for the deployment of resident applications. In addition, it also has an extension library function for loading other third-party libraries, plug-ins, API functions, etc.

[0109] The operating system configuration module stores RTOS versions such as FREERTOS and RT-Thread; the application basic resource library configuration module includes: graphics library, middle layer and API interface, etc.; the algorithm library configuration module stores timers and algorithm prototypes, etc.; the ICD configuration module stores various ICD templates such as A429-ICD, A664-ICD, CAN-ICD, CAN-ICD, EN-ICD, G-ICD, etc.; the communication protocol configuration module stores CAN protocol, Ethernet protocol and custom protocol, etc.; the extension library other resource management module stores TTS, image recognition, etc.

[0110] Configure the operating system and select the RTOS version: Select the version of the real-time operating system (RTOS) to provide a runtime environment for resident applications. Configure the application basic resource library: Set up the basic libraries required by the application, such as graphics library, middle layer and API interface, etc., to provide necessary support for application development. Configure the algorithm library: Select or add specific timing control algorithms and timers according to simulation requirements to implement the required calculation and processing logic. Select the simulation device ICD template: Select the appropriate interface control document ICD template to ensure the interface compatibility between the simulation device and the simulated object. Select the communication protocol: Configure the communication protocol suitable for the simulation device to ensure the standard and efficiency of data transmission. Extended library function: used to load other third-party libraries, plug-ins, API functions, etc. to enhance the flexibility and functionality of the software ecosystem.

[0111] The Graphics Library, which configures the application's basic resource library, is primarily responsible for configuring library files related to graphics processing, such as libraries used for interface design, graphics rendering, and other scenarios. The Graphics Library is a basic resource library specifically for graphics processing.

[0112] The middleware layer typically refers to the software layer between the operating system and the application. It handles common tasks such as transaction management, messaging, and data conversion, allowing developers to focus on implementing business logic rather than underlying technical details.

[0113] An API (Application Programming Interface) is a set of rules that defines how software communicates with each other. APIs allow different software systems to interact and provide specific functionality or services without exposing the underlying implementation details.

[0114] Other resources in the extension library are used to expand the capabilities of the simulated device, enabling it to support more functions and services. These resources mainly serve the following purposes: Increase functionality: By integrating third-party libraries, plug-ins, or APIs, new features are introduced to the simulated device, such as advanced data analysis and support for specific hardware.

[0115] Improve flexibility: Allow developers to flexibly add or replace different libraries and tools according to project needs to meet specific development requirements. Promote interoperability: Enable simulated devices to better interact with other systems or components, such as accessing cloud services or IoT platforms by calling external APIs.

[0116] An ICD template is usually a standardized file or data structure that contains the basic definition of a communication protocol or interface, such as A429, A664, CAN, etc. For example: data frame format; field name, length, data type, etc.; physical signal characteristics, such as voltage range, frequency, etc.; common communication rules or protocols. When a user selects an ICD template, the following steps are followed: (1) Loading the template: Loading the selected template file from the ICD configuration module. The template file may be a pre-stored standardized file in formats such as XML, JSON, Excel, etc. (2) Matching the input ICD description information: The user enters specific ICD description information through the object to be simulated editing module. This input information is matched with the fields in the template, filling in or overwriting the default values in the template. For example: If the template defines the length of "Field A" as 8 bits, but the ICD description information entered by the user requires "Field A" to be 16 bits, the system will update the definition of the field. If some fields are missing in the template, these fields will be supplemented based on the input information. (3) Generate code or configuration files: After matching and filling, the code or configuration files required for simulation are generated based on the final ICD description information. This step is similar to the generation process of automated ICD parsing, including: data frame parsing and packaging logic; simulator or driver for the communication interface; and simulation parameters of the physical signal. (4) Verify the generated results: The generated code or configuration files are verified to ensure that they are consistent with the final ICD description information. Verification methods may include: data format checking; simulation run testing; and comparison of key fields of the original ICD description information.

[0117] Depending on how well the input ICD description matches the template, the following two situations may occur:

[0118] (1) Exact match: If the ICD description information entered by the user is exactly the same as the template, no additional modification is required and the template can be used directly to generate code or configuration files.

[0119] In this case, the system's job is primarily to load the template and generate the output.

[0120] (2) Partial matching or customization: If the ICD description information entered by the user is not completely consistent with the template (for example, different field definitions, newly added fields, etc.), the system needs to adjust or expand the template.

[0121] Specific operations include: updating field definitions in the template, adding new fields or deleting unnecessary fields, and adjusting parameters of communication protocols or physical signals.

[0122] The ICD configuration module can also automatically parse existing ICD files and generate corresponding simulation code. It also supports dynamic updating of ICD information to adapt to real-time changing needs.

[0123] The automated ICD parsing, generation, and dynamic ICD update mechanisms are as follows:

[0124] Use natural language processing (NLP) techniques to identify and extract key information from ICD documents. For example, pre-trained language models such as BERT can be used to understand complex text descriptions.

[0125] Pattern matching algorithm: Use regular expressions or pattern matching algorithms to automatically identify ICD files of different formats and convert them into a unified data structure.

[0126] Automatic generation tool: Graphical interface: Provides a graphical user interface that allows users to automatically generate standard ICD files by filling out forms or dragging and dropping.

[0127] Template engine: Based on the basic information and configuration parameters entered by the user, a template engine (such as Jinja2) is used to automatically generate an ICD file.

[0128] Dynamic ICD update mechanism: Event-driven architecture: Design an event-driven system to monitor changes in system status (such as sensor access) in real time and dynamically update the ICD file based on the changes.

[0129] Version control system integration: Use Git or other version control systems to manage the change history of ICD files, ensuring that every update is recorded and traceable.

[0130] Specifically, the following is the basic workflow of automated ICD parsing: (1) Input ICD description information: The user provides ICD description information through the object editing module to be simulated. The input format can be: standardized ICD file (such as XML, JSON, Excel, etc.). Manually input key parameters (such as field name, data type, communication protocol, etc.). (2) Parsing ICD description information: The pre-trained language model will parse the input ICD description information and extract key content, such as: data frame structure (field name, data type, length, offset, etc.). Specific rules of the communication protocol (such as start bit, end bit, check method, etc.). Characteristics of the physical signal (such as voltage range, frequency range, etc.). (3) Generate the configuration or code required for simulation: After the parsing is completed, the pre-trained language model will generate the output required by the simulation system based on the extracted information, such as: configuration file of the simulation model. Code for data parsing and packaging (such as C / C++, Python, etc.). Simulator or driver of the communication interface. (4) Verify the parsing results: The tool will verify the generated configuration or code to ensure that it is consistent with the original ICD description information. Verification methods can include: data format check. Run the simulation test. Compare key fields in the original ICD file. 4. Dynamic update mechanism integration: If the ICD description of the simulated object changes during the project (for example, due to a communication protocol upgrade or new functionality), the automated ICD parsing tool can also support dynamic updates: real-time parsing of the new ICD information: When the user enters new ICD description information, the tool can quickly reparse and generate updated configuration or code.

[0131] Version management: The tool can record ICD analysis results of different versions for easy backtracking and comparison.

[0132] Automated ICD parsing is an optimization measure, supporting unified parsing of multiple ICD formats (such as A429, A664, and CAN). It provides intelligent field mapping and data conversion capabilities, enabling dynamic updates and real-time adaptation. This improves development efficiency by reducing manual parsing and coding time. It enhances system flexibility by quickly adapting to different ICD descriptions. It also reduces the risk of errors by reducing human error through automation.

[0133] In summary, the resource configuration module and its components work together to provide comprehensive resource configuration and support for the development of resident applications for simulation devices, while also enhancing the system's customizability and extensibility through features such as extension libraries.

[0134] The algorithm library includes an algorithm prototype library and a timer library. The algorithm prototype library stores timing control algorithms for different simulated devices, including a general timing control algorithm, a timing control algorithm for simulated device x, a timing control algorithm for simulated device y, and a timing control algorithm for simulated device o. These algorithms are specifically designed to simulate the behavior of different types of simulated devices. The timer library stores timers for 1 microsecond, 10 microsecond, 100 microsecond, 1 millisecond, 10 millisecond, and 100 millisecond timers.

[0135] The algorithm library configuration process is implemented by selecting the algorithm prototype through the algorithm prototype library and selecting the timer model through the timer library. The accuracy of the timer model determines the timing simulation control accuracy of the simulation device.

[0136] The timer is implemented using the following steps:

[0137] 1. Initialize the timer and set the initial time t0.

[0138] 2. Calculate the next timer trigger time t n =t0+nΔt.

[0139] 3. Get the current time t c .

[0140] 4. If t c ≥t n , then the timer callback function is triggered and t0=t is updated n .

[0141] 5. Repeat steps 2-4.

[0142] Since there may be errors in the calculation, a minimum constant τ is introduced to trigger the judgment condition. Therefore, the actual judgment condition in step 4 is t c ≥t n -τ. Δt is the fixed time interval (i.e., period) of the timer, expressed in units such as microseconds (µs), milliseconds (ms), or seconds (s). n is an integer counter representing the number of complete time intervals Δt that have elapsed since the initial time t0.

[0143] The 1 microsecond timer is implemented by using a 64-bit integer to represent time, where the upper 32 bits represent microseconds and the lower 32 bits represent nanoseconds. A nanosecond timer is constructed and then the nanosecond timer is encapsulated to implement a 1 microsecond timer.

[0144] The 10 microsecond timer is implemented by encapsulating a 1 microsecond timer.

[0145] The 100 microsecond timer is implemented by encapsulating a 1 microsecond timer.

[0146] The 1 millisecond timer is implemented by mainly using double-precision floating-point numbers to represent time in order to achieve microsecond-level timing accuracy, and thus encapsulates the 1 millisecond timer.

[0147] The 10 millisecond timer is implemented by encapsulating a 1 millisecond timer.

[0148] The 100 millisecond timer is implemented by encapsulating a 1 millisecond timer.

[0149] The encapsulated timer model is managed and stored through the timer library.

[0150] The application development module is mainly composed of the resident application code development module, the timing simulation control algorithm development module, the ICD editing and matching module, the compiler and other modules; the above modules are used to realize the development and compilation of the functional simulation code of the resident application and the timing control algorithm of the simulation device.

[0151] The application development module uses the functions of the application development module to simulate the functional characteristics and performance characteristics of the object to be simulated; through the development of resident application function logic, the development of synchronization matching algorithm between the timing characteristics of the object to be simulated and the simulation timing control, and the matching editing of the ICD information of the object to be simulated and the ICD of the simulation device, the resident application development of the simulation device is realized; the above code, algorithm and ICD information are compiled into a unified engineering project through the code compiler to generate deployable resident application files and ICD files; high-precision simulation is achieved in which the simulation device and the simulated device are completely consistent in device functions, timing characteristics, interface pins and object data.

[0152] Specifically, the resident application code development module writes and develops core functional codes such as data acquisition and driving, data processing, signal reception and transmission, and special simulation functions for simulation, simulates the functional characteristics of the simulated object, and combines the timing control algorithm to realize timing scheduling and control.

[0153] The resident application code development module provides a code development environment where developers can write resident applications (i.e., programs that run on the simulated device). This ensures that the simulated device can achieve the same functional logic and performance as the simulated object. It also outputs functional simulation code, providing a foundation for subsequent compilation and deployment.

[0154] The timing simulation control algorithm development module develops and optimizes the algorithm for controlling simulation timing to ensure that the time behavior of the simulation device is consistent with the simulated object.

[0155] Design and implement timing synchronization algorithms to precisely control the order and time intervals of events. Simulate the temporal characteristics of the simulated object, such as response delays and periodic task scheduling. Output timing control algorithms to ensure that the simulated device is highly consistent with the simulated object in terms of time.

[0156] The ICD editing and matching module edits the internal functional components and signal definitions of the simulation device through the structured editing window, constrains the data communication interface and pins, and clarifies the data communication protocol and data packet definition to ensure functional consistency between the simulation device and the simulated object.

[0157] The compiler module compiles the generated code, algorithm and ICD information in a unified manner, generates deployable application files and ICD files, and completes the packaging of resident applications.

[0158] Compiler modules can be cross-platform compilers, including multi-target compilers, CMake scripts, abstraction layer design, containerized deployment, CI / CD pipelines, and cloud-based compilation services. Multi-target compilers support the generation of executable files for different operating systems or hardware platforms. This means that the compiler must be able to understand and handle the specific requirements and optimizations for each target platform.

[0159] CMake scripts: By writing cross-platform CMake scripts, you can automatically generate corresponding build files (such as Makefiles and Visual Studio projects) based on the target platform. This method simplifies the process of building projects on multiple platforms.

[0160] Abstraction layer design: Introducing an abstraction layer into the code separates platform-specific code from general logic. This improves code portability, allowing the core logic to run on different platforms without modification, requiring only adaptation of the abstraction layer.

[0161] Containerized deployment: Leveraging technologies like Docker, you can write a Dockerfile for each target platform to create a consistent and isolated runtime environment. This helps ensure that applications can run the same way in any environment and simplifies dependency management and deployment.

[0162] CI / CD pipeline: Integrate continuous integration / continuous delivery tools (such as Jenkins and GitLab CI) to automate the testing and deployment process. This is crucial for ensuring software quality and accelerating the development cycle, especially when supporting multiple platforms.

[0163] Cloud-based compilation services: Develop an API that allows users to upload source code and select a target platform. Cloud servers then complete the compilation process. Cloud storage is used to store compilation results for easy download. This approach not only supports cross-platform compilation but also provides flexibility and scalability. The cloud-based compilation service can be configured based on actual needs; it can be omitted for emulated devices that are not publicly available.

[0164] Integrate resident application code, timing control algorithm and ICD information to form a complete project file.

[0165] Compile and generate resident application files (such as executable files or firmware) that can run on the simulated hardware device.

[0166] At the same time, an ICD file matching the simulation device is generated for interface communication and data interaction, ensuring that all development results can be seamlessly deployed to the simulation device.

[0167] The above modules work together to fully support the high-precision simulation of the simulated object by the simulation equipment from function, timing, interface to the final deployment file.

[0168] The timing simulation control algorithm development module uses the timing characteristics of the device to be simulated to develop and optimize the timing simulation control algorithm.

[0169] Code transplantation can be performed by importing the source code of the timing characteristic information of the simulated device, or by adopting a general timing control algorithm model.

[0170] Among them, if the device to be simulated has timing control logic, the timing specific information source code of the device to be simulated can be imported. Importing the timing specific information source code of the simulated device mainly achieves adaptation to the simulation device operating system and programming language by adjusting the code structure or completely reconstructing the code.

[0171] In addition, if the device to be simulated does not have a timing control algorithm, a universal timing control algorithm is used to provide a universal timing control algorithm to implement timing control of other simulated devices (devices with characteristic signals without an operating system or devices that cannot obtain a timing control algorithm).

[0172] For simulated devices where the timing control algorithm source code cannot be imported, a universal timing control algorithm is provided; combined with differentiated timers, two types of timing control for the simulated device are implemented. For other simulated devices, if a preset timing control algorithm is available, the preset timing control algorithm can be used as the timing control algorithm for the simulated device.

[0173] To implement the general timing simulation control algorithm, first construct the system state equation:

[0174] x(t)=Ax(t)+Bu(t)

[0175] y(t)=Cx(t)+Du(t)

[0176] Where x(t) is the state vector, u(t) is the input vector, and y(t) is the output vector. A, B, C, and D represent the state matrix, input matrix, output matrix, and direct transfer matrix, respectively. For different application areas and simulation devices, the state vector and input vector machine output vector correspond to different specific vectors. For example, for aviation / aerospace equipment, the state vector x(t) may include but is not limited to the following aspects: position, velocity, attitude angle, and angular velocity; the input vector u(t) may represent an external control signal or torque that can be applied to the system, such as thrust command, rudder deflection angle, and reaction wheel torque; the output vector y(t) can be an observation of the system's internal state or a measurement of its impact on the external environment. Depending on the purpose of the simulation, it may include: sensor readings, visualized flight parameters, fault detection and isolation signals.

[0177] Next, a linear LQR controller is defined to minimize the objective function:

[0178]

[0179] Where Q and R are the weight matrices of state and control input respectively;

[0180] x T (t) represents the time-weighted state error of the state vector; u T (t) is the time-weighted control error of the input vector.

[0181] The optimal control law of the LQR controller is:

[0182] u(t) = −Kx(t)

[0183] Where K is the feedback gain matrix, which can be obtained by solving the algebraic Riccati equation:

[0184]

[0185] By solving the equation we get:

[0186]

[0187] Among them, P is the symmetric positive definite matrix obtained by solving the continuous-time algebraic Riccati equation (CARE); P defines the minimum cost (i.e., the optimal performance indicator) of the system starting from any initial state; by prototyping the above-mentioned state feedback-based timing control method, a general timing simulation control engineering code is implemented, and the engineering packaging is completed and synchronized to the algorithm prototype library for storage and management.

[0188] Simulation timing control application programming: Select the packaged timing control algorithm or other preset timing simulation control algorithm through the configuration window, and select the timer at the same time; synchronize the software engineering file and timer model to the timing simulation control algorithm development module, and implement timing control programming by adjusting the control parameters.

[0189] Simulation timing control application programming based on the timing control source code of the simulated device:

[0190] By importing the timing control source code of the simulated object and selecting the timer through the configuration interface, the code and timer model are synchronized to the timing simulation control algorithm development module, the adaptation of the operating system and programming language is completed to realize the simulation timing control application programming, and the verified simulation timing control algorithm is synchronized to the algorithm prototype library for storage and management.

[0191] The measured timing of the device to be simulated can be obtained by manually entering it into the simulation platform. This measured timing typically refers to time data extracted directly from the actual system (or its documentation) through measurement, experimentation, logging, or other means, such as event trigger times, signal delays, and task cycles. The measured timing of the device to be simulated can be obtained from hardware devices, sensors, log files, ICDs (Interface Control Documents), and other sources. The measured timing of the device to be simulated may change dynamically, especially during actual operation, due to factors such as load and environmental conditions.

[0192] The simulation platform obtains the timing logic data of the device to be simulated based on the measured timing. This is a common function of the simulation platform and will not be elaborated in detail in the present embodiment. For example, source code import, universal timing control calculation, and preset timing control algorithm.

[0193] The timing optimization model is used to optimize and expand the timing logic data of the device to be simulated based on the measured timing.

[0194] Specifically, each timing node is identified; based on the timing node, the node to be optimized is obtained, and the function of the node to be optimized is matched; and the optimized timing is obtained.

[0195] Determine the physical functional modules in the timing execution process of the timing node. For example, in a timing logic of turning off switch K2 → turning off switch K1, the timing nodes are K1 and K2.

[0196] According to the timing nodes, the nodes to be optimized are obtained, and the functions of the corresponding optimization nodes are matched; the front and back sides of the timing execution of the physical function module are determined, the front and back sides are identified as the nodes to be optimized, and the functions of the corresponding nodes to be optimized are matched; the functions are data feedback and safety warning; for example, the main switch K1 is connected to multiple parallel relay switches K2, and each K2 is connected to the load. If the timing logic is to turn off the switch K2→turn off the switch K1, the timing nodes are K1 and K2. After the nodes to be optimized are inserted into the timing logic, Y1→turn off the switch K2→Y2→turn off the switch K1→Y3 are obtained, among which Y1, Y2 and Y3 are the nodes to be optimized. The functions matched by the nodes to be optimized are the data fed back by the system and the safety warning of whether the next timing node can be safely executed. That is to say, turn off the switch K2 and judge whether it is safe to turn off K1. The turn off switch K2 is any one of the multiple parallel switches K2, which can be determined by the system feedback data to achieve safety warning.

[0197] The final optimized timing is obtained: Y1→turn off switch K2→Y2→turn off switch K1→Y3.

[0198] The nodes to be optimized also include: the cut-off nodes to be optimized added after the final optimization sequence is completed. When determining the cut-off nodes to be optimized, the device function corresponding to the timing logic is first judged. If it is an inert function, the cut-off node to be optimized is inserted. Otherwise, it is an immediate function and the cut-off node to be optimized is not inserted.

[0199] Among them, the inertia function is a function in which the device parameters corresponding to the execution result change slowly after the logic is executed. For example, when the flow valve is closed, the flow rate will not immediately become zero. For example, when the power is cut off to a capacitor, the voltage across the capacitor will not immediately become zero.

[0200] The instant function is a function in which the device parameters corresponding to the execution results change immediately after the logic is executed, for example, opening a web page, closing a web page, etc., change immediately.

[0201] Nodes to be optimized include: data feedback and data feedback time.

[0202] Each device corresponds to a timing optimization model. According to the different matching devices, the feedback parameters are optimized and adjusted, such as the time of data feedback, data feedback and security warning parameters.

[0203] The timing optimization model identifies each timing node, obtains the nodes to be optimized, matches the functions of the nodes to be optimized, obtains the optimized timing, optimizes and expands the timing logic, and generates a complete set of executable timing logic for use in the simulation platform.

[0204] The application deployment module is mainly composed of modules such as the operating system deployment module, the resource file deployment module, the ICD synchronization module, the communication protocol deployment module, and the resident application deployment module; and realizes the orderly deployment of the operating system, resource files, ICD definitions, communication protocols, resident applications and other contents on the simulation hardware device in accordance with the constraint order.

[0205] The application deployment function uses the function window of the application deployment module to deploy the simulation device software ecosystem, resident applications, and ICD constraints. Among them, the software ecosystem includes the operating system, basic resources that support the execution of resident applications, communication protocols, etc.; resident applications mainly include compiled executable files, library files, binary files, etc.; ICD constraints mainly include interfaces, pins, data, and variable definition files edited according to templates.

[0206] Specifically, the operating system deployment module functions as follows: ensuring that a suitable operating system (such as RTOS) is installed on the simulated hardware device to provide the necessary operating environment for resident applications.

[0207] Deployment steps: Select the appropriate OS image version based on the hardware specifications. Use a flashing tool or boot loader to install the selected OS image on the target hardware. Configure system settings, such as network configuration and user permissions, to suit specific simulation requirements.

[0208] Resource file deployment module function: deploys the basic resource libraries required to support the operation of resident applications, including standard libraries, graphics libraries, algorithm libraries, etc.

[0209] Deployment steps: Identify the library files required by the simulation application and download or develop these libraries as needed. Transfer these library files to a designated directory on the simulation hardware device. Update environment variables or path settings so that the resident application can successfully access these libraries.

[0210] ICD synchronization module function: ensures that the interface control document (ICD) matches the interface definition of the simulation hardware device, ensuring the consistency and accuracy of data exchange.

[0211] Deployment steps: Edit or import an ICD template that meets the requirements of the simulated device, including information such as interfaces, pinouts, and data formats. Verify and adjust the ICD definition on the simulated hardware device to ensure compatibility with the actual hardware interface. Sync the finalized ICD file to the simulated device to ensure proper external communication.

[0212] Communication protocol deployment module function: configure and deploy communication protocols suitable for simulation devices, so that the devices can effectively interact with other systems.

[0213] Deployment steps: Select an appropriate communication protocol (such as CAN protocol, Ethernet protocol, or custom protocol) based on simulation requirements.

[0214] Install the necessary drivers and supporting libraries to implement the selected protocol. Configure relevant parameters (such as IP address and baud rate) to ensure smooth communication between devices.

[0215] Function of the resident application deployment module: deploy the compiled resident application and its dependencies (such as library files, binary files, etc.) to the simulated hardware device.

[0216] Deployment Steps: Gather all compiled executable files, libraries, and other related resources. Upload these files to the simulated hardware device and place them in the correct directory. Set appropriate permissions and run tests to verify that the application can start and run properly.

[0217] The coordinated work of these modules enables comprehensive deployment, from the operating system to specific applications. This process involves more than just simple file transfers; it also includes a complex series of configuration and verification steps to ensure that each component can operate efficiently in the simulated hardware environment, thereby accurately emulating the real system.

[0218] The simulation platform test system is used for testing simulation equipment. The test system mainly includes but is not limited to the following functions: testing of simulation hardware equipment and resident applications developed by the support platform.

[0219] The test system includes: a test object synchronization module, a test library management module, a test module and a test evaluation module.

[0220] The object synchronization module to be tested is mainly composed of modules such as ICD synchronization and confirmation module, GUI generation module, object set generation module, etc. Through the above modules, the ICD deployed in the embedded simulation device can be compared and confirmed with the ICD file of the development system, and GUI images and ICD object sets can be automatically generated based on the recognition of ICD content to support the implementation of testing activities.

[0221] The object synchronization module function uses the function window and built-in components of the object synchronization module to achieve information synchronization and resource generation of the object under test; obtains the deployed ICD file by connecting to the simulation device and combines it with the ICD file synchronized by the simulation platform development system to achieve information synchronization of the object under test; uses the built-in ICD parsing algorithm to parse ICD content and generate an ICD object set (ordered set), and combines the built-in image generation algorithm to graphically visualize the parsed ICD object into a GUI.

[0222] ICD is a structured device information description similar to XML / JSON files, so ICD parsing can be directly implemented through a structure recognition algorithm. I will not go into details here.

[0223] Specifically, the object under test synchronization module is used for information synchronization of the object under test and generation of test GUI, internal components, and communication interface list resources;

[0224] The object synchronization module includes:

[0225] The ICD synchronization and confirmation module obtains the deployed ICD file by connecting to the simulation device and combines it with the ICD file synchronized with the simulation platform development system. By comparing the version numbers and contents of the two files, it performs integrity, correctness, and consistency checks and obtains the return value to achieve synchronization of the object under test;

[0226] The object set generation module parses the ICD content and generates an ICD object set;

[0227] The GUI generation module generates GUI images according to the ICD object set.

[0228] The test library management module is mainly composed of a test case import module, a test case editing module, a test case management module, a test library management module, etc.; the import, editing and management of external test cases can be achieved through the ICD object.

[0229] The test library management module uses the function window of the test library management module to realize the editing and management of test cases; combined with the graphical operation interface, it supports the import of test cases in various file formats; combined with the graphical operation interface, it supports the editing of test case input data, output expectations, timing characteristics, tolerance range, result criteria, etc.; combined with the graphical operation interface, it supports the management operations such as adding, deleting, modifying, and checking test cases; the edited or imported test cases are uniformly saved by the test library.

[0230] Specifically, the test library management module is used to edit and manage test cases.

[0231] The test library management module includes:

[0232] The test case import module is used to import external test cases. It supports the import of test cases in formats such as spreadsheet files, XML / JSON files, and performs localization recognition and automatic generation.

[0233] The test case editing module supports the creation of new test cases, editing of existing test cases, and secondary editing. It mainly edits test objects, timing feature constraints, pre-stimulus, result expectations, etc. Existing test cases include external import and identification of generated test cases.

[0234] The test case management module manages newly created or externally imported test cases, including adding, deleting, modifying and screening;

[0235] The test library management module is used to save imported test cases or edited test cases.

[0236] The test module is mainly composed of an ICD object list display module, a test case configuration module, a test deployment module, a test driver module, a test monitor module, etc.; the ICD object list module is used to synchronize test information, the test case configuration module assigns test cases to ICD objects, the test deployment module can deploy the sequence and test mode of tests, the test driver module supports automatic generation of test drive scripts according to deployed tests and associated test cases to realize test data stimulation, and the test process is monitored through the test monitor module and the test process data and case test results are recorded / saved.

[0237] The test module function realizes object-centric test query, test configuration, test deployment, test data drive, test process monitoring and result recording through the function window and built-in components of the test module; clarifies the objects to be tested of the device under test through the object list, and intuitively displays the progress of the test and content deployment; configures test cases for a series of test objects of the device under test through the graphical operation interface of the test configuration; deploys the test start time, manual or automatic test mode, single-step or continuous test mode, single or loop test form through the graphical operation interface of the test deployment; realizes test drive script generation through the test driver, and uses it to generate test stimulus signals in combination with the test case content; monitors the test execution through the test monitor, and records and stores the test process and result data.

[0238] Specifically, the test module is used to test the object to be tested.

[0239] The test module includes:

[0240] ICD object list display module, used for object-centric test query and synchronous test information display;

[0241] Test case configuration module, which assigns test cases to ICD objects;

[0242] Test deployment module, used to deploy the test sequence and test mode;

[0243] The test driver module generates a test drive script based on the test and associated test cases of the test deployment module, and generates a test data stimulus signal;

[0244] The test monitor and result recording module is used to monitor the test process and record / save the test process data and use case test results.

[0245] The test evaluation module is mainly composed of a test data generation synchronization module, a test process playback module, a test report generation module and other modules; the test record / save data is loaded through the test data generation synchronization module, and the test process playback module calls the GUI interface and ICD object list to realize graphical and intuitive data playback of the test process and support subjective test evaluation. The test report generation module synchronizes the test record / save data and combines the test process playback to realize subjective and objective evaluation of the test and generate a test report file.

[0246] Test evaluation function, using the function window of the test evaluation module to realize subjective and objective test evaluation and test report generation; test information viewing: by loading and synchronizing the test process and result data, calling the GUI image and object list generated by the synchronization function of the tested object to realize the visual playback of the test process, combining manual input operations and automatic evaluation algorithms to generate test reports and support report export.

[0247] Specifically, the test evaluation module is used to perform subjective and objective test evaluation and generate test reports.

[0248] The test evaluation module includes:

[0249] Test generation data synchronization module, loading and synchronizing test process and result data;

[0250] Test process playback module, GUI images and ICD object lists for graphical and intuitive data test process playback;

[0251] The test report generation module synchronizes test records / saves data and combines test process playback to achieve subjective and objective evaluation of the test and generate test report files.

[0252] In addition to automated analysis, testers are allowed to score or annotate manually executed parts based on their expertise and experience. For example, these can include subjective evaluations of the user experience or detailed descriptions of specific behaviors. Pre-set algorithms are used to automatically analyze test data, calculate various performance indicators, identify anomalies, and provide preliminary evaluation results based on these results. These algorithms can be customized to meet specific test objectives, such as reliability testing or load testing.

[0253] For example, if there are 100 test cases, the test is considered passed if 100% of them pass.

[0254] The simulation platform of the embodiment of the present disclosure further includes: a graphical user interface, which is used to interact with each module.

[0255] Specifically, the interface provides an intuitive operating environment, allowing users to easily access and operate various functional modules within the simulation platform through various controls (such as buttons, menus, and dialog boxes). This includes, but is not limited to, editing simulation objects, resource configuration, application development, deployment, and testing. Through this design, users can complete complex tasks within a unified interface, such as defining simulation targets, configuring system resources, writing and debugging code, monitoring simulation progress, and analyzing results.

[0256] In addition, the GUI supports real-time monitoring of the simulation process, displays key performance indicators, and generates detailed analysis reports. Through this design, users can complete the entire process from development to testing in a unified and efficient environment.

[0257] The disclosed embodiments propose a simulation device platform for simulating "high-precision, specialized" devices. The platform constrains hardware devices through hardware standards, supports the development of resident applications for simulation devices that meet the hardware standards through the development system of the simulation platform, and tests the simulation devices and resident applications that meet the hardware standards through the test system; by applying the timing characteristics and functional characteristics of the simulated device, high timing stability and timing reliability simulation of the simulated "high-precision, specialized" device is achieved; the platform has a graphical operation interface to facilitate development and testing work.

[0258] Another aspect of the present disclosure provides a simulation method for devices with high timing requirements, using the above-mentioned simulation platform. The method includes:

[0259] Step S110: Configure the corresponding timer model and algorithm prototype according to the determined object to be simulated, and configure the corresponding ICD template file, select the required operating system, application basic resource library, and communication protocol from the basic library, and edit the ICD information of the simulation device.

[0260] Step S120: Edit the ICD template file to generate an ICD file.

[0261] Step S130 : Load the timer model and algorithm prototype, and edit the timing simulation control algorithm code according to the timer model and algorithm prototype and the imported timing characteristic information of the object to be simulated.

[0262] Step S140: Select the corresponding configuration from the application basic resource library according to the actual development requirements, and edit the resident application code in combination with the operating system and communication protocol.

[0263] The corresponding configuration includes: graphics, middle layer and API, etc.

[0264] Step S150 : compile the ICD file, the timing simulation control algorithm code file, and the resident application code file into an executable file.

[0265] Step S160: deploy the executable file to the simulated hardware device.

[0266] Specifically, such as Figure 3 As shown in FIG, the simulation device development process includes the following steps:

[0267] Step S201, confirm the simulated object: select a device to be simulated. The simulated object refers to the real device to be simulated, including but not limited to instrument panels, control panels, dimming panels and other devices.

[0268] The simulated object can be hardware devices with strict timing requirements in the aviation, navigation, and aerospace fields. After identifying the simulated object, the basic information, timing characteristics, and ICD description of the object to be simulated, or the source code, are obtained. The basic information, timing characteristics, and ICD description of the object to be simulated are imported into the object editing module to simulate the timing performance and functional characteristics of the simulated device, achieving high-precision hardware device simulation.

[0269] Step S202, feature data import: according to the selected simulated object, configure the corresponding timer model and algorithm prototype, and configure the corresponding ICD template file, select the required resident application, i.e. operating system, algorithm library, communication protocol, etc. from the basic library; and edit the ICD information of the simulated device.

[0270] Configure the operating system, communication protocols, algorithm libraries and other resources required by the device to support the code development of resident applications.

[0271] Step S203, ICD editing: edit the ICD template file generated in step 202 through the ICD editing window.

[0272] Step S204, timing simulation control algorithm development: This window is used to edit the code of the timing simulation control algorithm. The timing characteristic information source code of the simulated object selected in step S201 will be imported into the timing simulation control algorithm development window. The window will also load the timer model and algorithm prototype configured in step 202.

[0273] Step S205, resident application code development: This window is used to edit the code of the resident application. According to actual development needs, you can choose to configure the communication protocol, operating system, middle layer, graphics, etc. in the application basic resource library in step S206.

[0274] Step S207 , simulation application compilation: compile the ICD file generated in step 203 , the timing simulation control algorithm code file generated in step 204 , and the resident application code file generated in step 205 into an executable file through a compiler.

[0275] Step S208, application deployment: deploy the executable file generated in step S207 to the simulated hardware device in step S209 to complete the development.

[0276] The simulation method also includes a testing method;

[0277] The test method steps are as follows:

[0278] Step S310: Connect the simulation device to the simulation platform via wired or wireless signals.

[0279] Step S320: Based on the ICD information of the device to be simulated, confirm whether the device under test is consistent with the device described in the ICD after the connection is established, wherein the connection data includes: device, internal functional components of the device, interface functions and interface quantity.

[0280] Step S330: deploy the test activities according to the imported test cases, modify the test cases according to different test requirements and specify the test objects, and after the deployment is completed, drive the simulation device to perform the test.

[0281] Step S340: monitor and record the test process in real time, and display the test information in real time.

[0282] Step S350: record the test information, generate a test report, and evaluate the performance of the simulation device according to the test report.

[0283] like Figure 4 As shown in the figure, the simulation device test process includes the following steps:

[0284] Step S301 , physically connecting the simulation hardware device: connecting the simulation device to the simulation platform via cables, wireless signals, etc.

[0285] Step S302: Synchronous confirmation of the tested object: Based on the ICD information of the simulated device, confirm whether the information such as the device, interface function, and number of interfaces are consistent.

[0286] Step S304, test activity deployment and driving: Deploy the test activities through the test cases imported from the test case management in step S303, and modify the test cases, test objects, etc. according to different test requirements. After the deployment is completed, the simulation equipment can be driven to perform testing.

[0287] Step S305, monitoring and recording the test process: During the test process, the simulation platform will monitor and record the test process in real time, and display the test information on the monitoring page in real time.

[0288] Step S306, test evaluation and result output: Generate a test report based on the test information recorded in step 305, and evaluate the performance of the simulation device based on the test report.

[0289] The principle of the simulated object editing module is as follows:

[0290] Select a real device to be simulated, obtain the hardware performance characteristics of the device through professional analysis, and generate the time domain characteristic chart of the device based on the characteristics; obtain the hardware functional characteristics of the device through professional analysis, and generate the ICD description file of the device based on the characteristics; the interface of the object editing module to be simulated can import and parse the time domain characteristic chart and ICD description file.

[0291] The resource configuration module principle, the interface is implemented as follows:

[0292] The resource configuration interface contains multiple resource libraries, including but not limited to: operating system resources, application foundation resources, algorithm resources, ICD interface resources, communication protocol resources, and extended resources. Operating system resources include but are not limited to FREERTOS and RT-Thread; application foundation resources include but are not limited to graphics libraries, middleware, and API interfaces; algorithm resources include but are not limited to timer algorithms and algorithm prototypes; ICD interface resources include but are not limited to A429-ICD, A664-ICD, CAN-ICD, EN-ICD, and G-ICD; communication protocol resources include but are not limited to CAN protocol, Ethernet protocol, and custom protocols; and extended resources include but are not limited to TTS, image recognition, and speech recognition. The resource configuration interface reads resources from these resource libraries and configures them to the application development interface.

[0293] Application development module principle, the interface is implemented as follows:

[0294] The application development interface obtains the following information: timing and ICD information provided by the simulated object editing interface, and the exported resource files configured in the resource configuration interface. These resources can then be developed accordingly through the application development interface. The edited code files are compiled using a compiler, which generates the corresponding resident application files.

[0295] The principle of application deployment module is implemented as follows:

[0296] Build a physical connection between the simulation device and the simulation platform, complete the deployment of the operating system, resource files, communication protocols, ICD files, and resident applications in different ROM blocks, and after the deployment is complete, the program will be loaded into RAM for execution and verification.

[0297] like Figure 5 As shown in the figure, the working process of the synchronization module of the tested object is shown in the following process:

[0298] Step S801: The object under test is the developed simulation device hardware, and the ICD library is the ICD library file generated by the simulation platform development system;

[0299] Step S802: The measured object synchronization interface performs ICD synchronization between the measured object and the ICD library file;

[0300] Step S803: After synchronization is completed, the corresponding ICD file is parsed;

[0301] Step S804: Generate a corresponding object list according to the analysis result;

[0302] Step S805: Generate a corresponding GUI image according to the analysis result;

[0303] Step S806: The GUI image generated in step S805 is synchronized with the object list information generated in step S804 to obtain a GUI image whose screen changes in real time.

[0304] like Figure 6 As shown in the figure, the workflow of the test library management module is as follows:

[0305] Step S901: import test cases from external files;

[0306] Step S902: Edit the test case according to the temporal characteristics of the object;

[0307] Step S903: Edit the test case in the test case management interface or manage the test case by adding, deleting, modifying, or checking the test case.

[0308] The test case edited in step S904 will be saved in the test case library.

[0309] like Figure 7 As shown in the figure, the working process of the test module is as follows:

[0310] Step S1001: Match the corresponding test case library according to the test object;

[0311] Step S1002: Perform test deployment according to the test object and the matching test case;

[0312] Step S1003: driving the hardware device under test through the test driver;

[0313] Step S1005 , the test monitor captures 1003 the driving signal of the test driver and 1004 the output signal of the tested hardware device;

[0314] Step S1006: Generate a test log file.

[0315] like Figure 8As shown in the figure, the workflow of the test evaluation module is as follows:

[0316] Step S1101: The test evaluation module reads the test log file generated by the test interface;

[0317] Step S1102, the data synchronization module automatically generates a test report file in step S1106 according to the log file in step S1101;

[0318] Step S1103, manually select the test playback function, 1105 the GUI interface playback device output status information, 1104 the object list data synchronously and intuitively displays the playback recorded data;

[0319] Step S1106: Through human intervention, choose to generate a complete test report file or choose to generate a partial module test report file.

[0320] On the other hand, an embodiment of the present disclosure further provides a simulation terminal, including the platform described above.

[0321] The above is only a preferred implementation of the embodiment of the present disclosure. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the principles of the embodiment of the present disclosure. These improvements and modifications should also be considered within the scope of protection of the embodiment of the present disclosure.

Claims

1. A simulation platform for devices with high timing requirements, characterized by: Applied to aviation, aerospace and navigation related equipment, the simulation platform includes: a development system, the development system includes: The simulation object editing module obtains the basic information of the simulation object, timing characteristics information and ICD description information, determines the simulation target, and simulates the timing characteristics and functional characteristics of the simulation device based on the obtained information; timing characteristics information refers to the time series characteristics of the device operation; ICD description information refers to the internal functional components of the device and physical signal definition, device communication interface description, device communication protocol and communication data packet definition; The resource configuration module determines the RTOS version, configures the application basic resource library, configures the algorithm library, simulated device ICD template, and communication protocol to support the development of resident applications and complete the software ecosystem required for resident application deployment. It also has an extension library function for loading other third-party libraries, plug-ins, and API function content; Application development module, used for developing resident applications for simulation devices and developing and compiling timing control algorithms to simulate the functional and performance characteristics of the object to be simulated; The application deployment module uses the operating system deployment module, resource file deployment module, ICD synchronization module, communication protocol deployment module, and resident application deployment module to deploy the software ecosystem, resident applications, and ICD constraints in the order of constraints. The simulation platform further includes: a timing optimization model, the timing optimization model being used to optimize and expand timing logic data corresponding to the device to be simulated obtained according to the measured timing; Specifically, it includes: identifying each timing node; obtaining the node to be optimized based on the timing node, and matching the function of the node to be optimized; obtaining the optimized timing, including: Determine the physical functional modules during the timing execution of the timing nodes; Based on the timing nodes, the nodes to be optimized are obtained, and the functions of the corresponding optimization nodes are matched; the front and back sides of the timing execution of the physical function module are determined, the front and back sides are identified as the nodes to be optimized, and the functions of the corresponding nodes to be optimized are matched; the functions are data feedback and safety warning; The final optimized timing is obtained; wherein the nodes to be optimized include: data feedback and the time of data feedback; The nodes to be optimized also include: a cut-off node to be optimized that is added after the final optimization sequence is completed. When determining the cut-off node to be optimized, the device function corresponding to the timing logic is first judged. If it is an inert function, the cut-off node to be optimized is inserted. Otherwise, if it is an immediate function, the cut-off node to be optimized is not inserted. Each device corresponds to a timing optimization model, and the feedback parameters are optimized and adjusted according to the matching device.

2. The simulation platform according to claim 1, characterized in that: The application development module includes: The resident application code development module is used to write and develop the core functional codes for data acquisition and driving, data processing, signal reception and transmission, and special simulation functions for simulation, simulate the functional characteristics of the simulated object, and realize timing scheduling and control in combination with the timing control algorithm; Timing simulation control algorithm development module, which develops and optimizes algorithms for controlling simulation timing to ensure that the time behavior of the simulation device is consistent with the simulated object; ICD editing matching module edits the internal functional components and signal definitions of the simulation device, constrains the data communication interface and pins, and clarifies the data communication protocol and data packet definition to ensure functional consistency between the simulation device and the simulated object; The compiler module compiles the generated code, algorithm and ICD information in a unified manner, generates deployable application files and ICD files, and completes the packaging of resident applications.

3. The simulation platform according to claim 1, characterized in that: The object to be simulated editing module constructs the simulation device hardware according to a preset hardware architecture standard.

4. The simulation platform according to claim 1, characterized in that: The resource configuration module includes an operating system configuration module, an application basic resource library, an algorithm library configuration module, an ICD configuration module, a communication protocol configuration module, and other resource modules of the extension library; The operating system configuration module is used to select the version of the real-time operating system (RTOS) to provide the runtime environment for the resident application; Apply the basic resource library, set up the basic libraries required by the application, such as graphics library, middle layer and API interface, to provide necessary support for application development; Algorithm library configuration module, select or add specific timing control algorithms and timers according to simulation requirements to implement the required calculation and processing logic; The ICD configuration module stores multiple ICD templates and determines the appropriate interface control document ICD template to ensure interface compatibility between the simulation device and the simulated object. Alternatively, it can automatically parse existing ICD files and generate corresponding simulation code, and also supports dynamic updating of ICD information. A communication protocol configuration module, configured to configure a communication protocol suitable for the simulation device; Extension library other resource modules are used to load other third-party libraries, plug-ins, and API functions.

5. The simulation platform according to any one of claims 1 to 4, characterized in that: The simulation platform also includes a test system, which includes: The object under test synchronization module is used to synchronize the information of the object under test and generate the test GUI, internal components, and communication interface list resources; Test library management module, used to edit and manage test cases; Test module, used to test the object under test; The test evaluation module is used to perform subjective and objective test evaluation and generate test reports.

6. The simulation platform according to claim 5, characterized in that: The object synchronization module includes: The ICD synchronization and confirmation module synchronizes the object under test by connecting to the simulation device to obtain the deployed ICD file and combining it with the ICD file synchronized by the simulation platform development system; The object set generation module parses the ICD content and generates an ICD object set; The GUI generation module generates GUI images according to the ICD object set.

7. The simulation platform according to claim 5, characterized in that: The test module includes: ICD object list display module, used for object-centric test query and synchronous test information display; Test case configuration module, which assigns test cases to ICD objects; Test deployment module, used to deploy the test sequence and test mode; The test driver module generates a test drive script based on the test and associated test cases of the test deployment module, and generates a test data stimulus signal; The test monitor and result recording module is used to monitor the test process and record / save the test process data and use case test results.

8. A simulation method for devices with high timing requirements, using the simulation platform according to any one of claims 1 to 7, characterized in that: The method comprises: According to the determined object to be simulated, configure the corresponding timer model and algorithm prototype, as well as the corresponding ICD template file, and select the required operating system, application basic resource library and communication protocol from the basic library; Edit the ICD template file to generate an ICD file; Load the timer model and algorithm prototype, and edit the timing simulation control algorithm code based on the timer model and algorithm prototype as well as the imported timing characteristic information of the object to be simulated; According to actual development needs, select the corresponding configuration from the application basic resource library to edit the resident application code; Compile the ICD file, the timing simulation control algorithm code file, and the resident application code file into an executable file; and deploy the executable file to the simulation hardware device.

Images