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

Abstract

The invention discloses an implementation method and device for on-orbit operation and on-orbit autonomous operation of a spacecraft, and belongs to the technical field of on-orbit operation of spacecrafts. The method comprises the steps that in response to a control command sent by a ground control end, a virtual machine is created in an engine, a new coroutine is created in the virtual machine, an on-orbit control program is loaded into the virtual machine from a satellite-borne storage through the new coroutine, the on-orbit control program is activated, and the incidence relation of a virtual machine identifier, a coroutine identifier and an on-orbit control program identifier is established; and adding the coroutines having the association relationship with the on-orbit control program into a scheduling queue, and scheduling the coroutines in the scheduling queue according to a preset scheduling strategy so as to operate the on-orbit control program having the association relationship with the coroutines by using the coroutines. In the invention, the ground control terminal only participates in the preparation process of the early-stage on-orbit control program, and the operation process of the on-orbit control program is completely autonomously operated by the spacecraft, so that flexible adaptation of application scenes can be realized.

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 on-orbit autonomous operation of a spacecraft. Background Art

[0002] In order to reduce the reliance of spacecraft on ground manpower for on-orbit operation and manipulation, users are increasingly demanding the autonomous capabilities of spacecraft on-orbit. In mission scenarios that require a high degree of autonomy, such as deep space exploration and where measurement and control cannot be continuously guaranteed, the autonomous capabilities of on-orbit operation and manipulation determine the success or failure of the mission due to the complexity, unpredictability, and fleeting nature of on-orbit missions.

[0003] At present, spacecraft still rely heavily on manual operation on the ground, and mainly rely on time-stamped instructions and program-controlled instructions in the onboard software to achieve autonomous on-orbit operation and on-orbit operation. Time-stamped instructions and program-controlled instructions are generally instruction sequences with time-stamped information pre-bound in the onboard software, and the onboard software automatically executes according to the trigger time 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 device for realizing on-orbit operation and on-orbit autonomous operation of a spacecraft. The technical solution is as follows:

[0006] On the one hand, a method for realizing on-orbit operation and on-orbit autonomous operation of a spacecraft is provided, which is applied to an onboard computer, wherein the onboard computer is arranged in the spacecraft, and onboard software is installed in the onboard computer, and an engine is added to the onboard software, wherein 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 on-board memory into the virtual machine using the new coroutine, and the on-orbit control program is activated, and an association relationship between a virtual machine identifier, a coroutine identifier, and an on-orbit control program identifier is established; at least one on-orbit control program is stored in the on-board memory;

[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 a preset scheduling strategy, so as to use the coroutine to run the on-orbit control program associated with it.

[0009] On the other hand, a device for realizing on-orbit operation and on-orbit autonomous operation of a spacecraft is provided, which is applied to an onboard computer, wherein the onboard computer is arranged in the spacecraft, and onboard software is installed in the onboard computer, and an engine for realizing on-orbit autonomous operation is added to the onboard software, and 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 an engine, create a new coroutine in the virtual machine, load an on-orbit control program from an on-board memory into the virtual machine using the new coroutine, activate the on-orbit control program, and establish an association relationship between a virtual machine identifier, a coroutine identifier, and an on-orbit control program identifier; at least one on-orbit control program is stored in the on-board memory;

[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 a 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, wherein a computer program is stored in the storage medium, and when the computer program is executed by a processor, the steps of the method for implementing the on-orbit operation and on-orbit autonomous operation of the above-mentioned 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, and then uses the new coroutine to load the on-orbit control program from the onboard memory to the virtual machine and activate the on-orbit control program. Then, by establishing an association between the virtual machine identifier, the coroutine identifier and the on-orbit control program identifier, the coroutine is added to the scheduling queue, and finally the coroutines in the scheduling queue are scheduled using a preset scheduling strategy to use the coroutine to run the on-orbit control program associated with it. In this solution, after determining the current application scenario, the ground control terminal can select an on-orbit control program that is adapted to the application scenario, so that the on-board computer runs the on-orbit control program that is adapted to the application scenario on-orbit, thereby realizing autonomous operation on-orbit. It can be seen that in this solution, 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, thereby realizing 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 drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. 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 creative work.

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

[0019] Figure 2 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 It is a schematic diagram of the conversion 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 realizing on-orbit operation and on-orbit autonomous operation of a spacecraft provided by an embodiment of the present invention;

[0022] Figure 5 It is a hardware architecture diagram of a computer device provided by an 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, rather than all the embodiments. Based on the embodiments in 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] In order to realize the on-orbit operation and autonomous operation of spacecraft, it is necessary to program the operation process of monitoring and controlling the spacecraft on the ground control end based on downlink telemetry data and uplink remote control commands to form an on-orbit control procedure (OBCP), which can be executed autonomously on-orbit according to a certain scheduling strategy. Using the on-orbit control procedure to realize the autonomous operation of spacecraft on-orbit is like having a flight control operator on-orbit. Compared with the manual operation, on-orbit time scale instructions and on-orbit program instructions of the ground control end, it has significant advantages, which can greatly reduce or even not rely on the ground to complete the autonomous operation process of spacecraft on-orbit, and greatly improve the autonomous capability of spacecraft on-orbit.

[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 realizing on-orbit operation and on-orbit autonomous operation of a spacecraft, which is applied to an onboard computer. The onboard computer is arranged 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, a new coroutine is created in the virtual machine, an on-orbit control program is loaded from the on-board memory into the virtual machine using the new coroutine, and the on-orbit control program is activated, and an association relationship among a virtual machine identifier, a coroutine identifier, and an on-orbit control program identifier is established; at least one on-orbit control program is stored in the on-board memory;

[0028] Step 102, adding the 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 use the coroutine to run the on-orbit control program associated with it.

[0029] In the embodiment of the present invention, 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, and then uses the new coroutine to load the on-orbit control program from the onboard memory to the virtual machine and activate the on-orbit control program, then establishes an association relationship between the virtual machine identifier, the coroutine identifier and the on-orbit control program identifier, and adds the coroutine to the scheduling queue, and finally uses the preset scheduling strategy to schedule the coroutines in the scheduling queue, so as to use the coroutine to run the on-orbit control program associated with it. In this solution, after determining the current application scenario, the ground control terminal can select an on-orbit control program that is adapted to the application scenario, so that the on-board computer runs the on-orbit control program that is adapted to the application scenario on-orbit, thereby realizing autonomous operation on-orbit. It can be seen that in this solution, 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, thereby realizing flexible adaptation of the application scenario.

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

[0031] Please refer to Figure 2 , a spacecraft is provided with an onboard computer, and onboard software is installed in the onboard computer. The onboard software includes the original task execution program for executing task 1, task 2, task..., and the original task execution program can communicate with the ground control end during the execution of each task. In the prior art, the ground control end monitors and controls the operation process of the spacecraft through downlink telemetry data and uplink remote control instructions. In order to realize the on-orbit autonomous operation of the spacecraft, an on-orbit control program of the ground control end for the operation process of the spacecraft is designed, and the on-orbit control program is stored in the on-board memory of the onboard computer. By adding an engine to the on-board software, the ground control end 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 realizing the on-orbit autonomous operation of the spacecraft.

[0032] Based on the above architecture, the following describes Figure 1 How the various steps are performed.

[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 between the virtual machine identifier, the coroutine identifier and the on-orbit control program identifier is established; at least one on-orbit control program is stored in the on-board memory.

[0034] The ground control terminal controls the control right through control commands during the entire on-orbit autonomous operation process. The following is an explanation of the control commands that the ground control terminal can initiate and their command 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, and its operating states are shown in Table 2.

[0039] Table 2:

[0040] Running status Status description Storage State Stored in onboard memory as files Ready Already loaded into the virtual machine, ready to run at any time Running state Running, which is an active state Keep State The state of being temporarily suspended during operation is a kind of active state

[0041] The control commands and operating states of 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 to 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 the on-orbit control program no longer used in orbit from the on-board 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, so that the on-orbit control program can be run. At this time, the on-orbit control program is in a running state;

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

[0048] The program suspension 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 holding state;

[0049] A program recovery control command is used to recover the on-orbit control program in a held state in the virtual machine;

[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 end 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, so as to instruct the creation of a virtual machine in the engine;

[0055] A virtual machine destruction control command is used to destroy a 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 the virtual machine to achieve reset when an unrecoverable failure 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 the program upload control command to store at least one on-orbit control program in the on-board memory. When the spacecraft is in flight, the original task execution program in the on-board software is still in normal operation. When it is necessary to realize on-orbit autonomous operation, the on-board computer responds to the 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 the program loading control command sent by the ground control end, the program loading control command carries the on-orbit control program identifier and the virtual machine identifier, creates a new coroutine in the corresponding virtual machine, and uses the new coroutine to load the corresponding on-orbit control program from the on-board memory to the virtual machine. In response to the program activation control command sent by the ground control end, the program activation control command carries the on-orbit control program identifier, and activates the corresponding on-orbit control program in the virtual machine. By establishing an association relationship 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 the on-orbit control program is run for the first time, in order to ensure the reliability of the on-orbit autonomous operation, before activating the on-orbit control program, it also includes: performing a validity check on the composition structure of the on-orbit control program, and if the validity check passes, executing the activation of the on-orbit control program; if the validity check fails, an alarm is issued and the operation of the coroutine is terminated. By performing a validity check on the composition structure of the on-orbit control program, it is ensured that the composition structure of the on-orbit control program meets the program design requirements, so that the on-orbit control program can be correctly run.

[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 composition structure of the on-track control program includes a mandatory function body and an optional function body; wherein the mandatory function body includes:

[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] Among them, the optional functions include:

[0065] Declaration body (BODY_DECL), 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 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 composition 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, using the global keyword BODY_ID as the variable name of the data type table, represented by two unsigned integer members in the table;

[0072] (3) Register the declaration body, using the global keyword BODY_DECL as the variable name with the data type being 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, using the global keyword BODY_MAIN as the variable name with the data type being table;

[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 composition structure of the on-orbit control program includes all the required functions and whether it includes the optional functions;

[0080] If all mandatory function bodies are included, then check whether each mandatory function body is valid; if valid, then determine that the validity check has passed; if invalid, then determine that the validity check has failed;

[0081] If all the required function bodies are not included, it is determined that the validity check fails;

[0082] If the optional function body is included, it is determined whether the included optional function body is valid, and if so, it is determined that the validity check passes; if not, it is determined that the validity check fails.

[0083] It is understandable that when performing the validity check, the keyword can be used to check whether there is a function body corresponding to the corresponding keyword in the on-orbit control program.

[0084] The on-track control program passes the validity check and is activated, whereby the running state of the on-track 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 coroutine in the scheduling queue is 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, waiting 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 a preset scheduling strategy, the coroutine scheduling can be implemented through a "yield-recovery" mechanism. The engine periodically calls "recovery" on all the coroutines in the scheduling queue in sequence to perform operation scheduling, and the on-track control program coroutine ends the current operation of the current coroutine by "yielding".

[0089] In the embodiment of the present invention, after the 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 function bodies, 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] After initialization is completed, the conditional body is run;

[0092] Monitor in real time whether the execution conditions defined in the conditional body are met, and when they are met, run the on-orbit control operation 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 completed;

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

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

[0096] Furthermore, during the operation of the on-track control program, the on-track control program identifier can be specified, and the operation state of the on-track control program in the active state can be changed by using the program stop control command, program suspend control command, and program resume control command. The program stop control command will unconditionally stop the execution of the on-track control program in the running state and the holding state, and set the running state to the ready state. The program suspend control command and the program resume control command will switch the running state between the running state and the holding state; after the on-track control program completes the operation normally, the running state is automatically converted to the ready state.

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

[0098] In the 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, the telemetry function and the remote control function in the declaration body are used to realize data interaction with the original task in the on-board software. Therefore, 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, and convert the original code of the telemetry package into the engineering value data of the corresponding telemetry physical quantity according to the telemetry package data format, which is used to monitor the real-time on-orbit operation status of the spacecraft. 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 recovery 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, and the outgoing data is the operation instruction generated by the on-orbit control program, which is sent by the engine to the on-board software to perform 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 on-track control program that can be run in the virtual machine, the virtual machine can be destroyed through the virtual machine destruction control command to release 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 operation process of monitoring based on telemetry data and controlling based on remote control instructions on the ground is programmed using scripting language 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 on-orbit operation. There is no time delay in the ground-to-earth loop during on-orbit operation, so timely response and immediate disposal can be achieved, and the best processing opportunity will not be missed, 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, making 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 storage. It is 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 The embodiment of the present invention provides a device for realizing on-orbit operation and on-orbit autonomous operation of a spacecraft, which is applied to an onboard computer. The onboard computer is arranged 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 used to create a virtual machine in the engine in response to a control command sent by the ground control end, and create a new coroutine in the virtual machine, use the new coroutine to load the on-orbit control program from the on-board memory into the virtual machine and activate the on-orbit control program, and establish an association relationship 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;

[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, and 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 validity check on the component structure of the on-orbit control program, the following steps are specifically performed:

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

[0110] If all mandatory function bodies are included, then check whether each mandatory function body is valid; if valid, then determine that the validity check has passed; if invalid, then determine that the validity check has failed;

[0111] If all the required function bodies are not included, it is determined that the validity check fails;

[0112] If the optional function body is included, it is determined whether the included optional function body is valid, and if so, it is determined that the validity check passes; if not, it is determined that the validity check fails.

[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 function 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 characterizes whether the mission objectives of the on-orbit control program have been 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 functional bodies, 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] After initialization is completed, the conditional body is run;

[0124] Monitor in real time whether the execution conditions defined in the conditional body are met, and when they are met, run the on-orbit control operation 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 completed;

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

[0127] When an exception occurs during the operation of the on-track control program, the exception handling function in the exception handling body is executed, and the operation 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 device for realizing autonomous on-orbit operation of a spacecraft provided in the above embodiment is only illustrated by the division of the above functional modules. In actual applications, the above functions can be assigned to different functional modules as needed, that is, the internal structure of the device is divided into different functional modules to complete all or part of the functions described above. In addition, the device for realizing on-orbit operation and autonomous on-orbit operation of a spacecraft provided in the above embodiment and the method for realizing on-orbit operation and autonomous on-orbit operation of a spacecraft belong to the same concept. The specific implementation process is detailed in the method embodiment and will not be repeated 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, in which at least one instruction, at least one program, a code set or an instruction set is stored, and the at least one instruction, at least one program, a code set or an 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 on-orbit operation and on-orbit autonomous operation of a 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. A 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 system or device is described by dividing it into various modules or units according to its functions. Of course, when implementing the present application, the functions of each unit can be implemented in the same or multiple software and / or hardware.

[0134] It can be known from the description of the above implementation methods 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 such an understanding, the technical solution of the present application can be essentially or partly contributed to the prior art 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 several 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 the various embodiments of the present application or certain parts of the embodiments.

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

[0136] The above is only a preferred implementation 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 a satellite-borne computer, the satellite-borne computer is arranged in the spacecraft, the satellite-borne computer is installed with satellite-borne software, and an engine is added to the satellite-borne 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 on-board memory into the virtual machine using the new coroutine, and the on-orbit control program is activated, and an association relationship between a virtual machine identifier, a coroutine identifier, and an on-orbit control program identifier is established; at least one on-orbit control program is stored in the on-board memory; 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 a 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 on-board memory to the virtual machine by 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 composition structure of the on-orbit control program includes: Check whether the composition structure of the on-orbit control program includes all the required functions and whether it includes the optional functions; If all mandatory function bodies are included, then check whether each mandatory function body is valid; if valid, then determine that the validity check has passed; if invalid, then determine that the validity check has failed; If all the required function bodies are not included, it is determined that the validity check fails; If the optional function body is included, it is determined whether the included optional function body is valid, and if so, it is determined that the validity check passes; if not, it is determined that the validity check fails.

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 function 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 characterizes whether the mission objectives of the on-orbit control program have been 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 functional bodies, then the on-orbit control program associated with the on-orbit control program that uses the coroutine to run includes: Run the initialization function in the declaration body; After initialization is completed, the conditional body is run; Monitor in real time whether the execution conditions defined in the conditional body are met, and when they are met, run the on-orbit control operation 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 completed; When it is confirmed that the task goal is completed, the cleanup function in the declaration body is called to release resources and end the operation of the current coroutine; When an exception occurs during the operation of the on-track control program, the exception handling function in the exception handling body is executed, and the operation 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 task execution program of the on-board software. During the operation of the on-orbit control program, the data interaction with the original task in the on-board software is realized through the telemetry function and remote control function in the declaration body.

7. A device for realizing on-orbit operation and on-orbit autonomous operation of a spacecraft, characterized in that: Applied to a satellite-borne computer, the satellite-borne computer is arranged in the spacecraft, the satellite-borne computer is installed with satellite-borne software, an engine is added to the satellite-borne software, and 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 an engine, create a new coroutine in the virtual machine, load an on-orbit control program from an on-board memory into the virtual machine using the new coroutine, activate the on-orbit control program, and establish an association relationship between a virtual machine identifier, a coroutine identifier, and an on-orbit control program identifier; at least one on-orbit control program is stored in the on-board memory; 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 a 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, and when the computer program is executed by a processor, the steps of the method described in any one of claims 1 to 6 are implemented.

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