Satellite-borne autonomous program control component with configurable parameters

Abstract

The invention relates to a satellite-borne autonomous program control component with configurable parameters. The satellite-borne autonomous program control component comprises a program control configuration body and a program control operation body, the program control configuration body comprises a plurality of configurable tables, each table corresponds to an autonomous program control, each row in the tables represents an action combination in the autonomous program control, the attributes of the action combination comprise an action index, an autonomous attribute interface, an action instruction and a time interval with a next action, and a user configures the tables so as to complete the automatic program control. The functional design of the corresponding autonomous program control is completed; the program control operation body drives the corresponding autonomous program control operation according to the configuration table of the program control configuration body, and various specific actions set by the program control configuration body for the autonomous program control are accurately and timely completed. The method is efficient, flexible and safe, various complex autonomous program control requirements on the satellite can be met, and the problems that the autonomous program control complexity on the satellite is high, the requirements are diversified, and structural codes are difficult to achieve are fundamentally solved.

Description

Technical Field

[0001] The invention belongs to the field of satellite-borne software design and relates to a satellite-borne autonomous program-controlled component with configurable parameters. Background Art

[0002] As space exploration continues to deepen, the space missions that spacecraft need to perform are becoming increasingly complex. The space environment is complex and changeable. When facing uncertain factors in space missions, spacecraft usually adopt the method of "ground orbit determination -> telemetry transmission -> situation interpretation -> decision-making planning -> instruction injection -> on-orbit execution". This "large satellite-ground loop" control method has many problems such as window and arc segment limitations, long satellite-ground link delay, and many human factors in operation and maintenance command. The spacecraft uses this method to perform space missions in a real-time manner, with many unstable factors, and it is even more difficult to achieve complex program-controlled tasks with strict execution time requirements. In order to break through the arc segment outer orbit control restrictions, reduce the amount of manual tasks on the ground, and ensure that the spacecraft can accurately and timely perform corresponding actions autonomously according to the status on the satellite, it is necessary to improve the perception ability and autonomous decision-making ability of the spacecraft in certain mission scenarios, so that the spacecraft can autonomously trigger certain actions or instructions at the appropriate time according to the status on the satellite under a certain constraint framework, that is, autonomous program control.

[0003] Autonomous program control is completed by a computer. The architecture of the general satellite computer software is as follows: Figure 1 As shown in the figure. The bottom layer in the figure is the hardware layer that supports the digital control computer, including CPU, Memory, bus, IO and other devices; above the hardware layer is the onboard operating system, which is responsible for basic tasks such as memory management and task scheduling. Above the operating system is the dedicated middleware for onboard software. The middleware is a highly abstract general component entity of onboard software. The middleware is task-oriented and provides various services to it; above the middleware are various applications of onboard software, namely tasks. General digital control software includes: downlink telemetry, housekeeping, bus data, remote control data, instruction processing and autonomous program control, among which data is transmitted between tasks through message queues. Tasks call various services of the middleware through interfaces, access the operating system through system calls, and access the underlying hardware resources through drivers. The onboard operating system is a real-time operating system that adopts a time slice round-robin scheduling method, that is, all tasks are run once within a specific time slice.

[0004] Under the above software architecture, traditional satellite-borne data tube software generally uses instruction groups to implement autonomous program control tasks, that is, a group of program control actions is configured as an instruction array composed of several instructions, and the execution interval of each instruction is designed, and then it is solidified in the software. When the software is initialized, the instruction content and time interval in the instruction array are arranged in a cache BUFF. When the program control is executed, the instruction group running program determines the instruction arrival status in each time slice, and issues instructions or waits for operations. The schematic diagram of the instruction group to implement autonomous program control is detailed in Figure 2 .

[0005] The way the instruction group realizes autonomous program control is relatively simple, but its limitations are also obvious, mainly reflected in the following aspects:

[0006] (1) The command group does not have the ability to sense and make decisions autonomously on the satellite, and can only run rigidly according to the fixed command content and time interval. During the autonomous program control process, it is generally necessary to read the current state on the satellite in real time, and autonomously choose which command actions to execute or change the logic such as the command sending interval. However, once the command group is solidified, it cannot be changed in real time on the satellite, and the function of real-time perception and decision-making cannot be realized.

[0007] (2) The instruction group does not have the ability to handle complex program control logic. Some complex program controls require certain operating logic, such as repeating a group of actions several times, skipping several solidified instruction actions, etc. After the instruction group is solidified, it can only run step by step in the set order until all instruction actions are completed. It is impossible to implement complex logic such as instruction backtracking and jumping.

[0008] (3) Once a command group starts, it cannot be independently canceled. A command group is essentially a group of instructions. Once it starts, all instructions are added to the command queue until the end of the operation. It is impossible to independently delete a command group. If an abnormality occurs on the satellite and the running program needs to be stopped immediately, it is impossible to delete the running command group without affecting other command groups. Therefore, it is not competent for exception handling.

[0009] (4) The instruction group cannot reflect the actual running status of the program control. The instruction group is essentially a collection of instructions, which is used to implement autonomous program control. Once the instruction group is started, it has nothing to do with autonomous program control. The software will extract the instructions of the instruction group one by one and run them. There is no status feedback or error handling mechanism during the running process. At the same time, it is difficult for the software to know whether the current program control has ended.

[0010] To sum up, the traditional instruction group model for implementing autonomous program control has single and rigid functions, weak autonomy and exception handling capabilities, and is difficult to meet the current complex program control needs. It is necessary to develop a flexible, autonomous and efficient program control component while inheriting the simplicity of the instruction group to meet the current complex program control needs. Summary of the invention

[0011] The technical problem solved by the present invention is: to overcome the shortcomings of the prior art and propose an efficient, flexible and safe parameter-configurable satellite-borne autonomous programmable control component, which can meet various complex autonomous programmable control requirements on the satellite, and fundamentally solve the problems of high complexity of on-board autonomous programmable control, diverse requirements and difficulty in implementing structured codes.

[0012] The solution of the present invention is:

[0013] A parameter-configurable satellite-borne autonomous program-controlled component, comprising a program-controlled configuration body and a program-controlled operation body;

[0014] The program control configuration body includes a number of configurable tables, each table corresponds to an autonomous program control, each row in the table represents an action combination in the autonomous program control, and the attributes of the action combination include an action index, an autonomous attribute interface, an action instruction, and a time interval with the next action, wherein the autonomous attribute interface includes an entry interface, a running interface, and an exit interface; the user completes the functional design of the corresponding autonomous program control by configuring the table;

[0015] The program-controlled running body drives the corresponding autonomous program-controlled operation according to the configuration table of the program-controlled configuration body, and accurately and timely completes various specific actions set by the program-controlled configuration body for autonomous program control.

[0016] Preferably, the user configures three types of interface functions, namely, entry interface, operation interface, and exit interface, to realize autonomous program-controlled logical processing before, during, and after the execution of each action instruction, and the return value of the interface function drives the next specific operation.

[0017] Preferably, the entry interface function refers to the logic processing that the program-controlled running body needs to perform before executing a certain step of the autonomous program-controlled instruction action;

[0018] The operation interface function refers to the logical processing that the program-controlled operation body needs to perform after executing a certain step of the autonomous program-controlled instruction action;

[0019] The exit interface function refers to the logical processing that the program-controlled running body needs to perform after the current autonomous program-controlled instruction action is completed.

[0020] Preferably, the program-controlled running body includes five processing submodules, namely, an entry processing submodule, an action execution submodule, an operation processing submodule, an exit processing submodule, and a no-action waiting submodule, and its specific functions are as follows:

[0021] Entry processing submodule: calls the entry interface function of the program configuration body for autonomous processing before the execution of action instructions;

[0022] Action execution submodule: sends action instructions or executes corresponding actions according to the loaded instructions;

[0023] Operation processing submodule: calls the operation interface function of the program-controlled configuration body for autonomous processing after the action instruction is executed;

[0024] Exit processing submodule: calls the exit interface function of the program configuration body for exit processing after the action instruction is executed.

[0025] No-action waiting submodule: Wait for the corresponding status according to the waiting cycle set by the program configuration body.

[0026] Preferably, the operation processing submodule is capable of monitoring the execution status of the action instructions.

[0027] Preferably, the exit processing submodule can independently set the current program control state and the next action instruction.

[0028] Preferably, during the operation, all or a group of autonomous program controls are enabled / disabled by operating the enabling attribute of the program control operating body.

[0029] Preferably, the program-controlled running body is provided with a program-controlled state saving interface and a program-controlled state restoring interface, wherein the program-controlled state saving interface is used to store the state attributes of the program-controlled running body, and the program-controlled state restoring interface is used to restore the state attributes of the program-controlled running body;

[0030] During the program control operation, the autonomous program control continuously refreshes and stores the program control operation body data through the program control state saving interface. Once the autonomous program control is abnormally interrupted, after the abnormality is repaired, the program control reads the solidified program control operation body data through the program control state recovery interface and restores it to the program control state attributes. The program control will continue to complete the corresponding instructions from the breakpoint.

[0031] Preferably, the program-controlled operating body is provided with a program-controlled state acquisition interface for acquiring the running progress of the autonomous program-controlled operating body so as to understand which action instruction the current program-controlled operating body is running on.

[0032] The beneficial effects of the present invention compared with the prior art are:

[0033] (1) The present invention solves the defect that the traditional instruction group method of implementing autonomous program control does not have the ability of autonomous perception and decision-making on board, and provides a rich configuration interface. Developers can use these interfaces to independently configure the functions expected by program control, including selecting the instructions or actions to be executed, modifying the instruction interval, etc.

[0034] (2) The present invention solves the defect that the traditional instruction group is not capable of processing complex program control logic. The operation return value of the autonomous attribute configuration interface can be used to specify the next action or instruction to be executed in real time, and can realize complex functions such as cyclic execution, backtracking or jumping of instruction actions;

[0035] (3) The present invention solves the defect that the operation cannot be canceled after the traditional instruction group realizes the autonomous program control mode. A start-up prohibition state is set for each program control, and the start / prohibition of a certain type of program control in the same group can be set in batches in a group manner;

[0036] (4) The present invention solves the defect that the instruction group cannot reflect the running status of the program control. The control granularity of the program control by the autonomous program control component is at the single instruction level. It can monitor every instruction or action executed by the program control throughout the whole process, and provide status feedback for each instruction action, which can effectively represent the current running status of the program control. BRIEF DESCRIPTION OF THE DRAWINGS

[0037] Figure 1 This is a schematic diagram of the software architecture of the satellite-borne data management system;

[0038] Figure 2 Schematic diagram of realizing autonomous program control for traditional instruction groups;

[0039] Figure 3 It is a schematic diagram of autonomous program-controlled components;

[0040] Figure 4 A schematic diagram of a configuration table for a program-controlled configuration body;

[0041] Figure 5 It is a schematic diagram of the structural relationship between the program-controlled running body and the configuration body;

[0042] Figure 6 It is a schematic diagram of the interface relationship of the autonomous program-controlled components;

[0043] Figure 7 It is the flow chart of autonomous program-controlled drive interface;

[0044] Figure 8 It is a schematic diagram of the overall operation process of autonomous program control. DETAILED DESCRIPTION

[0045] The present invention will be further described below in conjunction with the accompanying drawings.

[0046] The present invention discloses an autonomous program control component with configurable satellite parameters, which abstracts autonomous program control into two modules: a program control running body and a program control configuration body. The program control configuration body realizes program control-specific functions and can be configured in a tabular form. The program control running body is a general module, which, as the bottom module of the program control configuration body, provides driving services to each autonomous program control and accurately and timely completes various specific actions set by the program control configuration body. The program control configuration body opens three types of configurable autonomous attribute interfaces: entry interface, operation interface, and exit interface. The complex logic processing before and after the execution of each program control action can be realized by configuring the three types of interface functions. The return value of the interface function drives the specific operation of the next step, and the control granularity of the autonomous program control is a single instruction level. The component has the ability to independently start / disable the running autonomous program control at any time, or start / disable it by group, thereby ensuring the flexibility of program control. The component has the ability to store status. If the program control is interrupted due to software switching / resetting, the running status before the interruption can be restored after the software resumes operation, and the running status before the interruption can be continued, thereby ensuring the stable operation of the program control.

[0047] Mainly include:

[0048] (1) Module design

[0049] It includes two modules: program control configuration body and program control operation body. The program control configuration body is used to realize the autonomous function of program control. The program control operation body drives the program control to run according to the setting requirements of the program control configuration body. The architecture diagram is detailed in Figure 3 .

[0050] The autonomous function is closely related to the actual needs of the program control and the real-time status of the spacecraft. The autonomous function requirements of each program control vary greatly, which are unique attributes of the autonomous program control and need to be set separately. The present invention uses a program control configuration body to configure the autonomous attributes of the autonomous program control. The program control configuration body sets a configuration table for each program control. On each configuration table, an autonomous attribute interface is provided. The user completes the functional design of the autonomous program control by setting the configuration table and the autonomous attribute interface.

[0051] Autonomous program control is driven by the program control running body to complete the configured autonomous properties and functions. The program control running body is designed as a general structure, which does not need to be configured. As a bottom-level module, it provides driving services to the upper-level program control configuration body, that is, it drives the program control to run continuously. The configuration body can configure the program control running body control interface and tell the program control running body how to run, so as to ensure that the actions or instructions generated by the program control autonomous properties can be executed in a timely and accurate manner and complete complex logic.

[0052] Program-controlled configuration body: The program-controlled configuration body is set in the form of a configuration table, such as Figure 4As shown in the figure, a table represents a specific autonomous program control. Each row in the table represents a certain action combination in the program control. Its attributes include action index, autonomous attribute interface, action instruction and time interval with the next action. The autonomous attribute interface uses the action before entering, during operation and after exiting as nodes, and sets entry interface, operation interface and exit interface to realize the autonomous processing logic required before and after the execution of each instruction action of the program control, and realize autonomous decision-making and complex program control functions. Its structure is set as follows Figure 4 shown.

[0053] Program-controlled running body: As the basic module of the bottom layer of autonomous program control, its design is universal and is used to drive program control operation. The program-controlled running body implements the driving process of program-controlled actions under different running states. By reading the return value of the current action autonomous attribute interface, the program-controlled running body selects the next specific operation. Specifically, it includes 5 operation methods for action states: enter processing, action execution, run processing, exit processing, and no action waiting. These 5 processing sub-modules cover the processing of various configurations of the autonomous program control configuration body. For specific operations, please refer to the interface description. The program-controlled running body module records the current running state of the program control. The properties it contains are shown in Table 1:

[0054] Table 1 List of program-controlled running body attributes

[0055] Property Code Attribute meaning wk_id Independent program control ID number, unique wk_gid Autonomous program control group ID wk_endis Program control enable disable status wk_cur_index Program control current running index wk_jump_step Program-controlled next action index wk_sum_num Total number of program-controlled configuration body instruction actions wk_timer_cnt Time slice count wk_last_status Last program control operation status wk_curr_status Current program control operation status wk_sts_flush Running status needs to store flags wk_list Pointer to the autonomous program control configuration structure

[0056] The program-controlled configuration body and the program-controlled operation body are organically combined to realize efficient, flexible and templated independent program-controlled design, as detailed below:

[0057] The program control configuration body is a set of actions that the autonomous program control needs to perform. The program control operation body controls the operation status of the autonomous program control so that each program control runs according to the constraints of the configuration body. Each line of record in the program control operation body reflects the operation status of a specific program control. Each autonomous program control in the operation body is associated with the corresponding program control configuration body through the attribute wk_list. The relationship diagram between the program control operation body and the program control configuration body is shown in the figure below. Figure 5 As shown, developers only need to set up the configuration body to implement autonomous functions, and call the program running body interface to drive the autonomous program control to run in the expected mode, thereby realizing efficient, flexible and templated autonomous program control development for developers.

[0058] (2) Autonomous attribute interface operation design

[0059] For any program-controlled action, the present invention designs three interface functions: entry interface, operation interface, and exit interface. Developers can develop complex functional logic according to specific needs, and then attach the corresponding functions to these three interfaces to achieve logical control before and after the execution of a certain action. For those that do not require logical control, no interface attachment is required. Each instruction action has these three interfaces, so the design method of this method is accurate to the control level of a single action for autonomous program control.

[0060] A. Entry interface: refers to the logical processing that the running body needs to perform before executing a certain step of autonomous program control;

[0061] B. Operation interface: refers to the logical processing that the operation body needs to perform after executing a certain step of autonomous program control;

[0062] C. Exit interface: refers to the logical processing that the running body needs to perform after the current autonomous program control instruction action is completed.

[0063] The actual call of the three interface functions is implemented in the program-controlled running body, which determines the next specific action through the return value of the interface function. The program-controlled running body mainly handles different action states through 5 processing submodules: entry processing submodule, action execution submodule, operation processing submodule, exit processing submodule, and no action waiting submodule. Its specific functions are as follows:

[0064] A. Entry processing submodule: calls the entry interface function of the configuration body for autonomous processing before action, which can be used to complete functions such as adaptive action instruction setting and time interval modification with the next action;

[0065] B. Action execution submodule: sends instructions or executes corresponding actions according to the loaded action instructions;

[0066] C. Operation processing submodule: calls the operation interface function of the configuration body for autonomous processing after the action, can monitor the execution status of the instruction, and perform autonomous program control settings for the execution status;

[0067] D. Exit processing submodule: Call the exit interface function of the configuration body for exit processing after the action is completed. The current program control state and the next action can be set independently.

[0068] E. No-action waiting submodule: Wait for the corresponding state according to the waiting cycle set by the configuration body.

[0069] The operation diagram of the autonomous attribute interface is as follows: Figure 6 shown.

[0070] Autonomous program control completes function configuration through program control configuration body and completes actual operation through program control operation body. The two are organically combined to realize the complex logic of the entire program control, such as realizing the functions of loop execution and jump execution of a group of instruction actions in program control. The detailed process of autonomous program control operation of a certain action is shown in Figure 7 .

[0071] (3) Operation control design

[0072] In order to ensure the flexibility and robustness of program-controlled operation, the present invention designs many methods to realize the control of program-controlled operation, including initialization design, operation status storage and recovery, and operation status acquisition. The overall operation process is detailed in Figure 8 .

[0073] A. Program-controlled initialization design

[0074] The initialization of program control includes the initialization of all program control parameters and the start / disable setting of program control. The method design can initialize parameters or set the start / disable status of all program control, independent program control ID, and program control group ID. The program control initialization and start / disable status setting can be set by setting the program control running body attribute wk_endis. The program control decides whether to enter the current program control according to the attribute wk_endis. The included methods are shown in the following table:

[0075] Interface Name Interface meaning wk_init_all Initialize all autonomous program controls wk_init_as_grp Initialize autonomous program control according to group ID wk_init_as_id Initialize an autonomous program control according to the program control ID wk_endis_all Set the enable / disable status of all autonomous program controls wk_endis_as_id Set the enable / disable status of a certain autonomous program control wk_endis_as_grp Set the enable / disable status of a group of autonomous program control

[0076] B. Design of saving and restoring program-controlled state

[0077] As the program control runs, the running state of the program control is constantly changing, that is, the attribute value of the program control running body is also constantly changing. This method solidifies and stores the attributes of the program control running body (Table 1). Once the program control is abnormally interrupted, after the abnormality is repaired, the program control reads the solidified program control running body data and restores it to the program control running body attributes. The program control will continue to complete the corresponding program control from the breakpoint. This paper sets two function methods for storage and recovery operations, as shown in the following table:

[0078] Interface Name Interface meaning wk_status_save Program control status preservation (store all program control running body properties) wk_status_resove Program control status recovery (restore all program control running body properties)

[0079] C. Program control status acquisition

[0080] In order to grasp the running progress of autonomous program control in real time, the present invention designs the following method, by obtaining the program control running body attribute wk_cur_index, it can be clearly understood which action the current program control is running on.

[0081] Interface Name Interface meaning wk_status_get Program control status acquisition (program control running body attribute wk_cur_index)

[0082] Example:

[0083] This embodiment provides a satellite-borne autonomous program-controlled component.

[0084] 1. Program-controlled configuration body configuration

[0085] First, the program control configuration body needs to be configured according to specific needs. Each autonomous program control corresponds to a configuration table. For example, there are M program controls in total (3 items are listed in the table), and each program control corresponds to a configuration table. Each configuration table specifically determines how the program control should run.

[0086]

[0087]

[0088]

[0089]

[0090] Take the program control 1 configuration table as an example, where the first column in the table corresponds to the program control action index wk_index, which starts from 0 and increases in sequence; the second to fourth columns are the entry interface function pointer, the run interface function pointer and the exit interface function pointer respectively. Developers need to write the corresponding action functions according to the actual situation and reference them in this table. The autonomous program control operation experience will call these interface functions in sequence to implement the corresponding functions. It should be noted that if the corresponding interface is not required for processing here, the corresponding position can be set to NULL; the fifth column represents the interval time between the current action and the next action. The interval time must be greater than 0, and the time accuracy is the rotation time of the operating system scheduling time slice; the sixth column represents the current instruction action pointer, which points to a specific instruction content. If there is no instruction action at present, it can be set to NULL. The interval time wk_time_inter with the next instruction and the instruction content wk_cmd can be modified in real time through the above three interfaces to meet the needs of autonomous decision-making on the satellite.

[0091] 2. Program-controlled running body configuration

[0092] As shown above, assume that a total of M autonomous program controls need to be configured in the software, and the autonomous program control configuration table of each program control has been configured. Then, these M program controls need to be registered to the autonomous program control running body, that is, the running body needs to be configured, as shown in the following table:

[0093]

[0094]

[0095] The first and second columns in the table above correspond to the program control id number wk_id and the group id number wk_gid respectively. The program control id is unique and is used to represent a unique autonomous program control. The third column indicates the enable or disable status of the program control, which is enabled by default. The fourth column indicates the action index of the currently ongoing autonomous program control, which starts from 0 by default and changes gradually as the program control runs. The fifth column indicates the offset number of steps of the next action relative to the current action index. This value can be positive or negative and can be used for functions such as instruction backtracking. The sixth column indicates whether the program control contains The number of specific instruction actions, such as X+1 actions in program control 1 and Z+1 actions in program control M; the 7th column represents the time slice count, the autonomous program control component takes 100ms as a cycle, and the count is +1 every 100ms; the 8th and 9th columns respectively represent the previous state and current state of the program control operation; the 10th column indicates whether the program control state needs to be stored. When the state of the program control changes, the flag is True and the default is 0; the 11th column represents the configuration body corresponding to the current program control, such as the program control 1 configuration body is ck_1.

[0096] 3. Operation configuration method of autonomous program control

[0097] After the autonomous program-controlled configuration body and the autonomous program-controlled running body are configured as described above, the basic configuration of the autonomous program-controlled is completed. The autonomous perception and autonomous decision-making capabilities of the autonomous program-controlled are reflected in the three interfaces of the configuration body, namely the entry, operation and exit interfaces. These three interfaces can access the autonomous program-controlled running body, and through the program-controlled running body, the program-controlled configuration body can be accessed. Therefore, this interface can access all parameters of the autonomous program-controlled configuration body and the running body and make adaptive changes.

[0098] Traditional on-board autonomous program control is usually solidified in the software in the form of instruction groups. Its operating logic is fixed and it cannot autonomously perform corresponding operations according to the state of the spacecraft itself. It is even more powerless for slightly complex logic. It is a rigid and inefficient autonomous program control mode that is difficult to meet the increasingly complex needs of autonomous detection. In order to get rid of this inefficient design mode and efficiently and safely complete various complex needs of autonomous detection, the present invention proposes a general autonomous program control component with configurable parameters based on the actual needs of current spacecraft autonomous execution of tasks on orbit. It is mainly designed in the following three aspects:

[0099] First, the autonomous program control process is abstracted into two modules: the program control configuration body and the program control operation body, which are used to realize the autonomous function and operation function of autonomous program control respectively. The program control configuration body module is designed as a table with configurable parameters. The autonomous attribute configuration of each program control is completed through the configuration table, and the program control operation body is notified in what way to run, so as to realize the autonomous function unique to autonomous program control; the program control operation body is designed as a general bottom-level module, which does not need to be configured. This module drives the program control to run continuously according to the configuration of the program control configuration body, ensuring that the actions or instructions generated by the program control can be completed in a timely and accurate manner. The configuration body and the operation body are organically combined, thus realizing efficient, flexible and templated autonomous program control design.

[0100] Secondly, an autonomous attribute interface is designed for the program-controlled configuration body. The interface uses an action instruction as the granularity, and performs function pointer hooking design for the autonomous operations before, during, and after the execution of the action, in order to complete specific autonomous functions in autonomous program control. The return value after the function executes the autonomous function can be used to notify the program-controlled running body of the next specific action, so that various complex control logics can be flexibly completed, and various functions that the instruction group does not have can be realized, so that it has strong autonomous functions.

[0101] Finally, the flexible control and robust operation of the autonomous program control process are designed. The present invention can start / disable all or a group of program controls at any time during the program control operation, ensuring the flexible control of the program control; at the same time, the method designs the program control state storage and recovery function. If the program control is interrupted due to power off / reset during operation, after the software resumes operation, the autonomous program control can continue to operate in the state before the interruption, thereby ensuring the robust operation of the program control.

[0102] Parts of the present invention that are not described in detail belong to common knowledge among those skilled in the art.

Claims

1. A parameter-configurable satellite-borne autonomous program-controlled component, characterized in that: Including program-controlled configuration body and program-controlled operation body; The program control configuration body includes a number of configurable tables, each table corresponds to an autonomous program control, each row in the table represents an action combination in the autonomous program control, and the attributes of the action combination include an action index, an autonomous attribute interface, an action instruction, and a time interval with the next action, wherein the autonomous attribute interface includes an entry interface, a running interface, and an exit interface; the user completes the functional design of the corresponding autonomous program control by configuring the table; The program-controlled running body drives the corresponding autonomous program-controlled operation according to the configuration table of the program-controlled configuration body, and accurately and timely completes various specific actions set by the program-controlled configuration body for autonomous program control.

2. The parameter-configurable satellite-borne autonomous program-controlled component according to claim 1, characterized in that: By configuring the three types of interface functions, namely entry interface, operation interface and exit interface, users can realize the logical processing before, during and after the execution of each action instruction through autonomous program control. The return value of the interface function drives the next specific operation.

3. The parameter-configurable satellite-borne autonomous program-controlled component according to claim 2, characterized in that: The entry interface function refers to the logical processing that the program-controlled running body needs to perform before executing a certain step of autonomous program-controlled instruction action; The operation interface function refers to the logical processing that the program-controlled operation body needs to perform after executing a certain step of the autonomous program-controlled instruction action; The exit interface function refers to the logical processing that the program-controlled running body needs to perform after the current autonomous program-controlled instruction action is completed.

4. The parameter-configurable satellite-borne autonomous program-controlled component according to claim 1, characterized in that: The program-controlled running body includes five processing submodules, namely, entry processing submodule, action execution submodule, operation processing submodule, exit processing submodule, and no-action waiting submodule. Its specific functions are as follows: Entry processing submodule: calls the entry interface function of the program configuration body for autonomous processing before the execution of action instructions; Action execution submodule: sends action instructions or executes corresponding actions according to the loaded instructions; Operation processing submodule: calls the operation interface function of the program-controlled configuration body for autonomous processing after the action instruction is executed; Exit processing submodule: calls the exit interface function of the program configuration body for exit processing after the action instruction is executed. No-action waiting submodule: Wait for the corresponding status according to the waiting cycle set by the program configuration body.

5. The parameter-configurable satellite-borne autonomous program-controlled component according to claim 4, characterized in that: The operation processing submodule can monitor the execution status of action instructions.

6. The parameter-configurable satellite-borne autonomous program-controlled component according to claim 4, characterized in that: The exit processing submodule can independently set the current program control state and the next action instruction.

7. The parameter-configurable satellite-borne autonomous program-controlled component according to claim 1, characterized in that: During operation, all or a group of autonomous program controls can be started / disabled by operating the enable attribute of the program control running body.

8. The parameter-configurable satellite-borne autonomous program-controlled component according to claim 1, characterized in that: The program-controlled running body is provided with a program-controlled state saving interface and a program-controlled state restoring interface, wherein the program-controlled state saving interface is used to store the state attributes of the program-controlled running body, and the program-controlled state restoring interface is used to restore the state attributes of the program-controlled running body; During the program control operation, the autonomous program control continuously refreshes and stores the program control operation body data through the program control state saving interface. Once the autonomous program control is abnormally interrupted, after the abnormality is repaired, the program control reads the solidified program control operation body data through the program control state recovery interface and restores it to the program control state attributes. The program control will continue to complete the corresponding instructions from the breakpoint.

9. The parameter-configurable satellite-borne autonomous program-controlled component according to claim 1, characterized in that: The program-controlled running body is provided with a program-controlled state acquisition interface for acquiring the running progress of the autonomous program-controlled running body so as to understand which action instruction the current program-controlled running is on.

Images