A dynamic compilation method for flight parameter diagnosis rules

Abstract

The present invention belongs to the field of aircraft fault diagnosis and maintenance, and specifically relates to a method for dynamically compiling flight parameter diagnostic rules. The present invention pre-designs the code required for the criterion according to the criterion function, leaving blanks for the criterion formula and associated parameters. After the criterion formula is parsed, the criterion formula and associated parameters are filled in, and a criterion file to be compiled is generated. Finally, the criterion file to be compiled is compiled into an executable program that can be linked to the main program through a compilation tool chain, thereby realizing the dynamic compilation of the criterion into an executable program. This greatly shortens the time it takes to convert the criterion into an executable program, greatly speeds up the guarantee software development process, and significantly improves guarantee efficiency.

Description

Technical Field

[0001] The present invention belongs to the field of aircraft fault diagnosis and maintenance, and in particular relates to a method for dynamically compiling flight parameter diagnosis rules. Background Art

[0002] With the continuous development of the aviation industry, aircraft safety and reliability have attracted increasing attention. An aircraft malfunction can impact performance at best, or even lead to loss of life and crew. The data generated by each flight largely reflects the performance and safety of each aircraft component. Identifying faults in these components from this data is a core task for ground crew and support personnel. Aircraft and engine manufacturers have developed sophisticated methods for troubleshooting using this data. However, aircraft operating environments vary, especially for military aircraft, which operate in extreme environments. The criteria and interpretation software provided by aircraft and engine manufacturers can only interpret pre-defined diagnostic rules, or criteria. Ground crew and support personnel have also developed numerous criteria over the years, independent of aircraft and engine manufacturers. These criteria represent the culmination of generations of support personnel's wisdom. However, due to a lack of support from aircraft and engine manufacturers, these criteria cannot be translated into efficient software. Consequently, when flight data reaches support departments, support personnel must individually troubleshoot each flight using the criteria combined with flight data, significantly reducing support efficiency.

[0003] Currently, there are several methods for interpreting flight parameters:

[0004] 1) Method based on interpretation software provided by the manufacturer.

[0005] This method mainly relies on the interpretation software provided by the aircraft and engine manufacturers. The interpretation software is used to interpret the flight parameter data of each flight and to troubleshoot the faults compiled by the aircraft and engine manufacturers.

[0006] 2) A method based on ground crew members observing flight parameter data with their naked eyes.

[0007] This method relies on custom criteria compiled by previous generations of ground crew members, combined with flight data from each flight, and visually inspecting the data to identify potential faults. This method often relies heavily on flight support personnel's observation and understanding of the criteria, taking a long time and being extremely inefficient.

[0008] The first method only supports criteria already developed by aircraft and engine manufacturers. For empirical criteria developed by ground support personnel based on their experience, the second method is the only option. However, from design to implementation, each criterion requires theoretical calculation, experimental verification, summary and publication, development and testing, and field application. Currently, the development of each criterion requires manual code development based on the specification, resulting in long development cycles, low efficiency, and inevitably reduced scalability.

[0009] Based on the above discussion, the present invention aims to design a dynamic compilation method for flight parameter criteria, striving to greatly improve the efficiency of criterion development while meeting the needs of support personnel to the greatest extent, thereby improving support efficiency. Summary of the Invention

[0010] Aiming at the problems of low efficiency of current flight parameter criterion development technology and poor scalability of development methods, which lead to low interpretation and guarantee efficiency, the present invention designs a method for dynamic compilation of aircraft flight parameter criterion, which automatically compiles the criteria of ground crew into an executable program that can be linked to the main program. At the same time, it supports customized input, ensuring that if subsequent ground crew members have new criteria, they can input them by themselves and automatically compile them into executable programs.

[0011] In order to realize the above functions and related functions, the present invention provides a method for dynamically compiling flight parameter criteria.

[0012] The technical solutions of the present invention are as follows:

[0013] A method for dynamically compiling flight parameter diagnosis rules, comprising the following steps:

[0014] Step 1: Manage flight parameter IDs. This involves binding flight parameter IDs consisting of four ASCII characters. Specifically, the flight parameter data is first categorized by system to create at least 20 system parameter types. These system parameters are then divided into digital (D) and analog (A) parameters. The categorized parameters are then numbered (00-zz) and the systems they belong to are numbered (AZ, az). Finally, the system, data type, and parameter number are combined to create a parameter ID that corresponds to each parameter.

[0015] Step 2: Formula management of flight parameter criteria, i.e., converting the flight parameter criteria into a formula that performs arithmetic and logical operations on at least one parameter ID converted in step 1 (the parameter ID uniquely corresponds to the parameter and can completely refer to the parameter) and adds a duration;

[0016] Step 2-1: Based on the textual description of the criterion, write the conditional expression of all parameters in the criterion. Each condition consists of at least one parameter, and undergoes arithmetic and logical operations, and adds a duration. At least one arithmetic operation and one logical operation are performed, but the duration may not be required. The resulting primary condition n (n = 1, 2, 3...) is obtained. It should be noted that each criterion consists of at least one initial condition, so there may be multiple initial conditions. The n here is only used to distinguish the primary conditions and has no actual meaning.

[0017] Step 2-2: Based on the criterion text, write out the combination condition m (m = I, II, III...) obtained by performing logical operations on the initial conditions in step 2-1 and adding the duration (not necessarily required).

[0018] In step 2-3, based on the textual description of the criterion, the initial conditions in step 2-1 that have not been combined in step 2-2 and the combined conditions generated by step 2-2 (in the conversion process of some criteria, the same initial conditions may be used not only in step 2-3 but also in step 2-2 to form combined conditions, which requires flexible handling in actual use) are subjected to logical operations and the duration is added to obtain the original formula of the criterion.

[0019] In step 2-4, replace the parameters in the original formula with the parameter ID converted in step 1, convert all durations into seconds, add "," before the time to distinguish it from the conditional expression, and add specific separators for each condition or combination of conditions that requires adding duration (such as: "[]", it should be noted that the specific separators here refer to paired separator symbols other than logical operations and arithmetic operations. The example of the present invention uses "[]", if other separator symbols are used, formula 1.1 in step 3-2 needs to be modified synchronously) to obtain the criterion formula.

[0020] It should be noted that the form of the judgment formula is "[conditional expression, duration]", where the duration must be greater than or equal to 0. Equal to 0 means that the moment the conditional expression is established, the fault is determined (in actual use, since the data packet cannot be accurately determined to the moment, it can be accurately determined to a certain frame of data. When the conditional expression is established, a fault is immediately determined).

[0021] Step 3: Parse the criterion formula and convert it into the required code, and generate the file to be compiled;

[0022] Step 3-1: Pre-design the judgment code file according to the functional requirements, and leave the associated parameters and formulas blank. Change the suffix of the designed code file to ".bin" and compile it into the main program;

[0023] Step 3-2 uses the regular expression parsing criterion formula of formula 1.1 to extract the content inside each delimiter. After the extraction is completed, the content inside the delimiter should be in the form of "conditional expression, duration";

[0024] \[(.*)\](1.1)

[0025] Step 3-3 uses the regular expression of formula 1.2 to parse the contents inside the delimiter extracted in step 3-2 in sequence, and obtain the conditional expression (before) and duration (after) before and after ",";

[0026] (.*(?=,)),(\d*\.?\d*) (1.2) Among them: (.*(?=,)) is used to match anything before the comma. The internal ".*" means matching any character (as many as possible, greedy mode); (?=,) means positive lookahead, ensuring that the matched content is followed by a comma, but not including the comma itself. The "," following (.*(?=,)) means matching the comma directly. (\d*\.?\d*) is used to match a number, supporting integers or decimals. The first \d* from left to right inside means matching any number of digits (including 0); \.? means matching a decimal point (optional); the second \d* means matching any number of digits again (including the decimal part).

[0027] Step 3-4 uses the regular expression in formula 1.3 to parse the parameter ID used in the conditional expression;

[0028] \b[a-zA-Z]{2}[0-9A-Za-Z]{2}\b (1.3)

[0029] Among them: \b is used to match word boundaries to ensure that the matched content is a complete word. A word boundary refers to the boundary between a word and a space, punctuation, or other non-word character; [a-zA-Z]{2} is used to match the first two consecutive English letters from left to right (can be uppercase or lowercase); [0-9A-Za-Z]{2} is used to match the last two consecutive letters or numbers (can be uppercase or lowercase English letters or numbers).

[0030] Step 3-5 uses the regular expression of formula 1.4 to parse the numeric parameters used in the logical comparison (>, <, ==, <=, >=, !=, etc.) contained in the conditional expression extracted in step 3-4;

[0031] [<=>](-?\d+\.?\d*) (1.4)

[0032] Among them: [<=>] is used to match one of the characters '<', '=' or '>'; (-?\d+\.?\d*) is used to match a floating point number (with or without a decimal part), -? means matching an optional minus sign, \d+ means matching one or more digits (integer part), \.? means matching an optional decimal point (.), and \d* means matching the decimal part, which can have 0 or more digits (such as '.0', '.12' or no decimal part).

[0033] Step 3-6 extracts the remaining part of the criterion formula, that is, the remaining part of the criterion formula except the parameter ID, the digital parameter used in the logical comparison operation and the duration (generally the symbols of logical operations and arithmetic operations, which can be specifically referred to the nouns and terminology explanations in the specific implementation method). <3> and <4> ).

[0034] Step 3-7 loads the pre-designed judgment code, removes duplicates from the parameter ID extracted in step 3-4 and fills it in the location of the associated parameter. The parsed parameter ID, logical operation, arithmetic operation and duration are combined into a code block, which is filled in the part where the formula is located to generate the file to be compiled.

[0035] Step 4: Compile the file to be compiled into a linkable executable program.

[0036] Step 4-1 compiles the resource files required to implement other functions in the file to be compiled, and generates a linkable target resource file;

[0037] Step 4-2 compiles the criterion file to be compiled and links the target resource file generated in step 4-1 to generate a criterion target file that can be linked to the main program.

[0038] As described above, the present invention is a method for dynamically compiling flight parameter criteria into a linkable executable program, which has the following features:

[0039] Beneficial effects:

[0040] The present invention pre-designs the code required for the criterion based on the criterion function, leaving blank the criterion formula and associated parameters. After the criterion formula is parsed, the criterion formula and associated parameters are filled in, and a criterion file to be compiled is generated. Finally, the compilation tool chain compiles the criterion file into an executable program that can be linked to the main program, thereby dynamically compiling the criterion into an executable program. This greatly shortens the time it takes to convert the criterion into an executable program, greatly speeds up the security software development process, and significantly improves security efficiency. BRIEF DESCRIPTION OF THE DRAWINGS

[0041] Figure 1 It is a schematic diagram of parameter ID design of the present invention;

[0042] Figure 2It is a schematic diagram of the criterion formula expression method of the present invention;

[0043] Figure 3 It is a criterion-formula conversion step diagram of the present invention;

[0044] Figure 4 It is a diagram of the analytical steps of the criterion formula of the present invention;

[0045] Figure 5 It is the dynamic compilation flow chart of the present invention. DETAILED DESCRIPTION

[0046] The following describes the embodiments of the present invention through specific examples. Those skilled in the art can easily understand the advantages and effects of the present invention from the content disclosed in this specification. The present invention can also be implemented and applied through other different specific embodiments. The details in this specification can also be modified or changed based on different viewpoints and applications without departing from the spirit of the present invention. It should be noted that the following embodiments and features in the embodiments can be combined with each other unless they conflict.

[0047] It should be noted that, in the following description, reference is made to the accompanying drawings, which describe several implementation examples and issuance processes of the present invention and should be understood.

[0048] The present invention provides a dynamic compilation method for flight parameter criteria. The method pre-designs the code required for the criteria, leaves blank the criteria formula and associated parameters, fills in the criteria formula and associated parameters after the criteria formula is parsed, and generates a to-be-compiled criteria file. Finally, the to-be-compiled file is compiled into an executable program that can be linked to a main program through a compilation tool chain, thereby dynamically compiling the criteria into an executable program. This method greatly shortens the time it takes to convert the criteria into an executable program, greatly speeds up the security software development process, and significantly improves security efficiency.

[0049] Before further explaining the present invention in detail, the nouns and terms involved in the embodiments of the present invention are explained. The nouns and terms involved in the embodiments of the present invention are subject to the following interpretations:

[0050] <1> Flight parameters: refers to the parameters used to monitor various operating indicators and safety status of the aircraft during flight.

[0051] <2> Criteria: This refers to a digital basis for determining whether an aircraft problem exists, based on a unified assessment of one or more flight parameters, drawing on expert experience and design specifications. It should be noted that the criteria and criterion formulas used in the subsequent descriptions are not intended to be specific; they are merely examples to illustrate the implementation of the present invention.

[0052] <3> Arithmetic operations: C++ supports addition ("+"), subtraction ("-"), multiplication ("*"), division (" / "), root, exponentiation, logarithm and bitwise operations (bitwise AND, bitwise OR, bitwise XOR and bitwise XOR).

[0053] <4> Logical operations: C++ supports AND ("&&"), OR ("||"), and NOT ("!").

[0054] <5> Compilation: The process of converting source code into an executable program.

[0055] The following is a detailed description of the embodiments of the present invention with reference to the accompanying drawings so that those skilled in the art can easily implement the present invention. The present invention can be embodied in many different forms and is not limited to the embodiments described herein.

[0056] Figure 1 This article demonstrates a method for defining a flight parameter ID in accordance with an embodiment of the present invention. The method includes the following steps: a parameter ID consists of four ASCII characters. The first character indicates the system to which the parameter belongs, the second character indicates the parameter type, "A" indicates an analog quantity, "D" indicates a switching quantity, and the last two characters are a serial number (numbered sequentially from 00 to 99 to 0A to ZZ to 0a to zz). For example, parameter AA01 indicates analog quantity No. 01 in system A. During program use, this ID is not directly called. Instead, it is converted into a 32-bit number composed of the four ASCII characters and then concatenated to facilitate storage and comparison.

[0057] Figure 2 This article demonstrates a formulaic expression method for a criterion we designed. The general form of a criterion is "[conditional expression, duration]". A criterion usually involves at least one parameter. After arithmetic and logical operations are performed on these parameters, at least one initial condition is obtained. The logical value obtained by the logical operation of the initial condition satisfies the requirement of being equal to 1 or equal to 0 and lasting for a period of time.

[0058] The conversion method is as follows: Figure 3 As shown, the steps include:

[0059] Step S21: List the various conditions in the criterion separately, where the conditions may involve arithmetic and logical operations of a single parameter and last for a period of time, such as: "PLA-5.3>PLA min " means PLA (throttle stick angle) minus 5.3 is greater than PLA min(the minimum design value of the throttle lever angle) is used as the initial condition 1; "n2>=65&&n2<=85" means that the speed of the n2 high-pressure rotor is between 65 and 85, which is used as the initial condition 2; "D 1-1 = = 1 for 2 seconds" means D 1-1 (Landing gear retraction signal) exists and lasts for 2 seconds, which serves as initial condition 3.

[0060] Step S22: If necessary, perform a logical operation on the initial conditions (some of which may involve a period of time) to obtain a combined condition. If not, go to step S3. For example, if initial conditions 2 and 3 are both met and last for 3 seconds, the combined condition I shown in formula 1.5 can be obtained:

[0061] “n2>=65&&n2<=85” and “D 1-1 = =1 lasts for 2 seconds" lasts for 3 seconds (1.5)

[0062] Step S23: Perform a logical operation on the remaining initial conditions and combined conditions, and accumulate the durations to obtain a criterion formula. For example, if combined condition I and initial condition 1 hold simultaneously for 1 second, the throttle stick angle is judged to be too small during that time period. The resulting formula is shown in Equation 1.6, where redundant durations are removed.

[0063] ““n2>=65&&n2<=85” and “D 1-1 ==1 lasts for 2 seconds, 3 seconds and PLA-5.3>PLA min 1 second (1.6)

[0064] Step S24: Change the parameters used in the obtained formula to ID, remove the quotation marks used for segmentation, replace the "and" used between conditions with "&&", and replace the "or" with "||". For conditions or combined conditions with duration, use "[]" to segment them, and convert the duration into the form of "[conditional expression, duration]" to obtain the final criterion formula. Assume that the parameter ID of the throttle stick angle PLA is MA01, and the throttle stick angle design minimum value PLA is min The parameter ID of the high-pressure rotor speed n2 is MA02, and the landing gear retraction signal D 1-1 The parameter ID is ND01, then the converted formula of formula 1.6 is shown in formula 1.7:

[0065] [[MA02>=65&&MA02<=85&&[ND01==1,2],3]&&MA01-5.3>sA01,1](1.7)By repeating the above process, all criteria can be converted into formulaic expressions. It should be noted that the formula obtained in the above conversion process can repeat steps 23 and 24 multiple times, as long as the outermost layer of the obtained formula meets the "[condition, duration]", where "condition" can also include conditions in the form of "[condition, duration]". For example, [MA02>=65&&MA02<=85&&[ND01==1,2],3] in formula 1.7 includes a condition [ND01==1,2], so the formula finally obtained by the present invention can be very complex.

[0066] After the conversion of the criterion formula expression is completed, we provide a method for parsing the criterion expressed in the formula and generating a file to be compiled. The parsing steps are as follows: Figure 4 As shown, the method includes:

[0067] Step S31: Pre-design the code to be compiled based on the specific functions required to execute the criterion. Leave blank spaces or use special characters (such as "@") to mark the areas where the criterion formula and associated parameters are required. Once designed, modify the file (which may also include other function code files) to a binary .bin file and compile it into the main program.

[0068] Step S32: Using formula 1.1, match the contents enclosed by square brackets “[]” to extract the formula and the conditions or combination conditions in the form of formulas nested within the formulas.

[0069] Step S33: Recycle the content extracted in step S32 and use formula 1.2 to extract the parameters before and after the comma from the character string, that is, the conditional expression and duration, to obtain the duration and conditional expression of the outermost formula.

[0070] Step S34: Use formula 1.3 to parse the formula expression, match a string that starts with two letters and is followed by two letters or numbers (the length is fixed to 4 ASCII characters), and require that the string is complete content within the word boundary, and obtain the parameter ID used in the expression.

[0071] Step S35: Use formula 1.4 to match a segment of numbers before and after a logical comparison operator (such as '<', '=' or '>'), which can be an integer or a floating point number (negative numbers are supported), to resolve the part involving numbers in the comparison operation.

[0072] Step S36: Copy the remaining parts, mainly the logical operators and arithmetic operators, to complete the parsing of the formula.

[0073] Taking Equation 1.7 as an example, after parsing Equation 1.1, we obtain the formula and its internal subformulas: [MA02>=65&&MA02<=85&&[ND01==1,2],3]&&MA01-5.3>sA01,1, MA02>=65&&MA02<=85&&[ND01==1,2],3, and ND01==1,2. Then, applying Equation 1.2 to the three subformulas in turn, we obtain [MA02>=65&&MA02<=85&&[ND01==1,2],3]&&MA01-5.3>sA01 and a duration of 1 second. The second obtains MA02>=65&&MA02<=85&&[ND01==1,2] and 3 seconds. The third obtains ND01==1 and 2 seconds. Then, use Formula 1.3 to parse the conditional expression to obtain the design parameter ID. For Formula 1.7, there are four associated parameters: MA01, MA02, ND01, and sA01. Then, use Formula 1.4 to parse the numbers involved in the comparison operator to complete the formula parsing.

[0074] Step S37: Load the criterion file pre-designed in step S31, combine the parameter ID parsed in step S33 and the extracted arithmetic and logical operators into a code block, fill the code block into the formula position, remove the duplicate parameter ID and fill it into the associated parameter position, and write the completed file to the specified path on the disk to complete the generation of the criterion to be compiled.

[0075] After the generation of the files to be compiled is completed, the pre-configured compilation tool chain needs to be called for compilation. The overall flow chart is as follows: Figure 5 As shown. ① If you are in a Windows environment, you need to call MINGW / LLVM / CLANG to compile the file. Since the functions of each judgment criteria are different, it is necessary to compile other required resources in advance. After compiling them into linkable resource files, call the G++ compiler to compile the ".cpp" source file, and link the linkable resource file to the generated ".dll" dynamic link library. The calling process can be done through a Windows batch program or by using the Windows operating system API function CreateProcess inside a C++ application to start a command line process for compilation. ② If you are in a Linux (Unix) environment, directly call the G++ compiler or use the prepared Makefile to compile the file to be compiled to generate a ".so" shared library. It should be noted that the specific compilation command is related to the running operating system, the compilation tool chain used, and the required functions.

[0076] In summary, the present invention provides a method for dynamically compiling flight parameter criteria. By pre-designing the code required for the criteria, leaving blank criteria formulas and associated parameters, the criteria formulas and associated parameters are filled in after the criteria formulas are parsed, and a criterion file to be compiled is generated. Finally, the file to be compiled is compiled into an executable program that can be linked to the main program through a compilation tool chain, thereby dynamically compiling the criteria into an executable program. Compared with the original system and development process, the time for converting criteria into an executable program is greatly shortened, the software development process is greatly accelerated, and the efficiency of the guarantee is greatly improved. In addition, the present invention also supports ground support personnel to customize the input and summary of criteria, which greatly improves the utilization rate of the ground support personnel's experience criteria. Due to the full utilization of the experience criteria, the guarantee time can be greatly reduced and the launch efficiency can be improved.

Claims

1. A method for dynamically compiling flight parameter diagnosis rules, characterized in that: Here are the steps: Step 1: Manage flight parameter IDs by binding the flight parameter to a flight parameter ID consisting of four ASCII characters. The specific operation is as follows: First, the flight parameter data is classified according to the system to which it belongs to obtain no less than 20 types of system parameters, and then the system parameters are divided into switch quantities and analog quantities; then, the classified parameters are numbered in sequence, and the systems to which they belong are numbered in sequence; finally, the system to which it belongs, the data type and the parameter number are combined to obtain the parameter ID corresponding to each parameter; Step 2: Formula management of flight parameter criteria, i.e., converting the flight parameter criteria into a formula that performs arithmetic and logical operations on at least one parameter ID converted in step 1 and adds a duration; wherein the parameter ID uniquely corresponds to the parameter and can refer to the parameter; The specific operations are as follows: Step 2-1: Based on the criterion text description, write the conditional expression of all parameters in the criterion. Each condition is composed of at least one parameter, and then undergoes arithmetic and logical operations, and adds a duration. At least one arithmetic operation and a logical operation must be performed, but the duration may not be required. The resulting elementary condition n is n = 1, 2, 3, etc. Step 2-2: Based on the criterion text description, write the combination condition m obtained by performing logical operations on the initial conditions in step 2-1 and adding the duration, where m = I, II, III, etc.; Step 2-3: Based on the textual description of the criterion, the initial conditions in step 2-1 that have not been combined in step 2-2 and the combined conditions generated in step 2-2 are subjected to logical operations and the duration is added to obtain the original formula of the criterion; Steps 2-4 replace the parameters in the original formula with the parameter ID converted in step 1, convert all durations to seconds, add "," before the time to distinguish it from the conditional expression, and add specific segmentation for each condition or combination of conditions that requires adding duration to obtain the judgment formula; Step 3: Parse the criterion formula and convert it into the required code, and generate the file to be compiled; Step 4: Compile the file to be compiled into a linkable executable program.

2. A method for dynamically compiling flight parameter diagnosis rules according to claim 1, characterized in that: The specific operations of step 3 are as follows: Step 3-1: Pre-design the criterion code file according to the functional requirements, and leave the associated parameters and formulas blank; change the suffix of the designed code file to ".bin" and compile it into the main program; Step 3-2 uses the regular expression parsing criterion formula of formula 1.1 to extract the content inside each delimiter. After the extraction is completed, the content inside the delimiter should be in the form of "conditional expression, duration"; \[(.*)\] (1.1) Step 3-3 uses the regular expression of formula 1.2 to parse the contents inside the delimiter extracted in step 3-2 in sequence, and obtains the conditional expression before "," and the duration after ","; (.*(?=,)),(\d*\.?\d*) (1.2) Among them: (.*(?=,)) is used to match any content before the comma; the internal ".*" means matching any character; (?=,) means positive lookahead, ensuring that the matched content is followed by a comma, but not including the comma itself; the "," following (.*(?=,)) means matching the comma directly; (\d*\.?\d*) is used to match a number, supporting integers or decimals; the first \d* from left to right means matching any number of digits; \.? means matching a decimal point; the second \d* means matching any number of digits again; Step 3-4 uses the regular expression in formula 1.3 to parse the parameter ID used in the conditional expression; \b[a-zA-Z]{2}[0-9A-Za-Z]{2}\b (1.3) Among them: \b is used to match word boundaries to ensure that the matched content is a complete word. A word boundary refers to the boundary between a word and a space, punctuation, or other non-word character; [a-zA-Z]{2} is used to match the first two consecutive English letters from left to right; [0-9A-Za-Z]{2} is used to match the last two consecutive letters or numbers; Step 3-5 uses the regular expression of formula 1.4 to parse the numeric parameters used in the logical comparison contained in the conditional expression extracted in step 3-4; [<=>](-?\d+\.?\d*) (1.4) Among them: [<=>] is used to match one of the characters '<', '=' or '>'; (-?\d+\.?\d*) is used to match a floating point number, -? means matching an optional minus sign, \d+ means matching one or more digits, \.? means matching an optional decimal point (.), and \d* means matching the decimal part, which has 0 or more digits; Step 3-6 extracts the remaining part of the criterion formula, that is, the remaining part of the criterion formula except the parameter ID, the digital parameter used in the logical comparison operation, and the duration; Step 3-7 loads the pre-designed judgment code, removes duplicates from the parameter ID extracted in step 3-4 and fills it in the location of the associated parameter. The parsed parameter ID, logical operation, arithmetic operation and duration are combined into a code block, which is filled in the part where the formula is located to generate the file to be compiled.

3. The method for dynamically compiling flight parameter diagnosis rules according to claim 2, wherein: In the steps 3-5, the logic comparison includes >, <, ==, <=, >=, !=.

4. The method for dynamically compiling flight parameter diagnosis rules according to claim 1, wherein: In steps 2-4, the form of the judgment formula is "[conditional expression, duration]", where duration must be greater than or equal to 0. When it is equal to 0, it means that a fault is determined when the conditional expression is met.

5. The method for dynamically compiling flight parameter diagnosis rules according to claim 1, wherein: In the steps 2-4, the specific segmentation uses "[]".

6. The method for dynamically compiling flight parameter diagnosis rules according to claim 1, wherein: In the steps 2-4, the specific operation of step 4 is as follows: Step 4-1 compiles the resource files required to implement other functions in the file to be compiled, and generates a linkable target resource file; Step 4-2 compiles the criterion file to be compiled and links the target resource file generated in step 4-1 to generate a criterion target file that can be linked to the main program.

Images