Embedded human-computer interface code generation method based on OpenGL

Abstract

The invention relates to an OpenGL (Open Graphics Library)-based embedded human-computer interface code generation method, and belongs to the field of automatic code generation. A human-computer interface code model in an onModel tool is stored as a file in an XML format, the invention provides a method for automatically generating a C code from a model file, and the method comprises the following steps of: analyzing the file by using an XML analyzer, and dividing model data into different modules; according to different module data, calling a code generation function to generate a code; and calling an adaptation layer interface to complete code generation. According to the generation method disclosed by the invention, the human-computer interface model in the onModel tool can be generated into the graphic rendering C code based on the OpenGL. The OpenGL has a cross-platform characteristic, so that the generated C code can be applied to any target platform, and repeated compiling of the code is reduced.

Description

Technical Field

[0001] The invention belongs to the field of automatic code generation, and in particular relates to an OpenGL-based embedded human-machine interface code generation method. Background Art

[0002] In the aerospace field, the importance of human-machine interface in software systems is becoming increasingly prominent. As a bridge for users to interact with computer systems, the design quality of human-machine interface directly affects the user experience and the convenience of system operation. The traditional manual coding process is cumbersome, error-prone, and difficult to achieve cross-platform compatibility. When the interface needs to be optimized, manually modifying the code is time-consuming and laborious. Based on the above problems, the human-machine interface is designed through modeling, and then cross-platform code is automatically generated. This method can improve design efficiency and reduce development costs.

[0003] With the improvement of my country's independent research and development capabilities for industrial software, benchmarking tools for human-machine interface design software are also developing rapidly. Among them, OnModel, as a model-based detailed design tool independently developed by our unit, provides a multi-functional graphic design and development environment for embedded human-machine interfaces. Automatic code generation for the human-machine interface is a key function in the tool.

[0004] Aiming at the human-machine interface code generation requirements of the OnModel tool, the present invention realizes automatic C code generation based on a self-developed adaptation layer by parsing the human-machine interface model data created in the OnModel tool, and on this basis, realizes the improvement and optimization of the OnModel tool function. Summary of the invention

[0005] 1. Technical issues to be resolved

[0006] The technical problem to be solved by the present invention is how to provide an embedded human-machine interface code generation method based on OpenGL to solve the key step of automatically generating embedded C code from a human-machine interface model.

[0007] (II) Technical solution

[0008] In order to solve the above technical problems, the present invention proposes an embedded human-machine interface code generation method based on OpenGL, which comprises the following steps:

[0009] The first step is to parse the file and divide the model data into different modules

[0010] Parse the tags in the XML file through the XML parser and divide the elements in the XML into data of different modules;

[0011] Step 2: Generate code based on different data

[0012] According to the different data obtained by the first step of analysis, different functions are used for processing, and a recursive function is used to generate a code framework for the sub-element information;

[0013] Step 3: Supplement the model code according to the interface provided by the adaptation layer

[0014] In order to simplify the generation process, all OpenGL instructions are encapsulated in the adaptation layer. At the same time, the adaptation layer provides an interface that matches the sub-primitive type. The adaptation layer interface is called according to the sub-primitive type, and the code is supplemented to complete the code generation.

[0015] (III) Beneficial effects

[0016] The present invention proposes an embedded human-machine interface code generation method based on OpenGL, which mainly has the following characteristics:

[0017] (1) By parsing the content of the XML file, the data is divided into different modules and the compliance of the data is checked. Then, the data is generated into corresponding C code through the corresponding generation function, realizing the parsing and code generation of the human-machine interface file for the OnModel tool, supporting the key functions of the OnModel tool.

[0018] (2) By using a packaged adaptation layer, the complex calls of OpenGL are avoided during the code generation process. The adaptation layer interface that is highly matched with the primitive type is directly called, and the adaptation layer then calls the OpenGL instructions, which simplifies the code generation process and improves the simplicity and accuracy of the generated code.

[0019] (3) The parsed XML file is generated into multiple header files and source files according to the function. These files can call each other to complete modular code generation, reduce the coupling between various functions, reduce code complexity, improve maintainability, and facilitate subsequent users to integrate the code. BRIEF DESCRIPTION OF THE DRAWINGS

[0020] Figure 1 The process of generating and using the human-machine interface code of the present invention;

[0021] Figure 2 A diagram showing the relationship between XML files and generated code files;

[0022] Figure 3 To generate function and call relationship graph;

[0023] Figure 4 XML content and code diagram for line width;

[0024] Figure 5 For texture XML content and code map;

[0025] Figure 6Define XML content and code graphs for data;

[0026] Figure 7 To configure the data code map;

[0027] Figure 8 XML content and code diagrams for input and output;

[0028] Fig. 9 is the initialization function graph;

[0029] Fig.10 To draw a function framework diagram;

[0030] Fig.11 is the interaction function graph;

[0031] Fig.12 Call graph for code files;

[0032] Fig.13 A diagram of the arc XML content and the generated code;

[0033] Fig.14 A diagram of the XML content and generated code for the reference model. DETAILED DESCRIPTION

[0034] In order to make the purpose, content and advantages of the present invention more clear, the specific implementation methods of the present invention are further described in detail below in conjunction with the drawings and examples.

[0035] Based on the actual functions and performance requirements of OnModel, a model-based software analysis, design and verification tool, after the user completes the human-machine interface design through the modeling method in the tool, the model needs to be generated into embedded C code. The generated C code calls OpenGL for graphics rendering to achieve cross-platform compatibility. Designing the human-machine interface through the modeling method and then automatically generating embedded code can significantly reduce the time of manual coding, allowing users to focus more on design and improve efficiency. The designed model and code can be reused to improve reusability.

[0036] The present invention provides an embedded human-machine interface code generation method based on OpenGL. This generation method can generate OpenGL-based graphics rendering C code from a human-machine interface model in an onModel tool. Since OpenGL has a cross-platform feature, the generated C code can be applied to any target platform, reducing the repetitive writing of code. The human-machine interface code model in the onModel tool is stored as a file in XML format. The present invention provides a method for automatically generating C code from a model file, including: using an XML parser to parse the file and divide the model data into different modules; calling a code generation function according to different module data to generate code; calling an adaptation layer interface to complete code generation.

[0037] The purpose of the present invention is to solve the problem of the key step of automatically generating embedded C code from a human-machine interface model for OnModel, a self-developed tool of our unit in the field of MBSE.

[0038] The entire onModel human-computer interface code generation and usage process is as follows Figure 1 As shown in the figure, the human-computer interface model data in onModel can be divided into three files according to their functions: resource files, data definition files and model files. The resource file stores five resource tables: fonts, textures, gradients, line widths and line types. The data definition file stores the custom data types used in the model. The model file stores the model's metadata. These files are stored in XML format. These files are automatically generated into C code corresponding to the human-computer interface model. The code includes resource code, model drawing code, interaction code, configuration code and data definition code. In the generated code, the adaptation layer interface encapsulated by onModel according to the primitives and OpenGL features is called to complete the graphics rendering. When the user needs to use the generated code, the user needs to manually write the window initialization and context initialization code, and the interface drawing part can directly call the automatically generated code.

[0039] The present invention mainly focuses on the implementation of this process from onModel human-machine interface file to C code.

[0040] The first step is to parse the file and divide the model data into different modules

[0041] The XML parser parses the tags in the XML file and divides the elements in the XML into data of different modules, including:

[0042] Use the XML parser to first parse the resource file to obtain the resource data, and then obtain the data definition from the data definition file. Parse the model file and decompose the model data into configuration data, interaction data, reference model, sub-graph metadata, and input and output according to the keywords in the model file.

[0043] Configuration data describes the canvas size and canvas zoom ratio. Interaction data refers to data such as mouse and keyboard. Referenced models refer to other models referenced in the top-level model. Referenced models can also include referenced models, input and output, and metadata, which are traversed through recursion. Sub-geometry metadata is the metadata in the model, such as lines, polygons, circles, etc. Input and output are the input and output of the top-level model, as well as local variables.

[0044] In the process of parsing the model file, the model data is checked according to the resource data and data definition data. If undefined resource data or data types appear in the model data, an error prompt is given and code generation is terminated.

[0045] Step 2: Generate code based on different data

[0046] According to the different data obtained by the first step of parsing, different functions are used for processing. For the sub-element information, a recursive function is used to generate a code framework, including:

[0047] Generate resource code. For each resource type, a header file and source file are generated separately. Simple data is declared in array form, and complex data is directly loaded into OpenGL. When using resources in primitives, resources are obtained through array indexes.

[0048] Generate data definition code and generate all data definitions into a header file and source file for use by other code files.

[0049] The configuration data generates a header file and a source file separately for users to use when initializing windows and contexts.

[0050] The top-level model and each referenced model generate corresponding header files and source files separately. For each model, the header file is divided into three parts: macro definitions for getting and setting input and output, model structure definitions, model initialization, and drawing function declarations. The input parameters of the function are all model structures. The source file contains the implementation of the function. In the initialization function, the model input and output variables are initialized, and the initial values ​​are obtained from the input and output data; in the drawing function, comments and brackets are generated according to the number of sub-element and hierarchical structure of the model. The comments include the name, type and unique identifier of the sub-element.

[0051] If there are interactive graphics in the graphics, the interactive code is generated separately. All interactive codes are implemented in one source file, which includes functions for obtaining the mouse position, obtaining keyboard key information, setting mouse events, and setting keyboard events. The interactive code does not change with the model, and the interactive event processing logic is performed in the model code.

[0052] Step 3: Supplement the model code according to the interface provided by the adaptation layer

[0053] In order to simplify the generation process, all OpenGL instructions are encapsulated in the adaptation layer. At the same time, the adaptation layer provides an interface that matches the sub-element type. The adaptation layer interface is called according to the sub-element type, and the code is supplemented to complete the code generation.

[0054] In the second step, the drawing function of the model code generates a hierarchical structure according to the sub-element information. This step requires matching the adaptation layer interface according to the sub-element type. The sub-element attributes are used to determine the resources, mode, and interface input parameters used for drawing the element, thereby generating the drawing code.

[0055] Example 1

[0056] The matching relationship between the onModel file and the generated code file is as follows Figure 2 As shown. Color, font, gradient, line width, and line type are resources. Each resource file is stored in a separate XML file to generate corresponding header files and source files. Data definition files also generate header files and source files separately. The top-level model file generates the top-level model code and configuration code. If the reference model is used in the top-level model, the code is generated through the reference model file. If the top-level model uses interactive primitives, the interactive code and interactive code function declaration header file are generated for use by other code files.

[0057] The specific implementation steps of embedded human-machine interface code generation based on OpenGL are:

[0058] The first step is to parse the file and divide the model data into different modules

[0059] Use XML parser to parse resource files, and divide them into color, font, gradient, line width, and line type according to resource type. The XML and data storage structure of color, gradient, and line type resources are shown in the following table:

[0060]

[0061]

[0062] Parse the data definition file. The data definition file and storage structure are shown in the following table:

[0063]

[0064] Parse the top-level model file and divide the model data into configuration data, referenced models, sub-graph metadata, and input and output according to XML tags.

[0065] Configuration data includes canvas size and scaling. The reference model refers to data of type "referenceContainer" in a sub-element. This type of element is given the position, size, scaling, and modifiable attribute information in the top-level model file. The specific model definition needs to obtain the file address of the reference model through the "file" tag, and then parse the reference model file to obtain the reference model data separately. The parsing of the reference model file does not require parsing the configuration data, and the rest is the same as the parsing method of the top-level model file. Sub-element metadata refers to the data obtained through the tag "children" in the top-level model file. A top-level model has several sub-elements, and a sub-element can also have sub-elements on the next layer. Input and output data refers to the input and output of the top-level model, as well as local variables. The matching relationship between the key tags and data in XML is as follows:

[0066]

[0067]

[0068] The second step is to generate code based on different data

[0069] Based on the results of the first step, different functions are used according to different types of data, and the data is used as input to generate corresponding code files. Figure 3 It is the main function and calling relationship when generating code.

[0070] 1. Resource data

[0071] The line width, line type, color, and font data in the resource data are relatively small, so when generating code, a constant array is directly generated. When generating code for textures and gradients, the adaptation layer interface is directly called to assign data to OpenGL. Figure 4 XML content and generated code for line width, Figure 5 XML content and generated code for textures.

[0072] 2. Data Definition

[0073] The data definition code is generated using the "generateDefinition" function. The generated file is named "om_global_definition.h", and the XML content and generated code are as follows Figure 6 shown.

[0074] 3. Configuration data

[0075] The configuration data includes the canvas width, height, horizontal axis scaling ratio and vertical axis scaling ratio. A header file and a source file are generated respectively, and the file names are "target_configuration.h / c", which are used to complete the definition of the configuration data. The generated code is as follows Figure 7 shown.

[0076] 4. Input and output data

[0077] For each input and output, generate the setting and getting methods using macro definitions, but not local variables. At the same time, you also need to generate a structure containing inputs, outputs, and local variables. The structure is the formal parameter of the subsequent graphics drawing function. Figure 8 It is the XML content of input and output and the generated code.

[0078] 5. Sub-element

[0079] A model contains two main functions: initialization and drawing. The initialization function is called at the beginning, and the drawing function is called once in each running cycle. The function of the initialization function is to initialize the input, output and local variables according to the initial values ​​in XML. Fig. 9 is the generated initialization function.

[0080] The function of the drawing function is to call the adaptation layer and complete the graphics drawing according to the sub-element information. According to the hierarchical structure of the sub-element, the corresponding structure framework is generated. Sub-element can be nested, and recursion is used to traverse all sub-element. The unique identifier OID is used to locate the element. Fig.10 Is a framework for XML content and generation.

[0081] 6. Reference Model

[0082] In order to improve code modularity, a header file and source file are generated for each referenced model, which are called in the top-level model code. The generation method is the same as that of the top-level model.

[0083] 7. Interaction Data

[0084] If there are interactive elements in the model, a source file for obtaining mouse and keyboard events that is independent of the model is generated. This file contains functions for obtaining the mouse position and keyboard key events. This file is copied directly from the template library of the onModel tool. The functions that need to be used in the actual sub-element are declared in "om_imported_function.h" for the model code to call. Fig.11 This is a partial source code display.

[0085] Finally, the calling relationship between all generated code files is as follows Fig.12 shown.

[0086] Step 3: Supplement the model code according to the interface provided by the adaptation layer

[0087] In the second step, according to the hierarchical relationship between sub-element, the function framework of the drawing function is generated. On this basis, according to each sub-element type, the corresponding interface of the adaptation layer is matched. The code location is determined by the unique identifier. The following table lists the matching relationship between some sub-element types and interfaces:

[0088]

[0089] The properties of the sub-element match the resource selection, mode setting and interface input. Taking the arc element as an example, the "lineWidth" in "properties" indicates the line width, which corresponds to "mglIndexLineWidthi" in the code. Fig.13The XML and generated code for the arc have matching properties as shown in the following table. Since "fillColor" is -1, only the outer contour is drawn, and the texture and gradient properties are not used.

[0090]

[0091]

[0092] When a sub-element is a referenced model, the attribute part is generated into the code as the input value of the referenced model. Fig.14 The matching relationship between the XML content and the generated code of a reference model is shown in the following table.

[0093]

[0094] Embodiment 2:

[0095] The embedded human-machine interface code generation method based on OpenGL is mainly based on the following steps:

[0096] The first step is to parse the file and divide the model data into different modules

[0097] Parse the tags in the XML file through the XML parser and divide the elements in the XML into data of different modules;

[0098] Step 2: Generate code based on different data

[0099] According to the different data obtained by the first step of analysis, different functions are used for processing, and a recursive function is used to generate a code framework for the sub-element information;

[0100] Step 3: Supplement the model code according to the interface provided by the adaptation layer

[0101] In order to simplify the generation process, all OpenGL instructions are encapsulated in the adaptation layer. At the same time, the adaptation layer provides an interface that matches the sub-primitive type. The adaptation layer interface is called according to the sub-primitive type, and the code is supplemented to complete the code generation.

[0102] Technical advantages and effects:

[0103] The present invention proposes an embedded human-machine interface code generation method based on OpenGL, which mainly has the following characteristics:

[0104] (1) By parsing the content of the XML file, the data is divided into different modules and the compliance of the data is checked. Then, the data is generated into corresponding C code through the corresponding generation function, realizing the parsing and code generation of the human-machine interface file for the OnModel tool, supporting the key functions of the OnModel tool.

[0105] (2) By using a packaged adaptation layer, the complex calls of OpenGL are avoided during the code generation process. The adaptation layer interface that is highly matched with the primitive type is directly called, and the adaptation layer then calls the OpenGL instructions, which simplifies the code generation process and improves the simplicity and accuracy of the generated code.

[0106] (3) The parsed XML file is generated into multiple header files and source files according to the function. These files can call each other to complete modular code generation, reduce the coupling between various functions, reduce code complexity, improve maintainability, and facilitate subsequent users to integrate the code.

[0107] The above is only a preferred embodiment of the present invention. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the technical principles of the present invention. These improvements and modifications should also be regarded as the scope of protection of the present invention.

Claims

1. A method for generating embedded human-machine interface code based on OpenGL, characterized in that: The method comprises the following steps: The first step is to parse the file and divide the model data into different modules Parse the tags in the XML file through the XML parser and divide the elements in the XML into data of different modules; Step 2: Generate code based on different data According to the different data obtained by the first step of analysis, different functions are used for processing, and a recursive function is used to generate a code framework for the sub-element information; Step 3: Supplement the model code according to the interface provided by the adaptation layer In order to simplify the generation process, all OpenGL instructions are encapsulated in the adaptation layer. At the same time, the adaptation layer provides an interface that matches the sub-primitive type. The adaptation layer interface is called according to the sub-primitive type, and the code is supplemented to complete the code generation.

2. The method for generating embedded human-machine interface code based on OpenGL as claimed in claim 1, characterized in that: The first step comprises: Use the XML parser to first parse the resource file and obtain the resource data; then obtain the data definition from the data definition file; parse the model file and decompose the model data into configuration data, interaction data, reference model, sub-graph metadata and input and output according to the keywords in the model file; The configuration data describes the canvas size and canvas zoom ratio; Interaction data refers to mouse and keyboard data; Referenced models refer to other models referenced in the top-level model. Referenced models can also include referenced models, input and output, and metadata, and traversal is achieved through recursion; Sub-element metadata is the element metadata in the model; Inputs and outputs are the inputs and outputs of the top model, as well as local variables; In the process of parsing the model file, the model data is checked according to the resource data and data definition data. If undefined resource data or data types appear in the model data, an error prompt is given and code generation is terminated.

3. The method for generating code for an embedded human-machine interface based on OpenGL as claimed in claim 2, characterized in that: The human-computer interface model data in onModel is divided into three types of files according to their functions: resource files, data definition files and model files; the resource files store five resource tables: fonts, textures, gradients, line widths and line types; the data definition files store custom data types used in the model; the model files store the model's graphic metadata; these files are stored in XML format.

4. The method for generating embedded human-machine interface code based on OpenGL as claimed in claim 2, characterized in that: In the first step, the reference model refers to the data of type "referenceContainer" in the sub-element. This type of element is given the position, size, scale, and modifiable attribute information in the top-level model file. The specific model definition needs to obtain the file address of the reference model through the "file" tag, and then parse the reference model file to obtain the reference model data separately; the parsing of the reference model file does not need to parse the configuration data, and the rest is consistent with the parsing method of the top-level model file; the sub-element metadata refers to the data obtained through the tag "children" in the top-level model file. There are several sub-elements in a top-level model, and a sub-element can also have sub-elements of the next layer.

5. The method for generating embedded human-machine interface code based on OpenGL according to any one of claims 2 to 4, characterized in that: The second step includes: Generate resource code. For each resource type, a header file and source file are generated separately. Simple data is declared in array form, and complex data is directly loaded into OpenGL. When using resources in primitives, resources are obtained through array indexes. Generate data definition code, generate all data definitions into a header file and source file for use by other code files; The configuration data generates a header file and a source file separately for users to use when initializing windows and contexts; The top-level model and each referenced model generate corresponding header files and source files separately; for each model, the header file is divided into three parts: macro definitions for getting and setting input and output, model structure definitions, model initialization and drawing function declarations, and the function input parameters are all model structures; the source file is the implementation of the function; in the initialization function, the model input and output variables are initialized, and the initial values ​​are obtained from the input and output data; in the drawing function, comments and brackets are generated according to the number of sub-element and hierarchy of the model, and the comments include the name, type and unique identifier of the sub-element; If there are interactive graphics among the graphics, the interactive code will be generated separately; all interactive codes are implemented in one source file, which includes functions for obtaining the mouse position, obtaining keyboard key information, setting mouse events, and setting keyboard events; the interactive code does not change with the model, and the interactive event processing logic is performed in the model code.

6. The method for generating embedded human-machine interface code based on OpenGL as claimed in claim 5, characterized in that: The line width, line type, color, and font data in the resource data are small, so when generating the code, a constant array is directly generated; when generating the code for textures and gradients, the adaptation layer interface is directly called to assign the data to OpenGL.

7. The method for generating embedded human-machine interface code based on OpenGL as claimed in claim 5, characterized in that: The data definition code is generated using the "generateDefinition" function; the generated file is named "om_global_definition.h".

8. The method for generating embedded human-machine interface code based on OpenGL as claimed in claim 5, characterized in that: Configuration data: The configuration data includes the canvas width, height, horizontal axis scaling ratio and vertical axis scaling ratio. A header file and a source file are generated respectively. The file names are "target_configuration.h / c" to complete the definition of configuration data. Input and output data: For each input and output, generate the setting and obtaining methods using macro definitions, and local variables are not required; at the same time, it is also necessary to generate a structure containing input, output, and local variables. The structure is the formal parameter of the subsequent graphics drawing function; Sub-element: A model contains two main functions: initialization and drawing. The initialization function is called at the beginning, and the drawing function is called once in each running cycle. The function of the initialization function is to initialize the input, output and local variables according to the initial values ​​in XML. The function of the drawing function is to call the adaptation layer and complete the graphics drawing according to the sub-element information. According to the hierarchical structure of the sub-element, the corresponding structure framework is generated. When the sub-element is nested, recursion is used to realize the traversal of all sub-element. The unique identifier OID is used to realize the positioning of the element. Reference model: Generate a header file and source file for each reference model, and call it in the top-level model code; Interactive data: If there are interactive graphics in the model, a source file for obtaining mouse and keyboard events that is independent of the model is generated. This file contains functions for obtaining the mouse position and keyboard key events. This file is copied directly from the template library of the onModel tool. The functions that need to be used in the actual sub-graphics are declared in "om_imported_function.h" for the model code to call.

9. The method for generating code for an embedded human-machine interface based on OpenGL as claimed in claim 5, characterized in that: The third step includes: in the second step, the drawing function of the model code generates a hierarchical structure according to the sub-element information; this step needs to match the adaptation layer interface according to the sub-element type, and the sub-element attributes are used to determine the resources, modes, and input parameters of the interface used for drawing the element, thereby generating the drawing code.

10. The method for generating embedded human-machine interface code based on OpenGL as claimed in claim 9, characterized in that: In the third step, a function framework of the drawing function is generated according to the hierarchical relationship between the sub-element. On this basis, the interface corresponding to the adaptation layer is matched according to each sub-element type, and the code location is determined by a unique identifier; the attributes of the sub-element match resource selection, mode setting and interface input; when the sub-element is a reference model, the attribute part is generated into the code as the input value of the reference model.

Images