A decentralized service-oriented framework implementation method and system within an avionics system

By adopting a decentralized architecture in the avionics system and using system operation blueprints and configurations for service management, the problems of single point of failure and resource consumption in the avionics system are solved, achieving high reliability and real-time performance.

CN123067928APending Publication Date: 2026-11-10XIAN AVIATION COMPUTING TECH RES INST OF AVIATION IND CORP OF CHINA
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611338125.4
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-08-31
Publication Date
2026-11-10

AI Technical Summary

Technical Problem

Existing service-oriented frameworks in avionics systems suffer from single-point failure risks, high resource consumption, limited scalability, and difficulty in fault location, making it difficult to meet the high reliability and resource-constrained requirements of avionics systems.

Method used

It adopts a decentralized architecture, and service discovery, creation, invocation and destruction are carried out by service usage nodes depending on the system's runtime blueprint and runtime configuration. This avoids the centralized management of the registry center and realizes distributed autonomous deployment and invocation decision-making.

Benefits of technology

It eliminates the risk of single points of failure, saves system resources, simplifies fault location, and meets the high reliability and real-time requirements of avionics systems.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123067928A_ABST
    Figure CN123067928A_ABST
Patent Text Reader

Abstract

This invention relates to the field of avionics, specifically to a method and system for implementing a decentralized service-oriented framework within an avionics system. The method includes: acquiring a system operation blueprint and system operation configuration; determining the operating environment of a target service based on the blueprint and configuration and sending a service creation command; periodically acquiring the configuration during the startup time; determining whether service creation was successful or failed based on whether the configuration contains the target service's operating information; obtaining the service interface description from the blueprint and performing consistency verification; invoking the target service after successful verification; sending a service destruction command and stopping the invocation; periodically acquiring the configuration within a preset destruction time; and determining whether service destruction was successful or failed based on whether the target service's corresponding operating information has been removed. This invention employs a decentralized architecture, reducing resource consumption and making it suitable for resource-constrained avionics systems.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention relates to the field of avionics, and more specifically to a method and system for implementing a decentralized service framework within an avionics system. Background Technology

[0002] With the development of distributed system technology, service-oriented frameworks have become the mainstream architecture for achieving modular design and distributed deployment by decoupling business functions into independent services.

[0003] However, most existing service-oriented frameworks adopt a centralized architecture based on a registry center, which consumes a lot of resources and has the risk of single point of failure, making it difficult to apply directly to avionics systems with limited resources and stringent reliability requirements.

[0004] Current mainstream service-oriented architectures typically include the following technical components: inter-service communication based on RESTful APIs, gRPC, or message queues; service instance management through a registry center, combined with load balancing and circuit breaking mechanisms to ensure service availability; and independent storage and eventual consistency of service data using database sharding or event sourcing. These solutions address the problems of high code coupling, poor scalability, and difficult maintenance inherent in traditional monolithic architectures, and provide complete service governance capabilities for service registration, discovery, use, and destruction.

[0005] However, the aforementioned service-oriented framework based on the registry center has the following drawbacks: the registry center, as a centralized node, is at risk of single point of failure, and its downtime will paralyze the service discovery of the entire system; all service registration and discovery requests converge on the registry center, which can easily create a performance bottleneck and limit scalability; the registry center requires a large amount of processor, network, and I / O resources, and redundancy or monitoring mechanisms need to be introduced to eliminate single points of failure, further exacerbating the already strained resource consumption in the avionics system; as the number of services increases, the call chain becomes increasingly complex, and the difficulty of fault location and performance optimization increases significantly. Summary of the Invention

[0006] To address the problems mentioned in the prior art, this invention proposes a method and system for implementing a decentralized service-oriented framework within an avionics system, in order to solve the problems in the background art.

[0007] To achieve the above objectives, the present invention adopts the following technical solution: This invention discloses a method for implementing a decentralized service-oriented framework within an avionics system. The method is executed by service-using nodes and includes the following steps: S1. Obtain the system runtime blueprint and system runtime configuration; S2. Determine the operating environment of the target service based on the system operation blueprint and the system operation configuration; send a service creation command to the physical node corresponding to the operating environment; obtain the service startup time corresponding to the target service from the system operation blueprint; periodically obtain the system operation configuration within the service startup time; and determine whether the system operation configuration contains the operating information corresponding to the target service. If running information is detected within the service startup time, the service is determined to have been created successfully; if no running information is detected after the service startup time has elapsed, a service startup failure indication is generated. S3. Obtain the service interface description of the target service from the system operation blueprint, and perform a consistency check between the service interface description used locally and the service interface description of the target service; after the check passes, call the target service. S4. Send a service destruction command to the physical node running the target service and stop calling the target service; The system operation configuration is periodically retrieved within a preset destruction time period. It is then determined whether the operation information corresponding to the target service in the retrieved system operation configuration has been removed. If it is removed, the service destruction is deemed successful. If it is not removed after the preset destruction time period, the service destruction is reported as failed.

[0008] As a further improvement of the present invention, the system operation blueprint includes physical node code, application and service name code, application and service identifier, service start time, message sending identifier, message receiving identifier, maximum number of service requests to respond to, and service interface description.

[0009] As a further improvement of the present invention, the system operation configuration includes physical node encoding, running application and service name encoding, response physical node encoding, and response service application encoding.

[0010] As a further improvement of the present invention, step S2, determining the operating environment of the target service based on the system operating blueprint and the system operating configuration, includes: Based on the system operating configuration, obtain the physical node distribution information of the running service, and based on the system operating blueprint, obtain the expected deployment node information of the target service. Compare the physical node distribution information with the expected deployment node information to determine the physical nodes that have the running capability and meet the deployment conditions as the operating environment of the target service.

[0011] As a further improvement of the present invention, the step S2 of determining whether the system operating configuration contains the operating information corresponding to the target service includes: Determine if the following conditions are met simultaneously in the system's operating configuration: the physical node code is consistent with the node corresponding to the target service's operating environment, the running service name code is consistent with the target service, and the response physical node code is consistent with the node code used by this service.

[0012] As a further improvement of the present invention, the target service to be invoked in S3 includes: Based on the message sending identifier corresponding to the target service in the system operation blueprint, a service call command is sent to the physical node running the target service. Based on the receive message identifier corresponding to the target service in the system operation blueprint, the service call result returned by the physical node is received.

[0013] As a further improvement of the present invention, the preset destruction duration in S4 includes the service destruction time corresponding to the target service obtained from the system operation blueprint.

[0014] As a further improvement of the present invention, the operational information corresponding to the target service includes: The physical node code corresponding to the operating environment, the application and service name code of the target service, and the physical node code and application code of the response service corresponding to the node used by the service.

[0015] As a further improvement of the present invention, the service usage node is the physical node running the application in the avionics system that needs to call the target service.

[0016] This invention proposes a decentralized service-oriented framework implementation system within an avionics system, comprising: The acquisition module is used to acquire the system runtime blueprint and system runtime configuration; The service creation module determines the operating environment of the target service based on the system operation blueprint and the system operation configuration; sends a service creation command to the physical node corresponding to the operating environment; obtains the service startup time corresponding to the target service from the system operation blueprint; periodically obtains the system operation configuration within the service startup time and determines whether the system operation configuration contains the operation information corresponding to the target service; if operation information is detected within the service startup time, the service creation is determined to be successful; if no operation information is detected after the service startup time, a service startup failure indication is generated. The service invocation module is used to obtain the service interface description of the target service from the system runtime blueprint, perform consistency verification between the locally used service interface description and the service interface description of the target service, and invoke the target service after the verification passes. The service destruction module is used to send a service destruction command to the physical node running the target service and stop calling the target service; it periodically obtains the system running configuration within a preset destruction time and determines whether the running information corresponding to the target service in the obtained system running configuration has been removed; if it is removed, the service destruction is determined to be successful; if it is not removed after the preset destruction time, the service destruction is reported as failed.

[0017] Compared with the prior art, the present invention achieves the following technical effects: This invention employs a decentralized architecture. Service-using nodes rely solely on locally acquired system blueprints and configurations to complete service discovery and invocation decisions, without needing to query any registry center. Since there is no centralized service registry node, the creation, invocation, and destruction of services on other nodes remain unaffected when any physical node in the avionics system fails. This fundamentally eliminates the single point of failure risk inherent in centralized solutions, meeting the high reliability requirements of avionics systems. Furthermore, this invention eliminates the need to deploy and maintain a registry center. Each service-using node performs blueprint acquisition, configuration query, and judgment locally, avoiding the large amounts of processor, network bandwidth, and I / O resources continuously consumed by the registry center in traditional solutions. Simultaneously, the absence of a single point of failure eliminates the need for additional registry center monitoring technology, further saving system resources.

[0018] This invention predefines the deployment goals, interfaces, and startup times of services through a system runtime blueprint. It records the actual running status and response relationships of services in real time through the system runtime configuration. Service user nodes can complete the creation and destruction confirmation of services by periodically obtaining the configuration and comparing it with the expected status. If the expected status is not achieved within the time limit, a failure indication is generated. This allows the service's dependencies, call paths, and failure causes to be directly located through the comparison results between the blueprint and the configuration, avoiding the difficulty of troubleshooting caused by the complexity of the call chain in traditional centralized solutions. Attached Figure Description

[0019] Figure 1 This is a schematic diagram of the overall process of the present invention; Figure 2 This is a schematic diagram of the service startup process of the present invention; Figure 3 This is a schematic diagram of the service invocation and response process of the present invention. Detailed Implementation

[0020] The present invention will now be described in further detail with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the invention and not intended to limit it. Furthermore, it should be noted that, for ease of description, the accompanying drawings show only the parts relevant to the present invention, and not all of the structures.

[0021] See Figure 1 This embodiment describes a method for implementing a decentralized service-oriented framework within an avionics system. The method is executed by service-using nodes and includes the following steps: S1. Obtain the system runtime blueprint and system runtime configuration; S2. Determine the operating environment of the target service based on the system operation blueprint and the system operation configuration; send a service creation command to the physical node corresponding to the operating environment; obtain the service startup time corresponding to the target service from the system operation blueprint; periodically obtain the system operation configuration within the service startup time; and determine whether the system operation configuration contains the operating information corresponding to the target service. If running information is detected within the service startup time, the service is determined to have been created successfully; if no running information is detected after the service startup time has elapsed, a service startup failure indication is generated. S3. Obtain the service interface description of the target service from the system operation blueprint, and perform a consistency check between the service interface description used locally and the service interface description of the target service; after the check passes, call the target service. S4. Send a service destruction command to the physical node running the target service and stop calling the target service; The system operation configuration is periodically retrieved within a preset destruction time period. It is then determined whether the operation information corresponding to the target service in the retrieved system operation configuration has been removed. If it is removed, the service destruction is deemed successful. If it is not removed after the preset destruction time period, the service destruction is reported as failed.

[0022] The present invention will be further explained below with reference to the accompanying drawings and specific embodiments: This method is executed through service-using nodes in the avionics system. These service-using nodes are physical nodes running applications that need to call the target service. The first step in its execution is to obtain the system operation blueprint and system operation configuration. The system operation blueprint is a set of static rules pre-configured and stored locally on each physical node. Its purpose is to define the target state and constraint rules for the operation of services throughout the system. It is compiled during the system design phase and loaded into the local storage of each node after power-on, without needing to be distributed in real time through a central node.

[0023] Specifically, the system operation blueprint includes physical node codes, application and service name codes, application and service identifiers, service startup time, sent message identifiers, received message identifiers, maximum number of service requests that can be responded to, and service interface descriptions. The physical node code identifies the specific physical node information running the application or service in the avionics system. It can correspond to the running physical system, subsystem, module, node, and corresponding processor core information, with a maximum bit width of 32 bits, sufficient to cover the multi-level node addressing requirements of the avionics system. The application and service name code is used to uniquely identify the application or service, with a maximum bit width of 32 bits, supporting independent numbering for large-scale services. The application and service identifier distinguishes whether the entry corresponds to a resident application or a dynamically created service, with a maximum bit width of 8 bits, facilitating quick identification of schedulable resource types by nodes. The startup time describes the maximum allowed time from receiving the instruction to completing the startup of the service, in seconds. The maximum width is 8 bits, used as a threshold for subsequent creation result determination; the sending message identifier describes the message channel information for the service user to send messages to the service provider, with a maximum width of 32 bits, corresponding to the fixed communication port on the airborne bus; the receiving message identifier describes the message channel information for the service user to receive messages from the service provider, also with a maximum width of 32 bits, configured in pairs with the sending identifier; the maximum number of service requests to respond to limits the upper limit of concurrent requests that a single service instance can handle simultaneously, realizing overload protection for service instances; the service interface description describes the parameter type, version number, and other information of the service interface, is a string type, has a maximum length of 256 bytes, and is the core basis for call compatibility verification. Table 1 shows a typical system operation blueprint.

[0024] Table 1

[0025] As shown in Table 1, the service numbered 4 can be deployed on two physical nodes, physical node 4 and physical node 5. The startup time of the two instances is 20 seconds, the maximum number of response requests is 1, and the interface definition is completely identical, but they correspond to different message channel identifiers, thus achieving communication isolation between service instances.

[0026] The system operational configuration is a dynamically updated set of states that reflects the actual operational status and service response relationships of all nodes in the system. All physical nodes in the system periodically synchronize status frames via the onboard bus, each maintaining its local configuration data; there is no centrally stored node. The system operational configuration includes physical node codes, running application and service name codes, response physical node codes, and response service application codes. The physical node codes are consistent with the coding system in the blueprint, with a maximum bit width of 32 bits. The running application and service name codes record all application and service instances currently loaded and running on the node, with a maximum bit width of 32 bits. The response physical node codes identify the physical node codes of the callers to which the service instance is responding. The response service application codes identify the application codes of the callers to which the service instance is responding. See Table 2 below.

[0027] Table 2

[0028] As shown in Table 2, 0xffffffff is an invalid identifier, indicating that the corresponding entry is a resident application and there is no responding caller; Service 2 running on physical node 2 responds to application 0 on physical node 0; Service 4 running on physical node 4 is currently responding to application 1 on physical node 1.

[0029] like Figure 2 As shown, after acquiring the data, the service-using nodes execute the service creation process, realizing distributed autonomous deployment and result confirmation of the service without the need for a central scheduling node. First, the service-using nodes determine the runtime environment of the target service based on the system runtime blueprint and system runtime configuration. Specifically, the service-using nodes first retrieve all deployable physical nodes corresponding to the target service from the system runtime blueprint, i.e., the range of nodes allowed for the service to run, as the expected deployment node set; then, combined with the current running status of each node recorded in the system runtime configuration, they filter out physical nodes with idle running capabilities, and finally select nodes that meet the deployment conditions as the runtime environment for the target service.

[0030] For example, if a service user's physical node code is 3, and the running application code is 3, and it currently needs to use service number 4, the service user node is first checked from the system runtime blueprint. Service 4 can be deployed on physical nodes 4 and 5. Then, checking the system runtime configuration shows that service 4 is already running on physical node 4, and this instance responds to physical node 1 with an application code of 1. Combined with the blueprint showing that the maximum number of service requests that service 4 can respond to is 1, it can be concluded that this instance is already occupied and does not have additional running capacity. Physical node 5, however, does not currently run service 4 and has running capacity. Following the rule of selecting the smallest physical node code with running capacity, physical node code 5 is ultimately determined as the runtime environment for service 4.

[0031] After determining the operating environment, the service-using node sends a service creation command to the target physical node corresponding to that operating environment via the onboard bus. The service creation command includes the physical node code initiating service creation, the service name code initiating service creation, the target physical node code, and the target service name code. Upon receiving the command, the target node can then determine which service instance to start for which caller.

[0032] After sending the creation command, the service-using node enters the creation result determination phase. First, it retrieves the service startup time corresponding to the target service from the system runtime blueprint, using it as the time window threshold for determination. For example, in this example, the startup time of service 4 is 20 seconds. Then, within the 20-second startup period, it periodically retrieves the local system runtime configuration and continuously checks whether the system runtime configuration contains the runtime information corresponding to the target service. This runtime information must simultaneously meet three conditions: the physical node code matches the node corresponding to the target service's runtime environment, the running service name code matches the target service, and the response physical node code matches the code of the node used by this service.

[0033] In this example, the system checks if the physical node code is 5, the running application and service name code is 4, the responding physical node code is 3, and the responding service application code is 3. If the matching running information is detected within the 20-second startup time, the service node determines that the service creation was successful. If the corresponding running information is not detected after the 20-second startup time, a service startup failure indication is generated. This failure indication can be reported to the avionics system's system management module so that system maintenance personnel can locate the cause of the fault.

[0034] The advantages of this embodiment are twofold: firstly, the entire process of site selection and creation instruction sending is completed autonomously by the service user node, without the need for a central node to perform resource scheduling and instruction forwarding, thus reducing intermediate steps and bus interaction overhead; secondly, the determination of the creation result is entirely based on the system operating configuration, without the need for the target node to specifically return a creation success response, further reducing the number of bus messages, while the determination logic is executed locally and is not affected by the failure of other nodes.

[0035] like Figure 3As shown, after successful service creation, the service-using node first obtains the service interface description of the target service from the system runtime blueprint and performs a consistency check between the locally stored service interface description and the target service's service interface description. The specific comparison content includes information such as the interface parameter types, number of parameters, and version number. In this example, the interface description for service 4 is "interface=Void server (UINT32); ver = 1.4;". If the interface parameters or version number on the service-using node's local machine do not match, it indicates that the interface expected by the caller does not match the interface actually provided by the service. Forcing a call will trigger a runtime exception. In this case, the service-using node will generate and report a service interface inconsistency error and terminate the call process. If the check passes, the call to the target service is officially executed.

[0036] In the specific implementation of the call, the service-using node, based on the sending message identifier corresponding to the target service in the system runtime blueprint, sends the service call command and call parameters to the physical node running the target service through the corresponding message channel on the onboard bus; simultaneously, based on the receiving message identifier in the blueprint, it waits to receive the return result on the corresponding channel. In this example, the service-using node will send the call command to physical node 5 through the sending channel corresponding to 0x555502, and wait for the return result through the receiving channel corresponding to 0x666602. The execution logic on the service-providing node side is as follows: after receiving the service call command, it first determines whether the service method corresponding to the call command is consistent with the locally implemented method. If a match is confirmed, it executes the corresponding service processing logic. After processing, it returns the call result to the service-using node through the agreed receiving message channel.

[0037] The service call in this embodiment does not require a registry center for routing and call management. The call chain is short and the transmission latency is low, which can well meet the real-time requirements of the avionics system. At the same time, the pre-interface consistency verification can detect version mismatch issues before the call is initiated, avoid system failures caused by invalid calls, and improve the reliability and stability of service calls.

[0038] When a service-using node no longer needs the target service, it executes the service destruction process. The service-using node first sends a service destruction command to the physical node running the target service, notifying the target node to release the corresponding service instance resources; at the same time, it stops calling the target service locally and no longer sends new call requests to it.

[0039] The service-using node periodically retrieves the system runtime configuration within a preset destruction period to determine whether the runtime information corresponding to the target service in the configuration has been removed. The preset destruction period can be obtained from the configuration entry of the target service in the system runtime blueprint, using the same configuration as the service startup time to ensure consistency of parameters across the entire system. The matching rules for the determination are consistent with those used in the creation phase, i.e., verifying whether the service instance entry originally corresponding to this service-using node has disappeared from the configuration. In this example, it verifies whether the entries for physical node 5, service 4, response node 3, and response application 3 have been removed from the configuration table. If the target node has completed service destruction and synchronized its state, the corresponding entry will be removed from the configuration. If runtime information is detected to have been removed within the preset destruction period, the service destruction is considered successful; if it has not been removed after the preset destruction period, service destruction failure is reported.

[0040] The destruction process in this embodiment enables service resources to be dynamically created and released on demand, avoiding the permanent occupation of node resources by services and effectively improving the utilization rate of the limited computing resources of the avionics system.

[0041] In a specific avionics system application scenario, the avionics system of a certain type of aircraft comprises multiple processing modules, each responsible for functions such as navigation calculation, radar data processing, and display control. When the display control module needs to acquire radar data, the physical node where this module resides acts as a service user node, creating and invoking the radar data processing service according to the aforementioned method. If the physical node hosting this service fails, the display control module can recreate the service on another node based on the alternative deployment node information in the system operation blueprint. The entire fault recovery process is completed autonomously by the service user node, without waiting for fault detection and reallocation by the registry center, thus significantly shortening the fault recovery time. Furthermore, since there is no centralized registry center node, the service governance capability of this avionics system will not be completely lost due to any single point of failure, ensuring the overall reliability of the system.

[0042] Based on the same inventive concept, this embodiment of the invention also provides a decentralized service framework implementation system within an avionics system. Since the principle of solving the problem by this decentralized service framework implementation system within an avionics system is similar to the aforementioned decentralized service framework implementation method within an avionics system, the implementation of this decentralized service framework implementation system within an avionics system can refer to the implementation of the decentralized service framework implementation method within an avionics system, and the repeated parts will not be described again.

[0043] In specific implementation, the decentralized service-oriented framework implementation system within the avionics system provided in this embodiment of the invention specifically includes: The acquisition module is used to acquire the system runtime blueprint and system runtime configuration; The service creation module determines the operating environment of the target service based on the system operation blueprint and the system operation configuration; sends a service creation command to the physical node corresponding to the operating environment; obtains the service startup time corresponding to the target service from the system operation blueprint; periodically obtains the system operation configuration within the service startup time and determines whether the system operation configuration contains the operation information corresponding to the target service; if operation information is detected within the service startup time, the service creation is determined to be successful; if no operation information is detected after the service startup time, a service startup failure indication is generated. The service invocation module is used to obtain the service interface description of the target service from the system runtime blueprint, perform consistency verification between the locally used service interface description and the service interface description of the target service, and invoke the target service after the verification passes. The service destruction module is used to send a service destruction command to the physical node running the target service and stop calling the target service; it periodically obtains the system running configuration within a preset destruction time and determines whether the running information corresponding to the target service in the obtained system running configuration has been removed; if it is removed, the service destruction is determined to be successful; if it is not removed after the preset destruction time, the service destruction is reported as failed.

[0044] Accordingly, embodiments of the present invention also provide a device for implementing a decentralized service framework within an avionics system, including a processor and a memory, wherein the processor executes a computer program stored in the memory to implement the method for implementing a decentralized service framework within an avionics system as provided in embodiments of the present invention.

[0045] For more detailed information on the above methods, please refer to the relevant content disclosed in the foregoing embodiments, which will not be repeated here.

[0046] Accordingly, embodiments of the present invention also provide a computer-readable storage medium for storing a computer program, wherein the computer program, when executed by a processor, implements the decentralized service framework implementation method within the avionics system provided in the embodiments of the present invention.

[0047] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on its differences from other embodiments. Similar or identical parts between embodiments can be referred to interchangeably. For the systems, devices, and storage media disclosed in the embodiments, since they correspond to the methods disclosed in the embodiments, the descriptions are relatively simple; relevant parts can be referred to the method section.

[0048] Those skilled in the art will further recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the components and steps of the various examples have been generally described in terms of functionality in the foregoing description. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0049] The steps of the methods or algorithms described in conjunction with the embodiments disclosed herein can be implemented directly by hardware, a software module executed by a processor, or a combination of both. The software module can be located in random access memory (RAM), main memory, read-only memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, hard disk, removable disk, CD-ROM, or any other form of storage medium known in the art.

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

[0051] The above provides a detailed description of the decentralized service framework implementation method, system, equipment, and storage medium within the avionics system provided by this invention. Specific examples have been used to illustrate the principles and implementation methods of this invention. The descriptions of the above embodiments are only for the purpose of helping to understand the method and core ideas of this invention. At the same time, for those skilled in the art, there will be changes in the specific implementation methods and application scope based on the ideas of this invention. Therefore, the content of this specification should not be construed as a limitation of this invention.

Claims

1. A method for implementing a decentralized service-oriented framework within an avionics system, characterized in that, The method is executed by the service-using node and includes the following steps: S1. Obtain the system runtime blueprint and system runtime configuration; S2. Determine the operating environment of the target service based on the system operation blueprint and the system operation configuration; send a service creation command to the physical node corresponding to the operating environment; obtain the service startup time corresponding to the target service from the system operation blueprint; periodically obtain the system operation configuration within the service startup time; and determine whether the system operation configuration contains the operating information corresponding to the target service. If running information is detected within the service startup time, the service is determined to have been created successfully; if no running information is detected after the service startup time has elapsed, a service startup failure indication is generated. S3. Obtain the service interface description of the target service from the system operation blueprint, and perform a consistency check between the service interface description used locally and the service interface description of the target service; after the check passes, call the target service. S4. Send a service destruction command to the physical node running the target service and stop calling the target service; The system operation configuration is periodically retrieved within a preset destruction time period. It is then determined whether the operation information corresponding to the target service in the retrieved system operation configuration has been removed. If it is removed, the service destruction is deemed successful. If it is not removed after the preset destruction time period, the service destruction is reported as failed.

2. The method for implementing a decentralized service-oriented framework within an avionics system according to claim 1, characterized in that, The system operation blueprint includes physical node codes, application and service name codes, application and service identifiers, service start time, message sending identifiers, message receiving identifiers, maximum number of service requests that can be responded to, and service interface descriptions.

3. The method for implementing a decentralized service-oriented framework within an avionics system according to claim 1, characterized in that, The system operation configuration includes physical node encoding, running application and service name encoding, response physical node encoding, and response service application encoding.

4. The method for implementing a decentralized service-oriented framework within an avionics system according to claim 1, characterized in that, The S2 step of determining the operating environment of the target service based on the system operating blueprint and the system operating configuration includes: Based on the system operating configuration, obtain the physical node distribution information of the running service, and based on the system operating blueprint, obtain the expected deployment node information of the target service. Compare the physical node distribution information with the expected deployment node information to determine the physical nodes that have the running capability and meet the deployment conditions as the operating environment of the target service.

5. The method for implementing a decentralized service-oriented framework within an avionics system according to claim 1, characterized in that, The step S2, determining whether the system operating configuration contains the operating information corresponding to the target service, includes: Determine if the following conditions are met simultaneously in the system's operating configuration: the physical node code is consistent with the node corresponding to the target service's operating environment, the running service name code is consistent with the target service, and the response physical node code is consistent with the node code used by this service.

6. The method for implementing a decentralized service-oriented framework within an avionics system according to claim 1, characterized in that, The target service to be invoked in S3 includes: Based on the message sending identifier corresponding to the target service in the system operation blueprint, a service call command is sent to the physical node running the target service. Based on the receive message identifier corresponding to the target service in the system operation blueprint, the service call result returned by the physical node is received.

7. The method for implementing a decentralized service-oriented framework within an avionics system according to claim 1, characterized in that, The preset destruction duration in S4 includes the service destruction time corresponding to the target service obtained from the system operation blueprint.

8. The method for implementing a decentralized service-oriented framework within an avionics system according to claim 1, characterized in that, The operational information corresponding to the target service includes: The physical node code corresponding to the operating environment, the application and service name code of the target service, and the physical node code and application code of the response service corresponding to the node used by the service.

9. The method for implementing a decentralized service-oriented framework within an avionics system according to claim 1, characterized in that, The service usage node is the physical node where the application in the avionics system that needs to call the target service runs.

10. A decentralized service-oriented framework implementation system within an avionics system, characterized in that, include: The acquisition module is used to acquire the system runtime blueprint and system runtime configuration; The service creation module determines the runtime environment of the target service based on the system runtime blueprint and the system runtime configuration. Send a service creation command to the physical node corresponding to the operating environment; obtain the service startup time corresponding to the target service from the system operation blueprint; periodically obtain the system operation configuration within the service startup time and determine whether the system operation configuration contains the operation information corresponding to the target service; if the operation information is detected within the service startup time, the service creation is determined to be successful. If no running information is detected after the service startup time has elapsed, a service startup failure indication will be generated. The service invocation module is used to obtain the service interface description of the target service from the system runtime blueprint, perform consistency verification between the locally used service interface description and the service interface description of the target service, and invoke the target service after the verification passes. The service destruction module is used to send a service destruction command to the physical node running the target service and stop calling the target service; The system operation configuration is periodically retrieved within a preset destruction time period. It is then determined whether the operation information corresponding to the target service in the retrieved system operation configuration has been removed. If it is removed, the service destruction is deemed successful. If it is not removed after the preset destruction time period, the service destruction is reported as failed.