Method and apparatus for formalizing control software of an engine

Abstract

The present disclosure provides a formalization processing method and device of control software of an engine, and relates to the technical field of formalization, the method comprising: receiving semi-formalized control requirements of the control software input by a user; forming the semi-formalized control requirements into formalized control requirements according to a defined formalization language; verifying the formalized control requirements according to control safety rules of the engine; and converting the verified formalized control requirements into a modeling script, wherein the modeling script is configured to generate a simulation model of the control software after being executed by modeling software.

Description

TECHNICAL FIELD

[0001] The present disclosure relates to the field of formalization, and in particular to a method and device for formalizing control software of an engine. BACKGROUND

[0002] The safety and reliability of the control system of an aero-engine have very strict requirements, for example, the failure probability requirement is not higher than 10 -9 / flight hours. For example, the control of a civil aero-engine can adopt full authority digital electronic control (FADEC) technology, and the core function thereof is implemented through control software.

[0003] The control software has the characteristics of large scale, high safety and high cost, and the code amount of the control software of an advanced aero-engine is in the order of magnitude of millions of lines. Due to the uncertainty of software testing and the difficulty in accurately quantifying the failure probability of complex logic, there is a lack of effective deterministic methods to measure the safety of software.

[0004] Software requirements are key inputs in the software product development process. In the field of engine control, the requirements of control software are usually documents described in natural language, and the confirmation of requirements often adopts the method of manual checking by industry experts. However, this method can only give qualitative conclusions and is highly subjective. When verifying the control software of a complex engine, it has great limitations.

[0005] With the continuous development of formalization methods, an automatic method is gradually adopted to quantitatively verify the requirements of control software, so as to discover and solve problems in the requirements in the early stages of research and development, and improve the efficiency of software research and development.

[0006] Software formalization method is a software development method based on strict mathematics, and logic, algebra, automata, graph theory, etc. constitute the mathematical basis of formalization method. Formalization method and the corresponding formalization language are often abstruse and difficult to understand, and ordinary engineers are difficult to master this method. Moreover, due to the strict semantic requirements of formalization method, it is difficult to cover all technical requirements in actual engineering or technical fields, and it can usually only be applied in a single and limited range. SUMMARY

[0007] The inventors have noticed that in the related art, the formalization method is often separated from the software development method. The traditional development process of control software is based on the documented requirements of control software. Engineers establish a simulation model of control software on a modeling software by reading the requirements, and generate embedded code through an automatic code generation tool of the modeling software. After a series of test verifications, the entire software development work is completed.

[0008] Formal methods are often based on specific formal languages and tools, and can only achieve single verification work. The formal models established by the formal methods often exist independently and cannot be further utilized, and are not well integrated with software development process systems.

[0009] In view of this, the embodiments of the present disclosure propose the following technical solutions.

[0010] According to an aspect of the embodiments of the present disclosure, a formal processing method of control software of an engine is provided, including: receiving semi-formal control requirements of the control software input by a user; forming the semi-formal control requirements into formal control requirements according to a defined formal language; verifying the formal control requirements according to control safety rules of the engine; and converting the verified formal control requirements into a modeling script, wherein the modeling script is configured to generate a simulation model of the control software after being executed by a modeling software.

[0011] In some embodiments, the receiving of the semi-formal control requirements of the control software input by the user includes: in response to a plurality of variables input by the user, checking the plurality of variables so that names of the plurality of variables are different from each other; in response to a plurality of functional tasks input by the user and a plurality of numbers corresponding to the plurality of functional tasks and different from each other, checking each functional task so that each variable in each functional task belongs to the plurality of variables; in response to calling logics of a plurality of control states input by the user, checking the calling logics of the plurality of control states so that numbers of each functional task called by each control state belong to the plurality of numbers; receiving state transition logics and timing control logics input by the user, the state transition logics including a transition order between different control states required by the control software, and the timing control logics including a duration of each functional task called by each control state required by the control software.

[0012] In some embodiments, the converting of the verified formal control requirements into a modeling script executable by the modeling software includes: converting the plurality of variables into a first script; converting each functional task in the plurality of functional tasks into a second script by using a conversion engine between the formal language and a script language of the modeling software; converting each calling logic in the calling logics of the plurality of control states into a third script; and converting the state transition logics and the timing control logics into a fourth script by using the conversion engine; wherein the modeling script includes the first script, the second script, the third script, and the fourth script.

[0013] In some embodiments, the converting the verified formalized control requirement into the modeling script executable by the modeling software further comprises: converting, according to requirements of the modeling software, a configuration requirement of the control software in the formalized control requirement into a fifth script, the modeling script further comprising the fifth script.

[0014] In some embodiments, the first script generates a data file of the simulation model after being executed by the modeling software; the second script, the third script and the fourth script generate a model file of the simulation model after being executed by the modeling software; and the fifth script generates a configuration file of the simulation model after being executed by the modeling software.

[0015] In some embodiments, the engine is an aero-engine.

[0016] According to another aspect of the embodiments of the present disclosure, there is provided a formalization processing apparatus of control software of an engine, comprising: a receiving module configured to receive semi-formalized control requirements of the control software input by a user; a forming module configured to form the semi-formalized control requirements into formalized control requirements according to a defined formalization language; a verifying module configured to verify the formalized control requirements according to control safety rules of the engine; and a converting module configured to convert the verified formalized control requirements into a modeling script, wherein the modeling script is configured to generate a simulation model of the control software after being executed by modeling software.

[0017] In some embodiments, the receiving module is configured to: in response to a plurality of variables input by a user, check the plurality of variables so that names of the plurality of variables are different from each other; in response to a plurality of functional tasks input by a user and a plurality of numbers corresponding to the plurality of functional tasks and different from each other, check each functional task so that each variable in each functional task belongs to the plurality of variables; in response to calling logics of a plurality of control states input by a user, check the calling logics of each control state so that numbers of each functional task called by each control state belong to the plurality of numbers; and receive state transition logics and timing control logics input by a user, the state transition logics comprising a transition sequence between different control states required by the control software, and the timing control logics comprising a duration of each functional task called by each control state required by the control software.

[0018] In some embodiments, the conversion module is configured to convert the plurality of variables into a first script, convert each of the plurality of functional tasks into a second script using a conversion engine between the formal language and a script language of the modeling software, convert each of the calling logics of the plurality of control states into a third script, convert the state transition logic and the timing control logic into a fourth script using the conversion engine, and wherein the modeling script comprises the first script, the second script, the third script, and the fourth script.

[0019] In some embodiments, the conversion module is further configured to convert configuration requirements of the control software in the formalized control requirements into a fifth script according to requirements of the modeling software, and the modeling script further comprises the fifth script.

[0020] In some embodiments, the first script generates a data file of the simulation model after being executed by the modeling software, the second script, the third script, and the fourth script generate a model file of the simulation model after being executed by the modeling software, and the fifth script generates a configuration file of the simulation model after being executed by the modeling software.

[0021] In some embodiments, the engine is an aero-engine.

[0022] According to still another aspect of the embodiments of the present disclosure, there is provided a formalization processing apparatus of control software of an engine, comprising a memory and a processor coupled to the memory, the processor being configured to execute the method according to any one of the above embodiments based on instructions stored in the memory.

[0023] According to still another aspect of the embodiments of the present disclosure, there is provided a computer readable storage medium having computer program instructions stored thereon, the instructions being executed by a processor to implement the method according to any one of the above embodiments.

[0024] In the embodiments of the present disclosure, the control requirements of the control software after formal verification are converted into a modeling script which can be executed by the modeling software to generate a simulation model of the control software, thereby realizing the formalization verification of the control requirements of the control software and the fusion of the development of the control software by the modeling software, and effectively improving the development efficiency of the control software.

[0025] The technical solutions of the present disclosure will be further described in detail below with reference to the accompanying drawings and embodiments. BRIEF DESCRIPTION OF DRAWINGS

[0026] In order to more clearly illustrate the technical solutions in the embodiments of the present disclosure or the prior art, the following will briefly introduce the drawings needed to be used in the embodiments or prior art description. Obviously, the drawings in the following description are only some embodiments of the present disclosure, and for those ordinarily skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0027] Figure 1 is a flowchart of a formalized processing method of control software of an engine according to some embodiments of the present disclosure;

[0028] Figure 2 is Figure 1 is a flowchart of some implementations of step 102 shown in FIG. 1;

[0029] Figure 3 is Figure 1 is a flowchart of some implementations of step 108 shown in FIG. 1;

[0030] Figure 4 is a structural diagram of a formalized processing device of control software of an engine according to some embodiments of the present disclosure;

[0031] Figure 5 is a structural diagram of a formalized processing device of control software of an engine according to some embodiments of the present disclosure. DETAILED DESCRIPTION

[0032] The technical solutions in the embodiments of the present disclosure will be described clearly and completely below with reference to the drawings in the embodiments of the present disclosure. Obviously, the described embodiments are only some of the embodiments of the present disclosure, but not all the embodiments. Based on the embodiments in the present disclosure, all other embodiments obtained by those ordinarily skilled in the art without creative effort belong to the scope of protection of the present disclosure.

[0033] Unless otherwise specified, the relative arrangement, numerical expressions and values of the components and steps set forth in these embodiments do not limit the scope of the present disclosure.

[0034] Meanwhile, it should be understood that the sizes of the various parts shown in the drawings are not drawn in accordance with the actual proportional relationship for the convenience of description.

[0035] The technologies, methods and devices known to those skilled in the relevant art can not be discussed in detail, but should be considered as part of the authorized description under appropriate circumstances.

[0036] In all of the examples shown and discussed herein, any specific values should be interpreted as merely exemplary and not limiting. Thus, other examples of the example embodiments can have different values.

[0037] It should be noted that like reference numerals and letters refer to like items throughout the attached drawings, and thus once an item is defined in one drawing, it is not necessary that it be further discussed in subsequent drawings.

[0038] Figure 1 is a flowchart of a formalized processing method of control software of an engine according to some embodiments of the present disclosure. In some embodiments, the engine is an aero-engine, such as a civil aero-engine. In some embodiments, the control software is embedded software.

[0039] In step 102, a semi-formalized control requirement of the control software is received by a user input.

[0040] For example, according to the defined semi-formalized language syntax requirements, the user edits the semi-formalized control requirement online through the interface module tool. In addition, the user input control requirement can also be checked online by the built-in syntax checker and consistency checker of the interface module tool, and the checking result is fed back to the user for modification in the case of not meeting the semi-formalized language syntax requirements, so as to complete the import of the semi-formalized control requirement.

[0041] In step 104, the semi-formalized control requirement is formed into a formalized control requirement according to the defined formalized language.

[0042] For example, the semi-formalized control requirement can be analyzed and converted by a modeling tool, and the model construction of the formalized requirement is completed according to the defined formalized language with strict mathematical semantics, i.e. the semi-formalized control requirement is formed into a formalized control requirement. As an example, the keywords in the semi-formalized control requirement can be analyzed and stored by tree and graph data structures to form a data platform, and then the formalized model of the control requirement is constructed according to the defined formalized language.

[0043] In step 106, the formalized control requirement is verified according to the control safety rules of the engine.

[0044] For example, according to the expected use environment of the engine and the working limit of the engine, the catastrophic event required in the airworthiness clause is decomposed by a safety analysis method to determine the safety property requirements of the control system components of the engine. In addition, the safety property requirements of the engine control system operation can be determined in combination with the experience of the engine control experts, so as to establish the control safety rules of the engine.

[0045] As some implementations, the ambiguity of the formalized control requirements can be analyzed, the data flow analysis and the control flow analysis can be carried out, the control function timing conflicts can be checked, and the safety critical properties can be verified according to the established control safety rules of the engine, and the formalized verification result can be output.

[0046] In some embodiments, the verification result can support the iterative revision of the control requirements. That is, if the verification result indicates that the formalized control requirements do not meet the requirements, the user is prompted to re-input the semi-formalized control requirements, and then steps 102-106 are repeatedly executed until the verification result indicates that the formalized control requirements meet the requirements.

[0047] In step 108, the verified formalized control requirements are converted into a modeling script.

[0048] Here, the converted modeling script is configured to generate a simulation model of the control software after being executed by a modeling software. In other words, the modeling script can be executed by the modeling software, and a simulation model of the control software can be generated after the execution. For example, the modeling software can be a commercial modeling software such as MatLab or Simulink.

[0049] In the above embodiments, the control requirements of the control software after formal verification are converted into a modeling script that can be executed by a modeling software and generate a simulation model of the control software, thereby realizing the fusion of the formalized verification of the control requirements of the control software and the development of the control software by the modeling software, and the development efficiency of the control software can be effectively improved.

[0050] Some specific implementations of steps 102 and 108 shown in the above embodiments will be described below. Figure 2 and Figure 3 Some specific implementations of steps 102 and 108 shown in the above embodiments will be described below. Figure 1 Some specific implementations of steps 102 and 108 shown in the above embodiments will be described below.

[0051] Figure 2 is Figure 1 Some specific implementations of steps 102 and 108 shown in the above embodiments will be described below.

[0052] In step 112, in response to the plurality of variables input by the user, the plurality of variables are checked to make the names of the plurality of variables different from each other.

[0053] For example, the plurality of variables input by the user can be imported into a variable data dictionary, and then the variables in the data dictionary are checked to confirm the uniqueness of the name of each variable, that is, to make the names of the plurality of variables different from each other.

[0054] In some embodiments, the attributes of a variable can include the name of the variable, the storage type of the variable, the value type of the variable, the initial value of the variable, the value range of the variable, etc. As some implementations, the storage type can include bus data, signal data, parameter data, etc. As some implementations, the value type can include Boolean number, floating point number, integer, etc.

[0055] It can be understood that if it is found that the name of a variable is not unique, the user can be prompted to re-enter, eventually making the name of each variable unique.

[0056] In step 122, in response to the user inputting a plurality of functional tasks and a plurality of numbers corresponding to the plurality of functional tasks and different from each other, each functional task is checked to make each variable in each functional task belong to the plurality of variables.

[0057] For example, the user inputs each control functional task according to the defined semi-formalized syntax on the input interface provided by the interface module and numbers each functional task. After the user inputs, the variable check is performed on each control functional task inputted to confirm that the variables in each control functional task have been defined in the data dictionary in step 112, i.e., to make each variable in each functional task belong to the plurality of variables inputted by the user in step 112.

[0058] For example, the variables in functional task 1 include variable a, variable b and variable c; the variables in functional task 2 include variable a, variable d and variable e.

[0059] In step 132, in response to the user inputting a plurality of control states and the calling logic of each control state, the calling logic of each control state is checked to make the number of each functional task called by each control state belong to the plurality of numbers.

[0060] Here, the calling logic of each control state corresponds to at least one functional task. By checking the number of the functional task called by each control state, it is confirmed that it has been entered in step 122, i.e., to make the number of each functional task called by each control state belong to the plurality of numbers inputted by the user in step 122.

[0061] For example, the calling logic of control state 1 calls functional task 1, functional task 3 and functional task 5; the calling logic of control state 2 calls functional task 3 and functional task 4.

[0062] In step 142, the state transition logic and the timing control logic inputted by the user are received.

[0063] The state transition logic includes the sequence of transitions between different control states required by the control software. For example, the control software may need to transition in the following order: control state 1, control state 3, control state 2, control state 5.

[0064] The timing control logic includes the duration of each functional task invoked by each control state required by the control software. For example, the functional tasks invoked by control state 1 include functional task 1, functional task 3, and functional task 5, and the timing control logic includes the duration of each of functional task 1, functional task 3, and functional task 5.

[0065] In the above implementation, user input of variables, functional tasks, and control state call logic is received sequentially, and corresponding checks are performed after each input. Then, user input of state transition logic and timing control logic is received. This approach allows for more accurate input of semi-formal control requirements, thereby improving the accuracy of subsequent modeling scripts and the simulation model built up after modeling.

[0066] Figure 3 yes Figure 1 The flowchart shows some implementation methods of step 108.

[0067] like Figure 3 As shown, the modeling script converted in step 108 may include a first script, a second script, a third script, and a fourth script.

[0068] In step 118, multiple variables are converted into the first script.

[0069] In some embodiments, variables can be converted according to their storage type. For example, bus data, signal data, and parameter data correspond to Simulink.Bus, mpt.Signal, and Simulink.Parameter in the MATLAB / Simulink tool, respectively.

[0070] For example, all variables controlling the requirements can be exported to the WorkSpaceData.m script file. That is, multiple variables are converted into the first script.

[0071] In step 128, a conversion engine between formal language and scripting language of modeling software is used to convert each of the multiple functional tasks into a second script.

[0072] For example, the defined formal language can be corresponded with the M language semantics of MATLAB / Simulink in rules to establish a corresponding semantic conversion engine. Then, the conversion engine can be used to convert each functional task established by the formal language into information such as modeling modules, module setting parameters and module connection relationships of MATLAB / Simulink, and then the modeling functions add_block, add_line and set_Param provided by MATLAB / Simulink can be used to complete the construction of the second script.

[0073] It can be understood that each functional task is converted into a second script, and therefore the multiple functional tasks are converted into corresponding multiple second scripts.

[0074] In step 138, each calling logic in the multiple control state calling logics is converted into a third script.

[0075] Here, the third script reflects the connection relationship of the functional tasks converted from the calling logic of the control state established by the formal description language. For example, the connection relationship script, i.e., the third script, can be constructed by the modeling functions of MATLAB / Simulink according to the reference model association relationship of each second script of each control functional task generated in step 128.

[0076] In step 148, the state transition logic and the timing control logic are converted into a fourth script by using the conversion engine.

[0077] For example, the conversion engine can be used to perform semantic conversion on the state transition logic and the timing control logic to obtain the Simulink / Stateflow modeling script, i.e., the fourth script.

[0078] For example, the first script can generate a data file of the simulation model, such as a Mat data file, after being executed by the modeling software. For example, the second script, the third script and the fourth script can generate a model file of the simulation model, such as an mdl model file, after being executed by the modeling software.

[0079] In the above embodiments, the variables, the functional tasks, the calling logic of the control state, the state transition logic and the timing control logic are converted into the corresponding first to fourth scripts. When the first to fourth scripts are executed by the modeling software, the simulation model of the control software can be obtained. In this way, on the one hand, the input of the control requirement is more accurate; on the other hand, the simulation model of the control software can be more accurately formed when the modeling software executes the scripts.

[0080] In some embodiments, referring to Figure 3In some embodiments, step 108 further includes step 158. In this case, the modeling script converted by step 108 can further include a fifth script. In some embodiments, the fifth script, when executed by the modeling software, can generate a configuration file of the simulation model.

[0081] In step 158, the configuration requirement of the control software in the formalized control requirement is converted into the fifth script according to the requirement of the modeling software.

[0082] For example, the configuration requirement can include a control period, a solver configuration, an optimization configuration, etc. As some examples, the solver configuration can be a default configuration; as other examples, the solver configuration can be configured by the user.

[0083] Figure 4 FIG. 1 is a schematic diagram of a formalization processing apparatus of control software of an engine according to some embodiments of the present disclosure.

[0084] As shown in FIG. 1, the formalization processing apparatus includes a receiving module 401, a forming module 402, a verifying module 403, and a converting module 404. Figure 4 The receiving module 401 is configured to receive semi-formalized control requirements of the control software input by a user. The forming module 402 is configured to form the semi-formalized control requirements into formalized control requirements according to a defined formalized language. The verifying module 403 is configured to verify the formalized control requirements according to control safety rules of the engine. The converting module 404 is configured to convert the verified formalized control requirements into a modeling script, wherein the modeling script is configured to generate a simulation model of the control software when executed by a modeling software.

[0085] In some embodiments, the receiving module 401 is configured to: in response to a plurality of variables input by the user, check the plurality of variables so that names of the plurality of variables are different from each other; in response to a plurality of functional tasks input by the user and a plurality of numbers corresponding to the plurality of functional tasks and different from each other, check each functional task so that each variable in each functional task belongs to the plurality of variables; in response to calling logics of a plurality of control states input by the user, check the calling logics of each control state so that numbers of each functional task called by each control state belong to the plurality of numbers; receive state transition logics and timing control logics input by the user, the state transition logics including a transition order between different control states required by the control software, and the timing control logics including a duration of each functional task called by each control state required by the control software.

[0086]

[0087] ​In some embodiments, the conversion module 404 is configured to: convert multiple variables into a first script; convert each of the multiple functional tasks into a second script using a conversion engine between the formal language and the scripting language of the modeling software; convert each of the multiple control state call logics into a third script; and convert the state transition logic and timing control logic into a fourth script using the conversion engine; wherein the modeling script includes the first script, the second script, the third script, and the fourth script. In some embodiments, the first script, after being executed by the modeling software, generates a data file of the simulation model; the second script, the third script, and the fourth script, after being executed by the modeling software, generate model files of the simulation model.

[0088] In some embodiments, the conversion module 404 is further configured to convert the configuration requirements of the control software in the formal control requirements into a fifth script according to the requirements of the modeling software. The modeling script further includes the fifth script. In some embodiments, the fifth script generates a configuration file for the simulation model after being executed by the modeling software.

[0089] Figure 5 This is a schematic diagram of the structure of a formal processing apparatus for engine control software according to other embodiments of the present disclosure.

[0090] like Figure 5 As shown, the formal processing apparatus 500 includes a memory 501 and a processor 502 coupled to the memory 501. The processor 502 is configured to execute the method of any of the foregoing embodiments based on instructions stored in the memory 501.

[0091] The memory 501 may include, for example, system memory, fixed non-volatile storage media, etc. The system memory may store, for example, an operating system, application programs, a boot loader, and other programs.

[0092] The formal processing apparatus 500 may also include an input / output interface 503, a network interface 504, and a storage interface 505. These interfaces 503, 504, and 505, as well as the memory 501 and processor 502, can be connected, for example, via a bus 506. The input / output interface 503 provides a connection interface for input / output devices such as displays, mice, keyboards, and touchscreens. The network interface 504 provides a connection interface for various networked devices. The storage interface 505 provides a connection interface for external storage devices such as SD cards and USB flash drives.

[0093] 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 formal processing apparatus embodiments, since they largely correspond to the formal processing method embodiments, the description is relatively simple; relevant parts can be referred to in the description of the method embodiments.

[0094] This disclosure also provides a computer-readable storage medium having stored thereon computer program instructions that, when executed by a processor, implement the methods of any of the above embodiments.

[0095] The embodiments of this disclosure have now been described in detail. To avoid obscuring the concept of this disclosure, some details known in the art have not been described. Those skilled in the art can fully understand how to implement the technical solutions disclosed herein based on the above description.

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

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

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

[0099] These computer program instructions can also be loaded into a computer or other programmable data processing devices, so that a series of operational steps are performed on the computer or other programmable devices to generate a computer-implemented process, so that the instructions executed on the computer or other programmable devices provide steps for implementing the function specified in the flowchart Figure 1 one flow or multiple flows and / or blocks Figure 1 one block or multiple blocks.

[0100] Although some specific embodiments of the present disclosure have been described in detail by way of example with reference to the drawings, it is to be understood that the above examples are for illustrative purposes only and are not intended to limit the scope of the present disclosure. Those skilled in the art should understand that modifications can be made to the above embodiments or equivalent substitutions can be made to some technical features without departing from the scope and spirit of the present disclosure. The scope of the present disclosure is defined by the appended claims.

Claims

1. A method for formalizing a control software of an engine, comprising: receiving semi-formalized control requirements of the control software input by a user; forming the semi-formalized control requirements into formalized control requirements according to a defined formalized language; verifying the formalized control requirements according to control safety rules of the engine; converting the verified formalized control requirements into a modeling script, wherein the modeling script is configured to generate a simulation model of the control software after being executed by a modeling software; converting the verified formalized control requirements into the modeling script comprises: converting a plurality of variables input by the user into a first script; converting each of a plurality of functional tasks input by the user into a second script by using a conversion engine between the formalized language and a script language of the modeling software; converting each of calling logics of a plurality of control states input by the user into a third script; converting state transition logics and timing control logics input by the user into a fourth script by using the conversion engine, the state transition logics comprising a transition sequence between different control states required by the control software, and the timing control logics comprising a duration of each functional task called by each control state required by the control software; the modeling script comprises the first script, the second script, the third script and the fourth script.

2. The method of claim 1, wherein, the receiving the semi-formalized control requirements of the control software input by the user comprises: in response to the plurality of variables input by the user, checking the plurality of variables so that names of the plurality of variables are different from each other; in response to the plurality of functional tasks input by the user and a plurality of numbers corresponding to the plurality of functional tasks and different from each other, checking each of the plurality of functional tasks so that each variable in each of the plurality of functional tasks belongs to the plurality of variables; in response to the calling logics of the plurality of control states input by the user, checking the calling logics of each of the plurality of control states so that numbers of each of the functional tasks called by each of the plurality of control states belong to the plurality of numbers; receiving the state transition logics and the timing control logics input by the user.

3. The method of claim 1, wherein, the converting the verified formalized control requirements into the modeling script executable by the modeling software further comprises: converting configuration requirements of the control software in the formalized control requirements into a fifth script according to requirements of the modeling software, the modeling script further comprising the fifth script. 4.The method according to claim 3, wherein: the first script is executed by the modeling software to generate a data file of the simulation model; the second script, the third script and the fourth script are executed by the modeling software to generate a model file of the simulation model; the fifth script is executed by the modeling software to generate a configuration file of the simulation model.

5. The method of any one of claims 1-4, wherein, the engine is an aero-engine. 6.An apparatus for formalizing a control software of an engine, comprising: a receiving module configured to receive semi-formalized control requirements of the control software input by a user; a forming module configured to form the semi-formalized control requirement into a formalized control requirement according to a defined formalized language; a verifying module configured to verify the formalized control requirement according to a control safety rule of the engine; a converting module configured to convert the verified formalized control requirement into a modeling script, wherein the modeling script is configured to generate a simulation model of the control software after being executed by a modeling software, wherein the converting module is configured to convert a plurality of variables input by a user into a first script; convert each of a plurality of functional tasks input by the user into a second script by using a conversion engine between the formalized language and a script language of the modeling software; convert each of calling logics of a plurality of control states input by the user into a third script; and convert state transition logics and timing control logics input by the user into a fourth script by using the conversion engine, the state transition logics comprising a transition sequence between different control states required by the control software, and the timing control logics comprising a duration of each functional task called by each control state required by the control software. the modeling script comprises the first script, the second script, the third script and the fourth script.

7. The apparatus of claim 6, wherein, the receiving module is configured to: check the plurality of variables input by the user to make names of the plurality of variables different from each other; check each of the plurality of functional tasks input by the user and corresponding plurality of numbers different from each other to make each variable in each functional task belong to the plurality of variables; check each of the calling logics of the plurality of control states input by the user to make numbers of each functional task called by each control state belong to the plurality of numbers; receive the state transition logics and the timing control logics input by the user.

8. The apparatus of claim 6, wherein, the converting module is further configured to: convert a configuration requirement of the control software in the formalized control requirement into a fifth script according to a requirement of the modeling software, the modeling script further comprising the fifth script.

9. The apparatus of claim 8, wherein: the first script is executed by the modeling software to generate a data file of the simulation model; the second script, the third script and the fourth script are executed by the modeling software to generate a model file of the simulation model; the fifth script is executed by the modeling software to generate a configuration file of the simulation model.

10. The apparatus of any of claims 6-9, wherein, the engine is an aero-engine.

11. An apparatus for formalizing a control software of an engine, comprising: a memory; and a processor coupled to the memory and configured to execute a method recited in any one of claims 1-5 based on instructions stored in the memory.

12. A computer readable storage medium having stored thereon computer program instructions, wherein, The instructions, when executed by the processor, implement the method recited in any one of claims 1-5.

Images