A spacecraft intelligent software virtual simulation test scene intelligent generation method

Abstract

The application relates to a spacecraft intelligent software virtual simulation test scene intelligent generation method, and belongs to the technical field of spacecraft software testing and simulation, which comprises the following steps: an IR structure with rich semantics is defined in advance; through a preset structured prompt word, a large language model LLM is called to recognize and extract task targets, entities, behaviors, environments, constraints and disturbance elements in natural language instructions; the LLM analyzes the extracted elements into nodes, node attributes and time sequence relationships, logical relationships and hierarchical relationships between the nodes in the predefined IR structure, generates a structured IR; a generated IR JSON file is loaded, and according to a preconfigured conversion rule library of the IR structure to a scene description language, the structured IR is converted into an executable simulation script; a simulation engine analyzes and executes the script, and instantiates a specific and high-fidelity test scene. The problems of low automation, high professional threshold and poor scalability in the simulation test of spacecraft intelligent software are solved.

Description

Technical Field

[0001] This invention belongs to the field of spacecraft software testing and simulation technology, and relates to an intelligent generation method for virtual simulation test scenarios of spacecraft intelligent software. It is particularly suitable for testing and verification of key intelligent software such as spacecraft autonomous navigation systems, visual recognition algorithms, and intelligent decision-making modules. Background Technology

[0002] With the intelligent development of space missions such as deep space exploration and on-orbit servicing, intelligent software, represented by autonomous navigation, visual recognition, and intelligent decision-making, has become a core component of spacecraft. To ensure the reliability and safety of such software during on-orbit operation, thorough high-fidelity simulation testing on the ground is essential. The core of simulation testing lies in constructing a large number of test scenarios covering normal, boundary, and fault conditions. However, current methods for constructing space test scenarios have significant bottlenecks, severely restricting testing efficiency and effectiveness.

[0003] Currently, mainstream test scenario generation methods heavily rely on test engineers manually writing simulation scripts or performing complex configurations through graphical interfaces. Taking the use of scene description languages ​​or simulation tools such as Scenic and Unity as examples, engineers need to manually decompose task requirements (e.g., "the lunar rover moves from point A to point B, avoiding rock obstacles along the way") into specific model parameters, logical rules, and behavioral sequences, and then write the code line by line. This method mainly suffers from the following drawbacks: (1) Low level of automation and low construction efficiency: The process of manually writing scripts is cumbersome and inefficient. It is difficult to quickly generate scene combinations that cover different terrain features, lighting conditions, obstacle layouts and sensor noise modes. This cannot meet the massive scene requirements for full testing of intelligent software and becomes an efficiency bottleneck in the testing process.

[0004] (2) High professional threshold and easy to introduce human error: Manual script writing requires testers to have in-depth knowledge of aerospace missions, be familiar with the specific syntax and API of simulation tools, and have software programming skills. It requires a high level of composite ability. This dependence makes script writing difficult to popularize, and manual operation is very easy to introduce errors into the script due to negligence or misunderstanding of requirements, thereby affecting the accuracy of the testing process and the reliability of the test results.

[0005] (3) Poor scalability and flexibility: Once the testing requirements change (such as updating task rules, adding new perturbation models or adjusting entity parameters), it is often necessary to rewrite or modify the script extensively. Existing manual writing or configuration methods often require rewriting or modifying the script extensively, resulting in low code reusability and a slow adaptation process. This makes it difficult for the test scenario library to evolve in sync with the rapid iteration of intelligent software algorithms and to adapt to the testing requirements under the rapid evolution of intelligent algorithms.

[0006] While research has explored the use of natural language processing (NLP) to assist in scene generation in other fields such as autonomous driving (e.g., converting NLP commands into intermediate representations), directly applying such methods to the aerospace field faces significant challenges. Aerospace missions are highly specific in terms of mission objectives (e.g., sampling, imaging), physical objects (e.g., rovers, landers, lunar soil), environmental constraints (low gravity, extreme lighting), and disturbance models (sensor noise, wheel slippage), resulting in entirely different syntax and semantics for their scene description languages ​​(e.g., Scenic). Current technologies lack a complete solution for the aerospace field that can accurately capture mission semantics and automate the conversion to a specific simulation language (e.g., Scenic). There is an urgent need for an automated, intelligent test scene generation method capable of targeting and identifying critical fault scenarios to comprehensively improve the testing efficiency and reliability of spacecraft intelligent software.

[0007] Therefore, there is an urgent need for a natural language-driven scene generation method that can lower the threshold for script writing, improve scene construction efficiency and automation level, and is specifically suitable for the aerospace testing field. Summary of the Invention

[0008] The technical problem solved by this invention is to overcome the shortcomings of the prior art and propose an intelligent generation method for virtual simulation test scenarios of spacecraft intelligent software. This method aims to solve the problems of low automation, high professional threshold and poor scalability caused by the high dependence on manual labor in the current simulation test of spacecraft intelligent software.

[0009] The solution to the technical problem of this invention is as follows: Firstly, a method for intelligently generating virtual simulation test scenarios for spacecraft intelligent software is provided, comprising the following steps: A semantically rich Interactive Resource (IR) structure is predefined, comprising node types, node attributes, and temporal, logical, and hierarchical relationships between nodes. The node attributes describe task parameters, object states, environment parameters, constraints, perturbation parameters, unit information, and coordinate system information. The node types include: Task Objective: describing the core task and its attributes; Entity: describing the physical objects participating in the task and their physical parameters and states; Behavior: describing atomic operations and their parameters; Environment: describing global environmental conditions; Constraints: describing physical or security rules that must be followed; Perturbation: describing injected test perturbations. By using pre-set structured prompts, the integrated large language model LLM is invoked to identify and extract task objectives, entities, behaviors, environment, constraints, and perturbation elements from natural language instructions; The Large Language Model (LLM) parses the extracted elements into nodes, node attributes, and temporal, logical, and hierarchical relationships between nodes in a predefined IR structure, constructs a complete hierarchical IR structure, and outputs it in JSON format to generate a structured IR. The generated IR JSON file is loaded, and the structured IR is converted into an executable simulation script according to the pre-configured IR structure to scene description language conversion rule library. The conversion rule library includes node type mapping rules, attribute mapping rules, temporal logic conversion rules, constraint expression conversion rules, parameter randomization rules, unit and coordinate conversion rules, and simulation engine adaptation rules. The executable simulation script is loaded into the target simulation engine. The simulation engine parses and executes the script, instantiates a specific, high-fidelity test scenario based on the parameters and distribution function in the script, and drives the spacecraft intelligent software to run in the scenario to complete the test task.

[0010] Furthermore, the preset structured prompts include: Role constraint information is used to limit the large language model to act as a semantic parser for aerospace test scenarios, and to output results only within the scope of predefined IR node types and attributes; Field template constraint information is used to specify the field names, field types, required fields, and optional fields for each node of task objectives, entities, behaviors, environments, constraints, and disturbances; Domain-specific vocabulary constraint information is used to provide entity categories, behavior categories, environment categories, disturbance categories, and their synonym mapping tables related to aerospace missions; Relationship extraction constraint information is used to guide large language models in recognizing temporal relationships, dependencies, subordinate relationships, object relationships, and constraint scope between nodes; Output format constraints are used to require large language models to output in a predefined JSON format and to prohibit the output of unstructured interpretable text. Ambiguity handling constraint information is used to select default values, mark fields to be confirmed, or output default prompt information according to preset priorities when there is ambiguity or missing information in the natural language description.

[0011] Furthermore, the pre-configured IR structure to scene description language conversion rule base specifically includes: Node type mapping rules are used to map task target nodes, entity nodes, behavior nodes, environment nodes, constraint nodes, and disturbance nodes in IR to corresponding syntactic units in the scene description language; Attribute mapping rules are used to map node attributes to object parameters, environment parameters, behavior parameters, or model parameters; Timing logic transformation rules are used to convert the order, dependency, and concurrency relationships between behavior nodes into timing control statements in the script; Constraint expression conversion rules are used to convert constraint nodes into constraint condition expressions in the script. The constraint nodes include safe distance, attitude range, speed limit, and reachable area. The parameter randomization rule is used to map the entity location, disturbance intensity, environmental parameters and initial state parameters in the IR structure to a random distribution function or a region sampling function to generate multiple scene variants; Unit and coordinate transformation rules are used to standardize the conversion of length units, velocity units, time units, angle units, and parameters of different coordinate systems in the IR structure; Simulation engine adaptation rules are used to generate script fragments or configuration files that are compatible with the target simulation engine, based on the target simulation engine's interface specifications, object naming conventions, environment configuration requirements, and script organization methods.

[0012] Furthermore, the node type mapping rules in the conversion rule base include the following mapping relationships: Map the task target node to the task definition statement in the scene description language; Map entity nodes to object definition statements; Map behavior nodes to action definition statements; Map constraint nodes to restriction condition statements; Map environment nodes and disturbance nodes to corresponding parameterized model definition statements.

[0013] Furthermore, before loading the executable simulation script into the target simulation engine, the following steps are performed: visualizing and manually verifying and editing the structured IR and the executable simulation script.

[0014] Secondly, a spacecraft intelligent software virtual simulation test scenario intelligent generation system is provided, including a human-computer interaction module, a natural language parsing module, a script generation module, and a scenario management module; Human-computer interaction module: used to receive natural language task descriptions input by users and to visualize the generated IR structure and simulation script; Natural Language Parsing Module: Integrates Large Language Model (LLM), responsible for parsing natural language task descriptions into structured IR and outputting them in JSON format; Script generation module: It has a built-in rule library for converting IR structure to scene description language, which converts structured IR into executable simulation scripts compatible with the target simulation engine; the conversion rule library includes node type mapping rules, attribute mapping rules, temporal logic conversion rules, constraint expression conversion rules, parameter randomization rules, unit and coordinate conversion rules, and simulation engine adaptation rules; Scene management module: Used for storing, versioning, and exporting generated simulation scripts.

[0015] Furthermore, the conversion rule base specifically includes: Node type mapping rules are used to map task target nodes, entity nodes, behavior nodes, environment nodes, constraint nodes, and disturbance nodes in IR to corresponding syntactic units in the scene description language; Attribute mapping rules are used to map node attributes to object parameters, environment parameters, behavior parameters, or model parameters; Timing logic transformation rules are used to convert the order, dependency, and concurrency relationships between behavior nodes into timing control statements in the script; Constraint expression conversion rules are used to convert constraint nodes into constraint condition expressions in the script. The constraint nodes include safe distance, attitude range, speed limit, and reachable area. The parameter randomization rule is used to map the entity location, disturbance intensity, environmental parameters and initial state parameters in the IR structure to a random distribution function to generate multiple scene variants; Unit and coordinate transformation rules are used to standardize the transformation of length, velocity, time, angle, and coordinate system parameters in the IR structure; Simulation engine adaptation rules are used to generate script fragments or configuration files that are compatible with the target engine, based on differences in the target simulation engine or scene description language.

[0016] A computer-readable storage medium storing a computer program, wherein the computer program, when executed by a processor, implements the steps of the intelligent generation method for a spacecraft intelligent software virtual simulation test scenario.

[0017] An electronic device includes a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the steps of the intelligent generation method for a spacecraft intelligent software virtual simulation test scenario.

[0018] A computer program product includes a computer program that, when executed by a processor, implements the steps of the intelligent generation method for a spacecraft intelligent software virtual simulation test scenario.

[0019] The advantages of this invention compared to the prior art are: The natural language-driven aerospace test scenario generation method and system provided by this invention, by introducing a large language model (LLM) and structured intermediate representation (IR) as core intermediaries, brings the following significant benefits: (1) Significantly improve scene construction efficiency and automation level By automatically converting natural language instructions into executable scripts, this invention completely changes the inefficient model of relying on manual code writing. Users (test engineers, task planning experts) do not need to learn the specific syntax details of scenario description languages ​​such as Scenic; they only need to input a high-level task description, and the system can generate complex scenarios in minutes or even seconds, improving scenario building efficiency by an order of magnitude and solving the bottleneck problem of the number of scenarios faced by large-scale simulation testing.

[0020] (2) Significantly reduces the professional threshold for scene construction and the risk of human error. This invention encapsulates the professional knowledge required for test scenario construction (such as aerospace mission semantics and simulation language syntax) within LLM prompts and IR conversion rules. Testers only need aerospace mission knowledge to describe the scenarios, reducing the rigid requirements for programming skills and alleviating the workload. Simultaneously, the automated parsing and conversion process avoids syntax errors, logical errors, and parameter configuration errors that are prone to occur in manual coding, greatly improving the accuracy and reliability of the generated scripts.

[0021] (3) Enhance the diversity and coverage of scenarios By introducing parameter randomization (such as replacing fixed coordinates with probability distributions) during the IR-to-script conversion process, the system can automatically derive a large number of scene variations with different parameters (such as different obstacle layouts, different lighting conditions, and different disturbance intensities) from a single task description. This mechanism efficiently generates a diverse set of scenes covering a wider range of test conditions, which is beneficial for more fully testing the performance of intelligent software under different conditions and improving the coverage and robustness verification level of the test.

[0022] (4) Improve the scalability and maintainability of the testing process. The IR-based intermediate presentation layer decouples the volatile natural language / scripting language from the core business logic. When task requirements change or new entity, behavior, constraint, or perturbation types need to be supported, rapid adaptation can be achieved by updating structured prompts, expanding IR structure definitions, and adjusting the transformation rule base, without rewriting a large amount of script code or modifying the core system architecture. This design enables the testing system to quickly adapt to new testing requirements, significantly improving the flexibility and maintainability of the entire testing process, and is well-suited to the rapid iteration of spacecraft intelligent software. Attached Figure Description

[0023] Figure 1 This is a flowchart of a method for intelligently generating virtual simulation test scenarios for spacecraft using intelligent software, according to the present invention. Figure 2This is a framework diagram of a method for intelligently generating virtual simulation test scenarios for spacecraft using intelligent software, as described in this invention. Detailed Implementation

[0024] The present invention will be further described below with reference to the accompanying drawings and embodiments.

[0025] This invention provides a method for intelligently generating virtual simulation test scenarios for spacecraft intelligent software. The overall flow of the method is shown in Figure 1. The core of the method lies in constructing an automated conversion pipeline of "natural language task description - domain-specific structured intermediate representation (IR) - executable simulation script", which specifically includes the following steps: Step 1: Receive and parse the natural language task description, including: (1) A semantically rich IR structure is predefined, which includes node types, node attributes, and temporal, logical, and hierarchical relationships between nodes. The node types include Mission, Entities, Actions, Environment, Constraints, and Disturbances; the node attributes are used to describe task parameters, object states, environment parameters, constraints, disturbance parameters, unit information, and coordinate system information.

[0026] Mission Objective: Describes the core task (such as patrol, sampling, and photography) and its attributes (such as priority and completion threshold). Entities: Describe the physical objects (such as rovers, rocks, and landers) involved in the mission and their physical parameters (mass, size) and status; Actions: Describe atomic operations (such as movement, rotation, and shooting) and their parameters (target, velocity, duration); Environment: Describes global environmental conditions (such as terrain type and light intensity); Constraints: Describe the physical or safety rules that must be followed (such as obstacle avoidance, maximum slope); Disturbances: Describes injected test disturbances (such as sensor noise, communication delay).

[0027] (2) By using pre-set structured prompts, the integrated large language model LLM is invoked to identify and extract key elements such as task objectives, entities, behaviors, environment, constraints and disturbances in natural language instructions.

[0028] The preset structured prompts include: Role constraint information is used to limit the large language model to act as a semantic parser for aerospace test scenarios, and to output results only within the scope of predefined IR node types and attributes; Field template constraint information is used to specify the field names, field types, required fields, and optional fields for each node of task objectives, entities, behaviors, environments, constraints, and disturbances; Domain-specific vocabulary constraint information is used to provide entity categories, behavior categories, environment categories, disturbance categories, and their synonym mapping tables related to aerospace missions; Relationship extraction constraint information is used to guide large language models in recognizing temporal relationships, dependencies, subordinate relationships, object relationships, and constraint scope between nodes; Output format constraints are used to require large language models to output in a predefined JSON format and to prohibit the output of unstructured interpretable text. Ambiguity handling constraint information is used to select default values, mark fields to be confirmed, or output default prompt information according to preset priorities when there is ambiguity or missing information in the natural language description.

[0029] Step 2: Generate structured IR, including: The Large Language Model (LLM) parses the elements extracted in step one into nodes, node attributes, and temporal, logical, and hierarchical relationships between nodes in a predefined IR structure, constructs a complete hierarchical IR structure, and outputs it in JSON format to generate a structured IR.

[0030] Step 3: Convert the structured IR into an executable simulation script, including: Load the generated IR JSON file, extract the corresponding rules from the pre-configured IR structure to scene description language conversion rule library, and automatically convert the structured IR generated in step two into an executable simulation script that conforms to the syntax specification of the scene description language.

[0031] The conversion rule base includes: node type mapping rules, attribute mapping rules, temporal logic conversion rules, constraint expression conversion rules, parameter randomization rules, unit and coordinate conversion rules, and simulation engine adaptation rules.

[0032] The process specifically includes: a) Node type mapping: The node type is converted according to the predefined mapping rules between IR node types and scene description language syntax elements. This includes converting task target nodes into task definition statements, entity nodes into object definition statements, behavior nodes into action definition statements, constraint nodes into constraint condition statements, and environment nodes and disturbance nodes into corresponding parameterized model definition statements.

[0033] b) Attribute mapping: Map the size, mass, and initial state of entities in the IR structure, the light intensity and gravity parameters in the environment, the target, velocity, and duration in the behavior, and the noise amplitude and time delay range in the disturbance to the corresponding script parameters.

[0034] c) Sequence logic conversion: Convert the order, dependency, and concurrency relationships between behavior nodes into sequential execution, dependency triggering, or concurrency control statements in the script.

[0035] d) Constraint expression conversion: Convert constraint nodes such as safe distance, attitude range, maximum speed, and area accessibility into constraint condition expressions in the script.

[0036] e) Parameter randomization: Replace parameters such as entity position, attitude angle, obstacle layout, light intensity, sensor noise amplitude, communication delay, and wheel slip coefficient with random distribution functions or regional sampling functions to generate multiple scene variants.

[0037] f) Unit and coordinate transformation: Standardize and transform the length units, velocity units, time units, angle units, and parameters of different coordinate systems in IR to meet the input requirements of the target scene description language or simulation engine.

[0038] g) Simulation engine adaptation: Generate script fragments or engine configuration files that are compatible with the target simulation engine, based on the target simulation engine's interface specifications, object naming conventions, environment configuration requirements, and script organization methods.

[0039] Step 4: Execute the simulation script and generate the scene, including: The structured IR generated in step two and the executable simulation script generated in step three are visualized and manually verified and edited. The executable simulation script is loaded into the target simulation engine, which parses and executes the script. Based on the parameters and distribution function in the script, a specific, high-fidelity test scenario is instantiated, and the spacecraft intelligent software is driven to run in the scenario to complete the test task.

[0040] This invention also provides a natural language-driven aerospace test scenario generation system that implements the above-described method, such as... Figure 2 As shown, it includes: Human-computer interaction module: used to receive natural language task descriptions input by users and to visualize the generated IR structure and simulation script; Natural Language Parsing Module: Integrates a Large Language Model (LLM) to parse natural language task descriptions into structured IRs and output them in JSON format; Script Generation Module: Contains a built-in rule library for converting IR structures into scene description languages, converting structured IRs into executable simulation scripts compatible with the target simulation engine; the conversion rule library includes node type mapping rules, attribute mapping rules, temporal logic conversion rules, constraint expression conversion rules, parameter randomization rules, unit and coordinate conversion rules, and simulation engine adaptation rules; Scene Management Module: Used for storing, versioning, and exporting generated scene script files.

[0041] The workflow of the aerospace test scenario generation system is as follows: Step 1: The user inputs a natural language command describing the aerospace test mission through the system's human-computer interaction interface. After receiving the command, the system invokes the integrated Large Language Model (LLM) service for deep semantic parsing. Guided by pre-set structured prompts rich in aerospace domain knowledge, the LLM extracts key elements such as mission objectives, behaviors, entities, environment, constraints, and disturbances from the command.

[0042] The second step: LLM maps the elements parsed in the first step to the corresponding nodes of the IR structure predefined for the aerospace testing domain. The core node types of the IR structure include Mission, Entities, Actions, Environment, Constraints, and Disturbances. Based on the temporal, logical, and hierarchical relationships implicit in the instructions, LLM constructs a complete, hierarchical IR structure and outputs it in JSON format, generating a structured IR that accurately expresses the user's mission intent and completely eliminates the ambiguity of natural language.

[0043] Step 3: The system's script generation module loads the IR JSON file generated in Step 2 and automatically converts the structured IR into an executable simulation script based on the pre-configured IR structure to scene description language conversion rule library. The conversion rule library includes node type mapping rules, attribute mapping rules, temporal logic conversion rules, constraint expression conversion rules, parameter randomization rules, unit and coordinate conversion rules, and simulation engine adaptation rules, ensuring that the generated script conforms to the target scene description language syntax and is compatible with the target simulation engine. Preferably, the scene description language is Scenic.

[0044] Taking Scenic as the preferred scene description language as an example, this process converts the "task objective" node into a mission definition, the "entity" node into an object definition, the "behavior" node into an action definition and uses the after keyword to handle timing, the "constraint" node into a require statement, and the "environment" and "disturbance" nodes into corresponding parameterized models (such as model Camera.noise = Uniform(0.05, 0.1)).

[0045] Meanwhile, to enhance scenario diversity, fixed parameters (such as entity location) in the IR structure can be replaced with random distribution functions (such as UniformCircle).

[0046] Finally, the system outputs a syntactically correct .scenic script file that can be directly loaded and executed by a simulation engine (such as Webots).

[0047] Step 4: Load the .scenic script file generated in Step 3 into the target simulation engine. The simulation engine parses and executes the script, instantiates a specific, high-fidelity test scenario based on the parameters and distribution function in the script, and drives the spacecraft intelligent software to run in the scenario to complete the test task.

[0048] Example 1 This embodiment uses a "lunar rover obstacle avoidance and navigation mission" as an example to specifically illustrate the steps of the method of the present invention.

[0049] (1) User input command: "The Yutu rover starts from the base located at (10,10), avoids the rocky area ahead, and travels to the scientific sampling point at (35,30). Throughout the journey, it must maintain a distance of more than 1.5 meters from obstacles. The lunar surface illumination is the same as Earth day, and there is camera sensor noise." (2) The LLM parses the instruction and generates a structured intermediate representation (IR, in JSON format). For example, it identifies behavioral nodes such as "movement" and "sampling", entity nodes such as "rovers" and "rocky areas", constraint nodes such as "maintain distance", and environmental and disturbance nodes such as "lighting" and "sensor noise", and establishes the temporal, logical and hierarchical relationships between the nodes.

[0050] (3) The script generation module converts the above structured IR into a Scenic script according to the conversion rules. The following code is an illustrative script snippet: base = Lander at (10, 10) yutu = Rover at (10, 10) rock_field = RockField at UniformCircle(center=(20, 20), radius=5) # Randomize the position sample_site = SampleSite at (35, 30) model Camera.noise = Uniform(0.01, 0.05) # Perturbation parameterization action move_to_sample(): yutu.move_to(sample_site) require always (min_distance(yutu, Obstacle)>1.5) # Constraint transformation In this embodiment, the script generation module converts task objectives, entities, behaviors, constraints, environments, and disturbance nodes into corresponding scene statements according to node type mapping rules; it converts the rock area location and camera noise parameters into random distribution function expressions according to parameter randomization rules; and it outputs .scenic script files that can be loaded by Webots in a way that is compatible with simulation engine adaptation rules.

[0051] (4) Load the generated script into the Webots simulation engine. The engine will randomly determine the specific location of the rocky area and generate a lunar surface environment that meets the requirements of the instructions. The rover's navigation algorithm will run in this scenario to test its obstacle avoidance performance.

[0052] In summary, this invention, targeting the aerospace testing field, effectively solves the challenges of efficiency, barriers to entry, and flexibility in the construction of aerospace testing scenarios through a natural language-driven approach. It not only directly improves the efficiency of current testing but also provides core support for the intelligent development of future testing technologies, possessing significant engineering application value and promising prospects for widespread adoption.

[0053] This application provides a computer-readable storage medium storing computer instructions that, when executed on a computer, cause the computer to perform... Figure 1 The method described.

[0054] Those skilled in the art will understand that embodiments of this application can be provided as methods, systems, or computer program products. Therefore, this application can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, this application can take the form of a computer program product implemented on one or more computer-usable storage media (including, but not limited to, disk storage and optical storage) containing computer-usable program code.

[0055] This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this application. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart... Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0056] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0057] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0058] Obviously, those skilled in the art can make various modifications and variations to this application without departing from the spirit and scope of this application. Therefore, if such modifications and variations fall within the scope of the claims of this application and their equivalents, this application also intends to include such modifications and variations.

[0059] The contents not described in detail in this specification are common knowledge to those skilled in the art.

Claims

1. A method for intelligently generating virtual simulation test scenarios for spacecraft intelligent software, characterized in that, include: A semantically rich Interactive Resource (IR) structure is predefined, comprising node types, node attributes, and temporal, logical, and hierarchical relationships between nodes. The node attributes describe task parameters, object states, environment parameters, constraints, perturbation parameters, unit information, and coordinate system information. The node types include: Task Objective: describing the core task and its attributes; Entity: describing the physical objects participating in the task and their physical parameters and states; Behavior: describing atomic operations and their parameters; Environment: describing global environmental conditions; Constraints: describing physical or security rules that must be followed; Perturbation: describing injected test perturbations. By using pre-set structured prompts, the integrated large language model LLM is invoked to identify and extract task objectives, entities, behaviors, environment, constraints, and perturbation elements from natural language instructions; The Large Language Model (LLM) parses the extracted elements into nodes, node attributes, and temporal, logical, and hierarchical relationships between nodes in a predefined IR structure, constructs a complete hierarchical IR structure, and outputs it in JSON format to generate a structured IR. The generated IR JSON file is loaded, and the structured IR is converted into an executable simulation script according to the pre-configured IR structure to scene description language conversion rule library. The conversion rule library includes node type mapping rules, attribute mapping rules, temporal logic conversion rules, constraint expression conversion rules, parameter randomization rules, unit and coordinate conversion rules, and simulation engine adaptation rules. The executable simulation script is loaded into the target simulation engine. The simulation engine parses and executes the script, instantiates a specific, high-fidelity test scenario based on the parameters and distribution function in the script, and drives the spacecraft intelligent software to run in the scenario to complete the test task.

2. The intelligent generation method for virtual simulation test scenarios of spacecraft intelligent software according to claim 1, characterized in that, The preset structured prompts include: Role constraint information is used to limit the large language model to act as a semantic parser for aerospace test scenarios, and to output results only within the scope of predefined IR node types and attributes; Field template constraint information is used to specify the field names, field types, required fields, and optional fields for each node of task objectives, entities, behaviors, environments, constraints, and disturbances; Domain-specific vocabulary constraint information is used to provide entity categories, behavior categories, environment categories, disturbance categories, and their synonym mapping tables related to aerospace missions; Relationship extraction constraint information is used to guide large language models in recognizing temporal relationships, dependencies, subordinate relationships, object relationships, and constraint scope between nodes; Output format constraints are used to require large language models to output in a predefined JSON format and to prohibit the output of unstructured interpretable text. Ambiguity handling constraint information is used to select default values, mark fields to be confirmed, or output default prompt information according to preset priorities when there is ambiguity or missing information in the natural language description.

3. The intelligent generation method for virtual simulation test scenarios of spacecraft intelligent software according to claim 1, characterized in that, The pre-configured IR structure to scene description language conversion rule base specifically includes: Node type mapping rules are used to map task target nodes, entity nodes, behavior nodes, environment nodes, constraint nodes, and disturbance nodes in IR to corresponding syntactic units in the scene description language; Attribute mapping rules are used to map node attributes to object parameters, environment parameters, behavior parameters, or model parameters; Timing logic transformation rules are used to convert the order, dependency, and concurrency relationships between behavior nodes into timing control statements in the script; Constraint expression conversion rules are used to convert constraint nodes into constraint condition expressions in the script. The constraint nodes include safe distance, attitude range, speed limit, and reachable area. The parameter randomization rule is used to map the entity location, disturbance intensity, environmental parameters and initial state parameters in the IR structure to a random distribution function or a region sampling function to generate multiple scene variants; Unit and coordinate transformation rules are used to standardize the conversion of length units, velocity units, time units, angle units, and parameters of different coordinate systems in the IR structure; Simulation engine adaptation rules are used to generate script fragments or configuration files that are compatible with the target simulation engine, based on the target simulation engine's interface specifications, object naming conventions, environment configuration requirements, and script organization methods.

4. The intelligent generation method for virtual simulation test scenarios of spacecraft intelligent software according to claim 3, characterized in that, The node type mapping rules in the conversion rule base include the following mapping relationships: Map the task target node to the task definition statement in the scene description language; Map entity nodes to object definition statements; Map behavior nodes to action definition statements; Map constraint nodes to restriction condition statements; Map environment nodes and disturbance nodes to corresponding parameterized model definition statements.

5. The intelligent generation method for virtual simulation test scenarios of spacecraft intelligent software according to claim 1, characterized in that, Before loading the executable simulation script into the target simulation engine, the following steps are performed: visualization and manual verification and editing of the structured IR and executable simulation script.

6. A spacecraft intelligent software virtual simulation test scenario intelligent generation system, used to implement the spacecraft intelligent software virtual simulation test scenario intelligent generation method as described in any one of claims 1 to 5, characterized in that, It includes a human-computer interaction module, a natural language parsing module, a script generation module, and a scene management module; Human-computer interaction module: used to receive natural language task descriptions input by users and to visualize the generated IR structure and simulation script; Natural Language Parsing Module: Integrates Large Language Model (LLM), responsible for parsing natural language task descriptions into structured IR and outputting them in JSON format; Script generation module: It has a built-in rule library for converting IR structure to scene description language, which converts structured IR into executable simulation scripts compatible with the target simulation engine; the conversion rule library includes node type mapping rules, attribute mapping rules, temporal logic conversion rules, constraint expression conversion rules, parameter randomization rules, unit and coordinate conversion rules, and simulation engine adaptation rules; Scene management module: Used for storing, versioning, and exporting generated simulation scripts.

7. The intelligent generation system for virtual simulation test scenarios of spacecraft intelligent software according to claim 6, characterized in that, The conversion rule base specifically includes: Node type mapping rules are used to map task target nodes, entity nodes, behavior nodes, environment nodes, constraint nodes, and disturbance nodes in IR to corresponding syntactic units in the scene description language; Attribute mapping rules are used to map node attributes to object parameters, environment parameters, behavior parameters, or model parameters; Timing logic transformation rules are used to convert the order, dependency, and concurrency relationships between behavior nodes into timing control statements in the script; Constraint expression conversion rules are used to convert constraint nodes into constraint condition expressions in the script. The constraint nodes include safe distance, attitude range, speed limit, and reachable area. The parameter randomization rule is used to map the entity location, disturbance intensity, environmental parameters and initial state parameters in the IR structure to a random distribution function or a region sampling function to generate multiple scene variants; Unit and coordinate transformation rules are used to standardize the transformation of length, velocity, time, angle, and coordinate system parameters in the IR structure; Simulation engine adaptation rules are used to generate script fragments or configuration files that are compatible with the target engine, based on differences in the target simulation engine or scene description language.

8. A computer-readable storage medium storing a computer program, characterized in that, When the computer program is executed by a processor, it implements the steps of the method as described in any one of claims 1 to 5.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements the steps of the method as described in any one of claims 1 to 5.

10. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by a processor, it implements the steps of the method as described in any one of claims 1 to 5.

Images