Method and device for realizing on-orbit operation and on-orbit autonomous operation of spacecraft

Abstract

The present invention discloses a method and device for realizing on-orbit operation and autonomous on-orbit operation of a spacecraft, and belongs to the technical field of on-orbit operation of a spacecraft. The method comprises: in response to a control command sent by a ground control terminal, creating a virtual machine in an engine, creating a new coroutine in the virtual machine, using the new coroutine to load an on-orbit control program from an onboard memory into the virtual machine and activating the on-orbit control program, establishing an association relationship among a virtual machine identifier, a coroutine identifier, and an on-orbit control program identifier; adding a coroutine associated with the on-orbit control program to a scheduling queue, and scheduling the coroutines in the scheduling queue according to a preset scheduling strategy, so as to utilize the coroutine to run the on-orbit control program associated with it. In the present invention, the ground control terminal only participates in the preparation process of the on-orbit control program in the early stage, and the operation process of the on-orbit control program is completely autonomously operated by the spacecraft, which can realize flexible adaptation of application scenarios.

Description

Technical Field

[0001] The present invention relates to the technical field of on-orbit operation of spacecraft, and in particular to a method and device for realizing on-orbit operation and autonomous on-orbit operation of a spacecraft. Background Art

[0002] To reduce reliance on ground personnel for spacecraft on-orbit operations and manipulation, users are increasingly demanding autonomous capabilities. In mission scenarios requiring a high degree of autonomy, such as deep space exploration and where continuous tracking and control cannot be guaranteed, the complexity, unpredictability, and fleeting nature of on-orbit missions make autonomous on-orbit operations and manipulation crucial to mission success.

[0003] Currently, spacecraft still rely heavily on ground-based manual operations, primarily relying on timed and programmed commands within onboard software to achieve autonomous on-orbit operation and operation. These commands are typically pre-programmed sequences of instructions with timed information pre-bound to the onboard software, which then executes them automatically according to the trigger times in the sequence.

[0004] Since the sequence content is pre-designed fixed instruction data, it can only be executed sequentially and can only meet deterministic application scenarios, but cannot meet flexible and complex application requirements. Summary of the Invention

[0005] The present invention provides a method and apparatus for achieving on-orbit operation and autonomous on-orbit operation of a spacecraft. The technical solution is as follows:

[0006] In one aspect, a method for implementing on-orbit operation and autonomous on-orbit operation of a spacecraft is provided, the method being applied to an onboard computer, the onboard computer being disposed in the spacecraft, the onboard computer having onboard software installed therein, and adding an engine to the onboard software. The method comprises:

[0007] In response to a control command sent by a ground control terminal, a virtual machine is created in the engine, a new coroutine is created in the virtual machine, an on-orbit control program is loaded from an onboard memory into the virtual machine using the new coroutine, the on-orbit control program is activated, and an association relationship is established between the virtual machine identifier, the coroutine identifier, and the on-orbit control program identifier; the on-board memory stores at least one on-orbit control program;

[0008] The coroutine associated with the on-orbit control program is added to the scheduling queue, and the coroutine in the scheduling queue is scheduled according to the preset scheduling strategy, so as to use the coroutine to run the on-orbit control program associated with it.

[0009] In another aspect, a device for implementing on-orbit operation and on-orbit autonomous operation of a spacecraft is provided, the device being applied to an onboard computer, the onboard computer being disposed in the spacecraft, the onboard computer being installed with onboard software, and an engine for implementing on-orbit autonomous operation being added to the onboard software. The device comprises:

[0010] a command execution unit, configured to respond to a control command sent by a ground control terminal, create a virtual machine in the engine, create a new coroutine in the virtual machine, use the new coroutine to load an on-orbit control program from an onboard memory into the virtual machine, activate the on-orbit control program, and establish an association between a virtual machine identifier, a coroutine identifier, and an on-orbit control program identifier; the on-board memory storing at least one on-orbit control program;

[0011] The program scheduling unit is used to add the coroutine associated with the on-orbit control program to the scheduling queue, and schedule the coroutine in the scheduling queue according to the preset scheduling strategy, so as to use the coroutine to run the on-orbit control program associated with it.

[0012] On the other hand, a computer device is provided, which includes a memory and a processor, wherein the memory is used to store computer programs, and the processor is used to execute the computer programs stored in the memory to implement the steps of the above-mentioned method for realizing on-orbit operation and on-orbit autonomous operation of a spacecraft.

[0013] On the other hand, a computer-readable storage medium is provided, in which a computer program is stored. When the computer program is executed by a processor, the steps of the above-mentioned method for implementing the on-orbit operation and autonomous on-orbit operation of the spacecraft are implemented.

[0014] On the other hand, a computer program product is provided, comprising a computer program, which, when executed by a processor, implements the steps of the above-mentioned method for implementing on-orbit operation and on-orbit autonomous operation of a spacecraft.

[0015] The technical solution provided by the present invention can at least bring the following beneficial effects:

[0016] By adding an engine to the onboard software, the ground control terminal sends a control command to the onboard computer to create a virtual machine in the engine and a new coroutine in the virtual machine. The new coroutine is then used to load the onboard control program from the onboard memory into the virtual machine and activate the onboard control program. Then, by establishing an association between the virtual machine identifier, the coroutine identifier, and the onboard control program identifier, the coroutine is added to the scheduling queue. Finally, the coroutines in the scheduling queue are scheduled using a preset scheduling strategy to use the coroutine to run the onboard control program with which it is associated. In this solution, after determining the current application scenario, the ground control terminal can select an onboard control program that is adapted to the application scenario, so that the onboard computer runs the onboard control program that is adapted to the application scenario on orbit, thereby achieving on-orbit autonomous operation. It can be seen that in this solution, the ground control terminal only participates in the early preparation process of the on-orbit control program, and the operation process of the on-orbit control program is completely autonomously operated by the spacecraft, thereby achieving flexible adaptation of the application scenario. BRIEF DESCRIPTION OF THE DRAWINGS

[0017] In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the following briefly introduces the drawings required for use in the embodiments or the description of the prior art. Obviously, the drawings described below are some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0018] Figure 1 This is a flow chart of a method for implementing on-orbit operation and on-orbit autonomous operation of a spacecraft provided by one embodiment of the present invention;

[0019] Figure 2 1 is a schematic diagram of an architecture for achieving on-orbit operation and on-orbit autonomous operation provided by an embodiment of the present invention;

[0020] Figure 3 1 is a schematic diagram of the transition of the running state of the on-orbit control program provided by an embodiment of the present invention;

[0021] Figure 4 This is a structural diagram of a device for implementing on-orbit operation and on-orbit autonomous operation of a spacecraft provided by one embodiment of the present invention;

[0022] Figure 5 This is a hardware architecture diagram of a computer device provided by one embodiment of the present invention. DETAILED DESCRIPTION

[0023] In order to make the purpose, technical solutions and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are part of the embodiments of the present invention, not all the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative work are within the scope of protection of the present invention.

[0024] To achieve on-orbit operation and autonomous on-orbit operation of spacecraft, the ground control end's monitoring and control of the spacecraft based on downlink telemetry data and uplink remote control commands needs to be programmed to form an on-orbit control procedure (OBCP), which is then autonomously executed on-orbit according to a specific scheduling strategy. Using an on-orbit control procedure to achieve autonomous on-orbit operation of a spacecraft is like having a flight control operator on-orbit. Compared to manual operation, on-orbit time-stamp commands, and on-orbit program commands from the ground control end, this offers significant advantages. It can greatly reduce or even eliminate reliance on the ground to complete the spacecraft's autonomous on-orbit operation process, greatly improving the spacecraft's autonomous on-orbit capability.

[0025] The specific implementation of the above concept is described below.

[0026] Please refer to Figure 1 An embodiment of the present invention provides a method for implementing on-orbit operation and autonomous on-orbit operation of a spacecraft, which is applied to an onboard computer. The onboard computer is provided in the spacecraft, and onboard software is installed in the onboard computer. An engine is added to the onboard software. The method includes:

[0027] Step 100: In response to a control command sent by the ground control terminal, a virtual machine is created in the engine, and a new coroutine is created in the virtual machine. The new coroutine is used to load an on-orbit control program from the on-board memory into the virtual machine and activate the on-orbit control program. An association is established between the virtual machine identifier, the coroutine identifier, and the on-orbit control program identifier; the on-board memory stores at least one on-orbit control program.

[0028] Step 102 : Add the coroutine associated with the on-orbit control program to a scheduling queue, and schedule the coroutines in the scheduling queue according to a preset scheduling policy, so as to utilize the coroutine to run the on-orbit control program associated with it.

[0029] In an embodiment of the present invention, an engine is added to the onboard software, and a control command is sent from the ground control terminal to the onboard computer to create a virtual machine in the engine and a new coroutine in the virtual machine. The new coroutine is then used to load the onboard control program from the onboard memory into the virtual machine and activate the onboard control program. Then, an association is established between the virtual machine identifier, the coroutine identifier, and the onboard control program identifier, and the coroutine is added to the scheduling queue. Finally, the coroutines in the scheduling queue are scheduled using a preset scheduling strategy, so that the coroutine is used to run the onboard control program with which it is associated. In this solution, after determining the current application scenario, the ground control terminal can select an onboard control program that is adapted to the application scenario, so that the onboard computer runs the onboard control program that is adapted to the application scenario on orbit, thereby achieving autonomous on-orbit operation. It can be seen that in this solution, the ground control terminal only participates in the early preparation process of the onboard control program, and the operation process of the onboard control program is completely autonomously operated by the spacecraft, thereby achieving flexible adaptation of the application scenario.

[0030] Described below Figure 1 Before describing how the various steps are performed, the overall architecture for achieving autonomous on-orbit operations is described.

[0031] Please refer to Figure 2 The spacecraft is equipped with an onboard computer, which is installed with onboard software. The onboard software includes a pre-existing mission execution program for executing Mission 1, Mission 2, Mission 1, etc. During the execution of each mission, the pre-existing mission execution program can communicate with the ground control terminal. In the prior art, the ground control terminal monitors and controls the spacecraft's operation process through downlink telemetry data and uplink remote control commands. To achieve autonomous on-orbit operation of the spacecraft, an on-orbit control program for the spacecraft's operation is designed by the ground control terminal and stored in the onboard memory of the onboard computer. By adding an engine to the onboard software, the ground control terminal communicates with the engine, creates a virtual machine in the engine, and then creates a coroutine in the virtual machine to load and execute the on-orbit control program, thereby achieving autonomous on-orbit operation of the spacecraft.

[0032] Based on the above architecture, the following describes Figure 1 How to perform the steps shown.

[0033] First, for step 100, in response to a control command sent by the ground control end, a virtual machine is created in the engine, and a new coroutine is created in the virtual machine. The new coroutine is used to load the on-orbit control program from the on-board memory into the virtual machine and activate the on-orbit control program, and an association relationship is established between the virtual machine identifier, the coroutine identifier, and the on-orbit control program identifier; at least one on-orbit control program is stored in the on-board memory.

[0034] The ground control terminal maintains control authority through control commands throughout the entire on-orbit autonomous operation process. The following describes the control commands that the ground control terminal can initiate and their descriptions.

[0035] First, the control commands of the ground control end for the on-orbit control program are shown in Table 1.

[0036] Table 1:

[0037] Control Commands Command Description Upload and delete Used to maintain on-orbit control program files stored in the onboard computer Loading and unloading On-orbit control program file used to maintain the ready state in the virtual machine Activation and deactivation Used to start and stop the operation of the on-orbit control program in the virtual machine Suspend and Resume Used to suspend and resume the running on-orbit control program in the virtual machine Passing parameters Used to set parameters for the on-orbit control program running in the virtual machine

[0038] When responding to the above control commands, the on-orbit control program is in different operating states, as shown in Table 2.

[0039] Table 2:

[0040] Running status Status Description Storage State Stored in onboard memory as files Ready state Loaded into the virtual machine and ready to run Running state Running, which is an active state Maintaining state The state of being temporarily suspended during operation is a kind of active state

[0041] The control commands and operating states in Table 1 and Table 2 are explained below.

[0042] The program upload control command is used to upload the on-orbit control program file that has been verified on the ground to the on-board computer and store it in the on-board memory. At this time, the on-orbit control program is in the storage state;

[0043] Program deletion control command, used to delete on-orbit control programs that are no longer used on-orbit from the onboard memory;

[0044] The program loading control command is used to load the on-orbit control program in the storage state from the onboard memory into the virtual machine. At this time, the on-orbit control program is in the ready state.

[0045] A program uninstallation control command is used to uninstall an on-orbit control program in a ready state in a virtual machine from the virtual machine;

[0046] A program activation control command is used to activate an on-orbit control program in a ready state in the virtual machine, thereby enabling the on-orbit control program to be run. At this time, the on-orbit control program is in a running state.

[0047] The program stop control command is used to stop the running on-orbit control program in the virtual machine;

[0048] The program suspend control command is used to suspend the running of the on-orbit control program in the virtual machine. At this time, the on-orbit control program is in a hold state.

[0049] Program recovery control command, used to resume the operation of the on-orbit control program in the virtual machine that is in a held state;

[0050] The program transfer parameter control command is used to set parameters for the on-orbit control program in the running state in the virtual machine.

[0051] Second, the control commands of the ground control terminal for the virtual machine are shown in Table 3.

[0052] Table 3:

[0053] Control Commands Command Description create Set the memory base address and size required for the virtual machine to run destroy Delete the coroutine queue, destroy the virtual machine, and release resources Reset Delete the coroutine queue, destroy the virtual machine, release resources, and recreate the virtual machine

[0054] A virtual machine creation control command is used to specify the memory base address and size required for the virtual machine to run, thereby instructing the creation of the virtual machine in the engine;

[0055] The virtual machine destruction control command is used to destroy the specified virtual machine when there is no runnable on-orbit control program in the virtual machine;

[0056] The virtual machine reset control command is used to destroy the specified virtual machine and recreate it to achieve reset when an unrecoverable fault occurs in the virtual machine.

[0057] After completing the description of the control commands above, the preparation process of the on-orbit control program will be explained next.

[0058] The ground control end uses a program upload control command to store at least one on-orbit control program in the onboard memory. When the spacecraft is in flight, the original mission execution program in the onboard software remains in normal operation. When autonomous on-orbit operation is required, the onboard computer responds to a virtual machine creation control command sent by the ground control end, creates a virtual machine in the engine, and returns the virtual machine identifier to the ground control end. In response to a program load control command sent by the ground control end, which carries the on-orbit control program identifier and the virtual machine identifier, a new coroutine is created in the corresponding virtual machine and the corresponding on-orbit control program is loaded from the onboard memory into the virtual machine using the new coroutine. In response to a program activation control command sent by the ground control end, which carries the on-orbit control program identifier, the corresponding on-orbit control program in the virtual machine is activated. By establishing an association between the virtual machine identifier, the coroutine identifier, and the on-orbit control program identifier, subsequent program calls are facilitated.

[0059] In one embodiment of the present invention, when running an on-orbit control program for the first time, to ensure the reliability of on-orbit autonomous operation, before activating the on-orbit control program, the following steps are included: performing a validity check on the component structure of the on-orbit control program. If the validity check passes, the activation of the on-orbit control program is executed; if the validity check fails, an alarm is issued and the execution of the coroutine is terminated. By performing a validity check on the component structure of the on-orbit control program, it is ensured that the component structure of the on-orbit control program meets the program design requirements, thereby ensuring that the on-orbit control program can run correctly.

[0060] Before describing the validity check of the component structure of the on-orbit control program, the program design requirements of the component structure of the on-orbit control program are first explained.

[0061] In the embodiment of the present invention, the program design requires that the structure of the on-track control program include mandatory functions and optional functions; wherein the mandatory functions include:

[0062] BODY_DECL is used to define the unique identifier of the on-orbit control program;

[0063] The main function body (BODY_MAIN) is used to implement the on-orbit control operations of various functions. It consists of a group of functions, each of which represents a step to be completed and is executed serially in the order in which the functions are registered;

[0064] The optional functions include:

[0065] The declaration body (BODY_DECL) is used to define the initialization function (INIT), parameter table (PARAMS_TBL), remote control function (PARAMS_MODIFY), telemetry function (TELEMETRY), cleanup function (CLEANUP), local variables and sub-functions;

[0066] The conditional body (BODY_PRECOND) is used to define the execution condition for triggering the on-orbit control program. The execution condition can be represented by a function, which is used to indicate when the on-orbit control program is executed;

[0067] BODY_CONFIRM is used to define the confirmation function that indicates whether the mission objectives of the on-orbit control program have been completed;

[0068] The exception handling body (BODY_CONTINGENCY) is used to define the exception handling function to handle the exceptions during the execution of the on-track control operation.

[0069] Based on the above program design requirements, when designing the structure of the on-orbit control program, one implementation method can be:

[0070] (1) Define a local variable OBCP with a table data type to store each function body and serve as the return value of the script program;

[0071] (2) Registration identifier, a globally unique identifier used to reference the on-orbit control program, uses the global keyword BODY_ID as the name of a variable whose data type is a table, which is represented by two unsigned integer members;

[0072] (3) Register the declaration body, using the global keyword BODY_DECL as the variable name whose data type is table;

[0073] (4) Register the conditional body and use the global keyword BODY_PRECOND to represent the function name;

[0074] (5) Register the main function body and use the global keyword BODY_MAIN as the variable name of the table data type;

[0075] (6) Register the confirmation body, using the global keyword BODY_CONFIRM to represent the function name;

[0076] (7) Register the exception handling body and use the global keyword BODY_CONTINGENCY to represent the function name.

[0077] Based on the above program design requirements, the validity check of the composition structure of the on-orbit control program is explained below.

[0078] In one embodiment of the present invention, the validity check of the component structure of the on-orbit control program may specifically include:

[0079] Check whether the structure of the on-orbit control program includes all required functions and whether it includes optional functions;

[0080] If all mandatory functions are included, then each mandatory function is checked to see if it is valid; if so, then the validity check is determined to have passed; if not, then the validity check is determined to have failed;

[0081] If all required functions are not included, the validity check is determined to have failed;

[0082] If the optional function body is included, it is determined whether the included optional function body is valid. If it is valid, it is determined that the validity check is passed; if it is invalid, it is determined that the validity check is failed.

[0083] It is understood that when performing the validity check, the keyword can be used to check whether the function body corresponding to the corresponding keyword exists in the on-track control program.

[0084] After the on-orbit control program passes the validity check and is activated, the running state of the on-orbit control program is switched from the ready state to the running state.

[0085] Then, for step 102, the coroutine associated with the on-orbit control program is added to the scheduling queue, and the coroutines in the scheduling queue are scheduled according to a preset scheduling strategy, so as to utilize the coroutine to run the on-orbit control program associated with it.

[0086] When the on-orbit control program is activated, the coroutine is added to the scheduling queue and waits to be scheduled to run.

[0087] It should be noted that the scheduling queue may include one coroutine or multiple coroutines. When multiple coroutines are included, the multiple coroutines may be located in the same virtual machine or in different virtual machines.

[0088] In one implementation, when scheduling the coroutines in the scheduling queue according to the preset scheduling strategy, the coroutine scheduling can be implemented through the "yield-resume" mechanism. The engine periodically calls "resume" on all the coroutines in the scheduling queue in sequence to perform operation scheduling. The on-track control program coroutine ends the current operation of the current coroutine by "yielding".

[0089] In an embodiment of the present invention, after a coroutine is scheduled, the coroutine runs the on-orbit control program associated with it. If the on-orbit control program that passes the validity check includes all optional functions, then using the coroutine to run the on-orbit control program associated with it may specifically include:

[0090] Run the initialization function in the declaration body;

[0091] Run the conditional body after initialization is completed;

[0092] Monitor in real time whether the execution conditions defined by the conditional body are currently met, and when they are met, run the on-orbit control operations of each function in the main function body;

[0093] When all on-orbit control operations in the main function body are completed, the confirmation body is run to confirm whether the mission objectives have been achieved;

[0094] When the task goal is confirmed to be completed, the cleanup function in the declaration body is called to release resources and end the current coroutine;

[0095] When an exception occurs during the execution of the on-track control program, the exception handling function in the exception handling body is executed, and the execution of the current coroutine is terminated after the exception handling is completed.

[0096] Furthermore, during the execution of an on-track control program, the on-track control program identifier can be specified, and the program stop control command, program suspend control command, and program resume control command can be used to change the running state of the active on-track control program. The program stop control command unconditionally halts the execution of an on-track control program in the running state or the hold state, and sets the running state to the ready state. The program suspend control command and program resume control command switch the running state between the running state and the hold state. After the on-track control program completes its execution normally, it automatically switches from the running state to the ready state.

[0097] Please refer to Figure 3 , which is a schematic diagram of the transition of the on-orbit control program running status.

[0098] In this embodiment of the present invention, the on-orbit control program is independent of the original mission execution program in the onboard software. During its execution, the on-orbit control program interacts with the original mission data in the onboard software through the telemetry and telecontrol functions in its declarative body. Thus, the operation of the on-orbit control program can replace the original manual operation on the ground.

[0099] Specifically, the on-orbit control program can obtain telemetry data in real time by subscribing to the telemetry package of the onboard software. According to the telemetry package data format, the original code of the telemetry package is converted into the engineering value data of the corresponding telemetered physical quantity, which is used to monitor the real-time operation status of the spacecraft on-orbit. The telemetry data of the on-board software is the input data of the on-orbit control program. The on-orbit control program exchanges data through the "yield-restore" function pair. The engine passes the incoming data as a parameter to the on-orbit control program coroutine by calling the restore function of the coroutine API. The coroutine passes the outgoing data as a parameter to the engine through the yield function. The incoming data is used as the startup parameter of the on-orbit control program. The outgoing data is the operation instruction generated by the on-orbit control program, sent by the engine to the on-board software for executing the on-orbit operation of the spacecraft, and is the output data of the on-orbit control program.

[0100] Furthermore, during the operation of the on-orbit control program, the on-orbit control program identifier can be specified, and the parameter values ​​of the on-orbit control program in the running state and the holding state can be set by passing parameter control commands to the on-orbit control program, and the data in the parameter table (PARAMS_TBL) defined in the declaration body can be modified by calling the remote control function (TELECOMMAND) defined in the declaration body.

[0101] Furthermore, during the operation of the on-orbit control program, the running status data of the virtual machine and the on-orbit control program can be packaged and sent to the ground control end for monitoring; among them, the monitoring data mainly includes the actual usage of the virtual machine memory, the number of loaded coroutines and the running status of the coroutines, the running progress of the on-orbit control program, the running error code, etc., as well as the result data during the running process, etc.; the data stream is generated according to the designed format, and the engine completes the data stream generation by calling the on-orbit control program telemetry function (TELEMETRY) defined in the declaration body.

[0102] When there is no running on-orbit control program in the virtual machine, the virtual machine can be destroyed by the virtual machine destruction control command to free up resources. In addition, the virtual machine reset control command can also be used to destroy the virtual machine that has an unrecoverable fault during operation and recreate the virtual machine.

[0103] In the embodiment of the present invention, scripting language technology is applied to the field of on-orbit operation and on-orbit operation of spacecraft. The scripting language is used to program the operation process of monitoring based on telemetry data and controlling based on remote control instructions on the ground to form an on-orbit control program. Each on-orbit control program is stored separately on-orbit and can be loaded, run and modified at any time. This solution can monitor the operation status of the spacecraft in real time through autonomous operation on-orbit. There is no time delay in the ground-to-ground loop during on-orbit operation, which can achieve timely response and immediate disposal, and will not miss the best processing opportunity, which can greatly improve the operation efficiency. By designing the composition structure of the on-orbit control program and activating the validity check before operation, on-orbit control is realized. The on-orbit control program is independent of the onboard software and is dynamically interpreted and executed in the virtual machine. Failures will not propagate to and affect the original tasks of the onboard software. It has been verified before being injected on the ground, which makes the operation process more certain. Once the on-orbit control program is started, it will run autonomously in orbit, realizing the autonomy of the on-orbit operation and on-orbit operation of the spacecraft. The on-orbit control program technology involved in the present invention scripts routine operations and on-orbit emergency plans and stores them in the on-board memory. They are continuously increased and improved in orbit and can be called on demand for autonomous execution in orbit, which greatly improves the autonomy of the on-orbit operation and on-orbit operation of the spacecraft and has good versatility and application effect.

[0104] Please refer to Figure 4 An embodiment of the present invention provides a device for implementing on-orbit operation and autonomous on-orbit operation of a spacecraft, which is applied to an onboard computer. The onboard computer is disposed in the spacecraft, and onboard software is installed in the onboard computer. An engine is added to the onboard software. The device includes:

[0105] The command execution unit 400 is configured to, in response to a control command sent by the ground control terminal, create a virtual machine in the engine, create a new coroutine in the virtual machine, use the new coroutine to load an on-orbit control program from the onboard memory into the virtual machine, activate the on-orbit control program, and establish an association between the virtual machine identifier, the coroutine identifier, and the on-orbit control program identifier; the on-board memory stores at least one on-orbit control program;

[0106] The program scheduling unit 402 is used to add the coroutine associated with the on-orbit control program to the scheduling queue, and schedule the coroutine in the scheduling queue according to a preset scheduling strategy to use the coroutine to run the on-orbit control program associated with it.

[0107] In one embodiment of the present invention, the command execution unit is further used to: perform a validity check on the component structure of the on-orbit control program; if the validity check passes, execute the activation of the on-orbit control program; if the validity check fails, issue an alarm and terminate the operation of the coroutine.

[0108] In one embodiment of the present invention, when the command execution unit performs a validity check on the component structure of the on-orbit control program, the steps specifically include:

[0109] Check whether the structure of the on-orbit control program includes all required functions and whether it includes optional functions;

[0110] If all mandatory functions are included, then each mandatory function is checked to see if it is valid; if so, then the validity check is determined to have passed; if not, then the validity check is determined to have failed;

[0111] If all required functions are not included, the validity check is determined to have failed;

[0112] If the optional function body is included, it is determined whether the included optional function body is valid. If it is valid, it is determined that the validity check is passed; if it is invalid, it is determined that the validity check is failed.

[0113] In one embodiment of the present invention, the mandatory functions include:

[0114] Identifier, used to define the unique identifier of the on-orbit control program;

[0115] The main functional body is used to realize the on-orbit control operations of various functions;

[0116] The optional functions include:

[0117] Declaration body, used to define initialization functions, parameter tables, remote control functions, telemetry functions, cleanup functions, local variables, and sub-functions;

[0118] The conditional body is used to define the execution conditions for triggering the on-orbit control program;

[0119] The confirmation body is used to define the confirmation function that represents whether the mission objectives of the on-orbit control program are completed;

[0120] The exception handling body is used to define the exception handling function to handle the exceptions during the execution of the on-track control operation.

[0121] In one embodiment of the present invention, if the on-orbit control program that passes the validity check includes all optional functions, the program scheduling unit, when using the coroutine to run the on-orbit control program associated with it, specifically includes:

[0122] Run the initialization function in the declaration body;

[0123] Run the conditional body after initialization is completed;

[0124] Monitor in real time whether the execution conditions defined by the conditional body are currently met, and when they are met, run the on-orbit control operations of each function in the main function body;

[0125] When all on-orbit control operations in the main function body are completed, the confirmation body is run to confirm whether the mission objectives have been achieved;

[0126] When the task goal is confirmed to be completed, the cleanup function in the declaration body is called to release resources and end the current coroutine;

[0127] When an exception occurs during the execution of the on-track control program, the exception handling function in the exception handling body is executed, and the execution of the current coroutine is terminated after the exception handling is completed.

[0128] In one embodiment of the present invention, the on-orbit control program is independent of the original task execution program of the on-board software. During the operation of the on-orbit control program, data interaction with the original task in the on-board software is achieved through the telemetry function and remote control function in the declaration body.

[0129] It should be noted that the apparatus for implementing on-orbit autonomous operation of a spacecraft provided in the above-mentioned embodiments is merely illustrative of the division of the aforementioned functional modules. In actual applications, the aforementioned functions can be assigned to different functional modules as needed, i.e., the internal structure of the apparatus can be divided into different functional modules to perform all or part of the functions described above. Furthermore, the apparatus for implementing on-orbit operation and autonomous operation of a spacecraft provided in the above-mentioned embodiments and the method for implementing on-orbit operation and autonomous operation of a spacecraft provided in the above-mentioned embodiments are based on the same concept. The specific implementation process is detailed in the method embodiments and will not be further described here.

[0130] The embodiment of the present application also provides a computer device, please refer to Figure 3 The computer device includes a processor and a memory, wherein the memory stores at least one instruction, at least one program, code set or instruction set, and the at least one instruction, at least one program, code set or instruction set is loaded and executed by the processor to implement the methods for implementing the on-orbit operation and on-orbit autonomous operation of a spacecraft provided by the above-mentioned method embodiments.

[0131] An embodiment of the present application also provides a computer-readable storage medium, on which is stored at least one instruction, at least one program, code set or instruction set, and the at least one instruction, at least one program, code set or instruction set is loaded and executed by a processor to implement the methods for on-orbit operation and on-orbit autonomous operation of spacecraft provided in the above-mentioned method embodiments.

[0132] An embodiment of the present application also provides a computer program product, which includes a computer program. The processor of a computer device reads the computer program from a computer-readable storage medium, and the processor executes the computer program, so that the computer device executes the method for implementing on-orbit operation and on-orbit autonomous operation of a spacecraft as described in any of the above embodiments.

[0133] For the convenience of description, the above systems or devices are described as being divided into various modules or units according to their functions. Of course, when implementing this application, the functions of each unit can be implemented in the same or multiple software and / or hardware.

[0134] Through the description of the above embodiments, it can be seen that those skilled in the art can clearly understand that the present application can be implemented by means of software plus a necessary general hardware platform. Based on this understanding, the technical solution of the present application, or the part that contributes to the prior art, can be embodied in the form of a software product, which can be stored in a storage medium such as ROM / RAM, a magnetic disk, an optical disk, etc., and includes a number of instructions for enabling a computer device (which can be a personal computer, a server, or a network device, etc.) to execute the methods described in various embodiments of the present application or certain parts of the embodiments.

[0135] Finally, it should be noted that, in this document, relational terms such as first, second, third, and fourth are used only to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any actual relationship or order between these entities or operations. Moreover, the terms "comprises," "comprising," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus comprising a series of elements includes not only those elements, but also other elements not explicitly listed, or elements inherent to such process, method, article, or apparatus. In the absence of further limitations, an element defined by the phrase "comprising a ..." does not exclude the presence of additional identical elements in the process, method, article, or apparatus comprising the element.

[0136] The above is only a preferred embodiment of the present application. 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 present application. These improvements and modifications should also be regarded as the scope of protection of the present application.

Claims

1. A method for realizing on-orbit operation and on-orbit autonomous operation of a spacecraft, characterized in that: Applied to an onboard computer, the onboard computer is provided in the spacecraft, onboard software is installed in the onboard computer, and an engine is added to the onboard software. The method comprises: In response to a control command sent by a ground control terminal, a virtual machine is created in the engine, a new coroutine is created in the virtual machine, an on-orbit control program is loaded from an onboard memory into the virtual machine using the new coroutine, the on-orbit control program is activated, and an association relationship is established between the virtual machine identifier, the coroutine identifier, and the on-orbit control program identifier; the on-board memory stores at least one on-orbit control program; The coroutine associated with the on-orbit control program is added to the scheduling queue, and the coroutine in the scheduling queue is scheduled according to the preset scheduling strategy, so as to use the coroutine to run the on-orbit control program associated with it.

2. The method according to claim 1, characterized in that After the on-orbit control program is loaded from the onboard memory into the virtual machine using the new coroutine and before the on-orbit control program is activated, the method further includes: A validity check is performed on the component structure of the on-orbit control program. If the validity check passes, the activation of the on-orbit control program is executed; if the validity check fails, an alarm is issued and the operation of the coroutine is terminated.

3. The method according to claim 2, characterized in that The validity check of the structure of the on-orbit control program includes: Check whether the structure of the on-orbit control program includes all required functions and whether it includes optional functions; If all mandatory functions are included, then each mandatory function is checked to see if it is valid; if so, then the validity check is determined to have passed; if not, then the validity check is determined to have failed; If all required functions are not included, the validity check is determined to have failed; If the optional function body is included, it is determined whether the included optional function body is valid. If it is valid, it is determined that the validity check is passed; if it is invalid, it is determined that the validity check is failed.

4. The method according to claim 3, characterized in that The required functions include: Identifier, used to define the unique identifier of the on-orbit control program; The main functional body is used to realize the on-orbit control operations of various functions; The optional functions include: Declaration body, used to define initialization functions, parameter tables, remote control functions, telemetry functions, cleanup functions, local variables, and sub-functions; The conditional body is used to define the execution conditions for triggering the on-orbit control program; The confirmation body is used to define the confirmation function that represents whether the mission objectives of the on-orbit control program are completed; The exception handling body is used to define the exception handling function to handle the exceptions during the execution of the on-track control operation.

5. The method according to claim 4, characterized in that If the on-orbit control program that passes the validity check includes all optional functions, then the on-orbit control program associated with the on-orbit control program is run using a coroutine, including: Run the initialization function in the declaration body; Run the conditional body after initialization is completed; Monitor in real time whether the execution conditions defined by the conditional body are currently met, and when they are met, run the on-orbit control operations of each function in the main function body; When all on-orbit control operations in the main function body are completed, the confirmation body is run to confirm whether the mission objectives have been achieved; When the task goal is confirmed to be completed, the cleanup function in the declaration body is called to release resources and end the current coroutine; When an exception occurs during the execution of the on-track control program, the exception handling function in the exception handling body is executed, and the execution of the current coroutine is terminated after the exception handling is completed.

6. The method according to claim 4, characterized in that The on-orbit control program is independent of the original mission execution program of the onboard software. During the operation of the on-orbit control program, data interaction with the original mission in the on-board software is achieved through the telemetry function and remote control function in the declaration body.

7. A device for realizing on-orbit operation and autonomous on-orbit operation of a spacecraft, characterized in that: Applied to an onboard computer, the onboard computer is provided in the spacecraft, the onboard computer is installed with onboard software, and an engine is added to the onboard software, the device comprises: a command execution unit, configured to respond to a control command sent by a ground control terminal, create a virtual machine in the engine, create a new coroutine in the virtual machine, use the new coroutine to load an on-orbit control program from an onboard memory into the virtual machine, activate the on-orbit control program, and establish an association between a virtual machine identifier, a coroutine identifier, and an on-orbit control program identifier; the on-board memory storing at least one on-orbit control program; The program scheduling unit is used to add the coroutine associated with the on-orbit control program to the scheduling queue, and schedule the coroutine in the scheduling queue according to the preset scheduling strategy, so as to use the coroutine to run the on-orbit control program associated with it.

8. A computer device, characterized in that: The computer device includes a memory and a processor, the memory is used to store a computer program, and the processor is used to execute the computer program stored in the memory to implement the steps of any one of the methods described in claims 1-6.

9. A computer-readable storage medium, characterized in that The storage medium stores a computer program, which, when executed by a processor, implements the steps of the method according to any one of claims 1 to 6.

10. A computer program product, characterized in that The method comprises a computer program, wherein when the computer program is executed by a processor, the steps of the method according to any one of claims 1 to 6 are implemented.

Images