CN113360713A - Design method and system for embedded graphic frame of automobile instrument - Google Patents
Design method and system for embedded graphic frame of automobile instrument Download PDFInfo
- Publication number
- CN113360713A CN113360713A CN202110599359.5A CN202110599359A CN113360713A CN 113360713 A CN113360713 A CN 113360713A CN 202110599359 A CN202110599359 A CN 202110599359A CN 113360713 A CN113360713 A CN 113360713A
- Authority
- CN
- China
- Prior art keywords
- file
- tree structure
- automobile instrument
- node
- generate
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 32
- 238000013461 design Methods 0.000 title claims abstract description 15
- 238000013515 script Methods 0.000 claims abstract description 21
- 238000004891 communication Methods 0.000 claims abstract description 18
- 238000004806 packaging method and process Methods 0.000 claims abstract description 14
- 230000006870 function Effects 0.000 claims description 23
- 238000004458 analytical method Methods 0.000 claims description 16
- 239000004973 liquid crystal related substance Substances 0.000 claims description 8
- 238000007781 pre-processing Methods 0.000 claims description 5
- 238000009434 installation Methods 0.000 claims description 3
- 239000012634 fragment Substances 0.000 abstract description 4
- 230000007246 mechanism Effects 0.000 abstract description 4
- 238000010586 diagram Methods 0.000 description 8
- 230000008859 change Effects 0.000 description 3
- 238000011161 development Methods 0.000 description 3
- 238000003491 array Methods 0.000 description 2
- 230000007547 defect Effects 0.000 description 2
- 230000003993 interaction Effects 0.000 description 2
- 101000767160 Saccharomyces cerevisiae (strain ATCC 204508 / S288c) Intracellular protein transport protein USO1 Proteins 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 230000008676 import Effects 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000008569 process Effects 0.000 description 1
- 230000008707 rearrangement Effects 0.000 description 1
- 230000003252 repetitive effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/80—Information retrieval; Database structures therefor; File system structures therefor of semi-structured data, e.g. markup language structured data such as SGML, XML or HTML
- G06F16/84—Mapping; Conversion
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/90—Details of database functions independent of the retrieved data types
- G06F16/901—Indexing; Data structures therefor; Storage structures
- G06F16/9027—Trees
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/90—Details of database functions independent of the retrieved data types
- G06F16/906—Clustering; Classification
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/42—Syntactic analysis
- G06F8/427—Parsing
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Databases & Information Systems (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Data Mining & Analysis (AREA)
- Software Systems (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a design method and a system for an embedded graphic frame of an automobile instrument. The design method of the embedded graphic frame for the automobile instrument comprises the following steps: s1, establishing a tree structure corresponding to graphic elements of the automobile instrument; s2, analyzing the established tree structure to generate an analyzed file; s3, adding a custom statement describing communication between nodes into the analyzed file to obtain an intermediate file; s4, analyzing the intermediate file to generate a file finally used for compiling; and S5, packaging all the project files to generate an executable program. The method and the device automatically generate the required codes by analyzing the XML file through the Python script, avoid the problems of memory leakage, memory fragment generation and the like caused by building a tree structure by using a dynamic memory allocation mechanism, and have better control force when the code amount of a project is larger, so the method and the device have the characteristics of high efficiency, safety and light weight.
Description
Technical Field
The invention relates to the technical field of automobile instruments, in particular to a design method and a system of an embedded graphic frame for an automobile instrument.
Background
Along with the development of science and technology, the automobile instrument field has also obtained rapid development, and liquid crystal instrument has generally been applied to the car, because the car is more intelligent, the auxiliary function is more and more, and the quantity of the graphic element that will present on the liquid crystal instrument also increases thereupon, for example: speedometer, electric quantity, energy flow, driving information and the like. For graphical user interfaces with numerous graphical elements, it becomes more complicated to implement efficient control of the graphical elements, and particularly, it is inefficient to uniformly control graphical elements having the same attributes.
In order to enable the graphic element control of the liquid crystal instrument to be more efficient, the invention provides a design method and a system for an embedded graphic frame of an automobile instrument.
Disclosure of Invention
The invention aims to overcome the defects of the prior art and provides a design method and a system of an embedded graphic framework for an automobile instrument.
In order to achieve the purpose, the invention adopts the following technical scheme:
a design method of an embedded graphic frame for an automobile instrument comprises the following steps:
s1, establishing a tree structure corresponding to graphic elements of the automobile instrument;
s2, analyzing the established tree structure to generate an analyzed file;
s3, adding a custom statement describing communication between nodes into the analyzed file to obtain an intermediate file;
s4, analyzing the intermediate file to generate a file finally used for compiling;
and S5, packaging all the project files to generate an executable program.
Further, the step S1 of building the tree structure corresponding to the graphic element of the liquid crystal meter is built by using XML language.
Further, the step S1 is specifically:
s11, classifying the graphic elements of the automobile instrument, and representing each layer after the graphic elements are classified by using nodes in a tree structure;
s12, distributing an ID to each node in the tree structure, and representing the parent-child relationship among the nodes in the form of binding the ID;
and S13, describing the attribute of the graphic element represented by the node in the tree structure to obtain the tree structure corresponding to the graphic element of the automobile instrument.
Further, the parsing in step S2 and the parsing in step S4 are performed by Python scripts.
Further, the step S2 is specifically: analyzing the content of the tree structure through an xml.etree.elementtree standard library of a Python script to generate a C file; the content of the analysis comprises preprocessing an XML file, initializing the XML file, analyzing the XML file, converting the XML file into a C file, and packaging the XML file to generate an executable program.
Further, the step S3 is specifically:
s31, describing a custom statement of communication among the graphic elements, wherein the custom statement is SEND _ txnode TO _ rxnode, the txnode represents a source node, and the rxnode represents a target node;
s32, assigning the attribute value of the source node to the target node;
s33, self-defining a message receiving statement in a callback function of a certain node;
and S34, assigning a certain attribute value of the source node to a certain attribute of the current node based on the self-defined message receiving statement.
Further, the step S4 is specifically: analyzing a self-defined statement which describes communication between graphic elements and appears in the C file through a Python script to generate a corresponding source file and a header file; and the source file comprises a corresponding structure pointer array.
Further, the step S5 is specifically: the python script is packaged into an exe executable file using the pip install installation pyinstteller.
Correspondingly, a design system of an embedded graphic framework for an automobile instrument is also provided, and comprises the following components:
the building module is used for building a tree structure corresponding to the graphic elements of the automobile instrument;
the first analysis module is used for analyzing the established tree structure to generate an analyzed file;
the adding module is used for adding the self-defined sentences describing the communication between the nodes into the analyzed file to obtain an intermediate file;
the second analysis module is used for analyzing the intermediate file to generate a file finally used for compiling;
and the packaging module is used for packaging all the project files to generate an executable program.
Furthermore, the tree structure corresponding to the graphic element of the liquid crystal instrument is established in the establishing module by using an XML language; and the first analysis module and the second analysis module are analyzed through a Python script.
Compared with the prior art, the method has the advantages that the required codes are automatically generated by analyzing the XML file through the Python script, the problems of memory leakage, memory fragment generation and the like caused by the fact that a tree structure is built by using a dynamic memory allocation mechanism are solved, and when the code amount of a project is large, the method also has good control force, so the method has the characteristics of high efficiency, safety and light weight.
Drawings
FIG. 1 is a flow chart of a method for designing an embedded graphics framework for a vehicle instrument according to an embodiment;
FIG. 2 is a tree structure diagram of an XML document description provided in one embodiment;
FIG. 3 is a block diagram illustrating a relationship between coordinate attributes of parent and child nodes in a tree structure according to an embodiment;
FIG. 4 is a block diagram illustrating whether an attribute relationship is visible between parent and child nodes in a tree structure according to an embodiment;
FIG. 5 is an initial interface diagram of a graphic element on the automobile instrument provided in the second embodiment;
fig. 6 is an interface diagram after the position is changed according to the second embodiment.
Detailed Description
The embodiments of the present invention are described below with reference to specific embodiments, and other advantages and effects of the present invention will be easily understood by those skilled in the art from the disclosure of the present specification. The invention is capable of other and different embodiments and of being practiced or of being carried out in various ways, and its several details are capable of modification in various respects, all without departing from the spirit and scope of the present invention. It is to be noted that the features in the following embodiments and examples may be combined with each other without conflict.
The invention aims to overcome the defects of the prior art and provides a design method and a system of an embedded graphic framework for an automobile instrument.
Example one
The embodiment provides a design method of an embedded graphic frame for an automobile instrument, as shown in fig. 1, including the steps of:
s1, establishing a tree structure corresponding to graphic elements of the automobile instrument;
s2, analyzing the established tree structure to generate an analyzed file;
s3, adding a custom statement describing communication between nodes into the analyzed file to obtain an intermediate file;
s4, analyzing the intermediate file to generate a file finally used for compiling;
and S5, packaging all the project files to generate an executable program.
In step S1, a tree structure corresponding to the graphic element of the meter is created.
The present embodiment describes a tree structure using an XML language. The method specifically comprises the following steps:
s11, classifying the graphic elements of the automobile instrument, and representing each layer after the graphic elements are classified by using nodes in a tree structure;
classifying the graphs according to the control relationship of the graph elements, for example, six icons in the automobile instrument are respectively defined as icon1, icon2, icon3, icon4, icon5 and icon6, as shown in fig. 2, if the six icons have the same requirement on the position control relationship, then icon1 and icon4 can be respectively set as parent nodes, icon2 and icon3 can be set as child nodes of icon1, and icon5 and icon6 can be set as child nodes of icon 4; the coordinates of the child node will be determined by the absolute coordinates of the parent node and the relative coordinates of the child node. If the three coordinates have the same requirements on display relations, after the parent-child relations are established among the nodes and the attributes are set, if icon2 and icon3 are displayed along with icon1, if icon1 is not displayed, icon2 and icon3 are also not displayed; icon4, icon5, and icon6 are similar.
The embodiment can add different attributes to establish parent-child relationship according to actual application environment, and because the XML language is an inherent hierarchical data format, it is more suitable to describe the tree structure by the XML language, and establish the tree structure for management by the classified graphic elements.
S12, distributing an ID to each node in the tree structure, and representing the parent-child relationship among the nodes in the form of binding the ID;
based on nodes in the tree structure, an ID is distributed to each node in the XML file, an attribute representing the ID of a child node is added under a parent node, and the parent-child relationship is represented in the form of binding the ID.
And S13, describing the attribute of the graphic element represented by the node in the tree structure to obtain the tree structure corresponding to the graphic element of the automobile instrument.
Describing attributes of the graphic elements represented by the nodes based on the tree structure, such as coordinate information of the graphic elements, whether the graphic elements are visible and other attributes; and adding a callback function name in the node attribute for generating a callback function after analysis, and completing logic control on each node in the callback function.
The coordinate information of the graphic element is shown in fig. 3, and fig. 3 is a diagram of a coordinate attribute relationship between parent and child nodes in a tree structure. Wherein, X, Y absolute coordinates in parent icon 1: the UI framework adds the absolute coordinates of the parent node and the relative coordinates of the object to calculate the absolute coordinates of the object. If an object has no parent, then the relative coordinates are equal to the absolute coordinates. X, Y absolute coordinates of child nodes icon2, icon 3: parent object absolute coordinates plus the relative coordinates of the object.
Fig. 4 shows attributes such as whether a graphic element is visible, and fig. 4 is a diagram of a relationship between attributes visible between parent and child nodes in a tree structure. The m _ visible relative whether attributes of parent icon1, child icon2, icon3 are visible: int is 0, specifically assigned by the object, 0 is invisible, 1 is visible, if a certain object has no parent object, then the relative visible attribute value is equal to the absolute visible attribute value. Whether m _ visible attributes of parent node icon1, child node icon2, icon3 are absolutely visible: int-1, 0 is invisible and 1 is visible. The UI framework multiplies the attribute value of the parent object which is absolutely visible or not by the attribute value of the parent object which is relatively visible or not, and if the multiplication result is 0, the parent object is invisible; if the result of multiplication is 1, the object is visible.
In step S2, the created tree structure is analyzed, and an analyzed file is generated.
Analyzing the XML file content through an XML. Elementary tree can implement a simple and efficient API for parsing and creating XML data, import XML, elementary tree as ET into XML parsing library, elementary tree represents the whole XML document as a tree, elements represent single nodes in this tree, interaction (reading and writing files) with the whole document is usually done at the elementary tree level, and interaction with single XML elements and their sub-elements is done at the element level. Each Element object has the following attributes, tag (string object) represents the kind of data representation, attribute (differential object) represents the attached attribute, text (string object) represents the content of the Element, tail (string object) represents the trail after the Element closure, and several sub-elements are included.
The expression form of the Element object in the XML file is, for example, < tag attribute ═ 1 text [ ] tail, the statement is parsed by using an XML.
In this embodiment, the parsing content includes preprocessing an XML file, initializing the XML file, parsing the XML file, converting the XML file into a C file, and packaging the XML file into an executable program.
Preprocessing the XML file, namely preprocessing the XML file, wherein ID completion is carried out on newly added nodes; and if the XML file is not found locally, automatically generating the XML template.
Initializing the XML file is to update the relevant information of the ID of the parent-child node and complete the binding of the ID.
Analyzing the XML file is used for obtaining useful information in the XML file for other modules to use, for example, extracting attribute names and attribute types of all nodes in the XML file, traversing all the attributes, and storing the attribute names and the attribute types into a dictionary as key value pairs for generating a structural body describing the node attributes in the C file; traversing and extracting node names according to the hierarchical order of the parent-child node relationship, and generating an array in the C file to facilitate subsequent traversal data; and extracting the callback function name corresponding to each node, generating the callback function in the C file, and finishing logic control on each node in the callback function.
Converting the XML file into the C file is to convert the node information obtained from parsing the XML file into a corresponding C code, and includes generating a structure body describing node attributes, a node array for sequence traversal, a callback function for controlling node logic, and the like.
Packaging an XML file to generate an executable program is to use the pip install to install a PyInsteller to package a python script into an exe executable file.
In this embodiment, a source file for describing a hook function for node logic control is generated after Python parsing. Codes for actually completing node logic control are written in a hook function, wherein the PHook hook function is called each time, the VHook hook function can be selectively called by changing cycles and whether the node has visible attributes, and logic function control codes which are not influenced by other nodes are generally written in the PHook hook function.
The Python script automatically generates a description of the attribute relationship between the parent and child nodes in the C file after analyzing the XML file, wherein the description is only for the description of whether the coordinate sum is the visible attribute, the absolute coordinate of the child node is equal to the sum of the absolute coordinate of the parent node and the relative coordinate of the child node, the absolute visible attribute value of the child node is equal to the product of the multiplication of the absolute visible attribute value of the parent node and the relative visible attribute value of the child node, and different attribute relationships can be edited in the XML according to different actual project environments.
In step S3, a custom statement describing the inter-node communication is added to the parsed file, resulting in an intermediate file.
Adding a custom statement to describe communication among the graphic elements in the C file generated in step S2, specifically:
s31, describing a custom statement of communication among the graphic elements, wherein the custom statement is SEND _ txnode TO _ rxnode, the txnode represents a source node, and the rxnode represents a target node;
in step S2, a custom statement describing inter-node communication is added to the C file (file for describing actual logical control of nodes) automatically generated after the python script is parsed for the first time, since the Phook hook function of a node is not affected by other node attributes and is called each time, and the Vhook function is controlled by the cycle of the node, the attribute of visibility, and the like, a custom statement SEND _ txnode to _ rxnode describing node communication is added under the Phook function, and the custom statement should be written under the hook function of the source node.
S32, assigning the attribute value of the source node to the target node;
based on the self-defined statement, the attribute value of the source node is assigned to the target node, and two nodes performing communication are arbitrary, for example, one node may transmit a message to its sibling node, or a child node may transmit a message to its parent node.
S33, self-defining a message receiving statement in a callback function of a certain node;
self-defining a receiving message statement as this (attribute) or txnode in a callback function of a certain node; wherein this refers to the current node, the parenthesis of this is the attribute value of the current node, txnode refers to the source node, and the parenthesis of txnode is the attribute value of the source node.
And S34, assigning a certain attribute value of the source node to a certain attribute of the current node based on the self-defined message receiving statement.
And assigning a certain attribute value of the source node to a certain attribute of the current node. The content of the transmitted message is arbitrary, for example, the coordinate attribute value of the target node is changed along with the coordinate attribute value of the source node, so that the coordinate attribute value of the source node can be transmitted to the target node as a message.
In step S4, the intermediate file is parsed to generate a file to be finally compiled.
Using a Python script to re-analyze the intermediate file added with the custom statement in the step S3 to generate a C file finally used for compiling; the method specifically comprises the following steps:
and the C file which is finally used for compiling and generated after the intermediate file is re-analyzed by utilizing the Python script, wherein the custom statement for describing node communication is deleted, the custom statement for describing received messages is replaced by a statement which can be compiled, simultaneously, a source file message.c and a header file message.h for storing and declaring a message array are automatically generated, the header file message.h for declaring the message array is quoted in the C file which is finally used for compiling, and a code is generated through the Python analysis, so that a repetitive encoding process can be omitted, and the development is more efficient.
The source file comprises corresponding structure pointer arrays NodeInfo _ t MessageArr _ rxnode [ ] { & txnode1, & txnode2}, the arrays are sets of source nodes for sending messages to the target node, and the custom node assignment statement is analyzed to be the attribute of the source node (the current node attribute) & gt (MessageArr _ txnode [ index ])). Where index represents the index value of the source node in the message array of the current node.
In step S5, all the project files are packaged to generate an executable program.
The python script is packaged into an exe executable file using the pip install installation pyinstteller.
Compared with the prior art, the method and the device have the advantages that the required codes are automatically generated by analyzing the XML file through the Python script, the problems of memory leakage, memory fragment generation and the like caused by the fact that a tree structure is built through a dynamic memory allocation mechanism are solved, and when the code amount of a project is large, the control force is good, so that the method and the device have the characteristics of high efficiency, safety and light weight.
Example two
The design method of the embedded graphic frame for the automobile instrument provided by the embodiment is different from the first embodiment in that:
the embodiment transplants the framework into the actual engineering project to verify the function.
As shown in fig. 5, which is an initial interface diagram of graphic elements on an automobile instrument, a parent-child relationship in a tree structure is established for three graphic elements in an upper-left corner box, wherein the first graphic on the left is a root node, the last two are child nodes, and the root position root.m _ x is adjusted to 250; by changing their relative coordinates, the absolute coordinates of the latter two coordinates will also change.
As shown in fig. 6, the interface graph after the location change is obtained by changing whether the attribute of the root node is displayed or not, and setting the attribute to invisible root.m _ visible equal to 0; its children nodes will also change accordingly.
EXAMPLE III
The embodiment provides a design system of an embedded graphic frame for an automobile instrument, which comprises:
the building module is used for building a tree structure corresponding to the graphic elements of the automobile instrument;
the first analysis module is used for analyzing the established tree structure to generate an analyzed file;
the adding module is used for adding the self-defined sentences describing the communication between the nodes into the analyzed file to obtain an intermediate file;
the second analysis module is used for analyzing the intermediate file to generate a file finally used for compiling;
and the packaging module is used for packaging all the project files to generate an executable program.
Furthermore, the tree structure corresponding to the graphic element of the liquid crystal instrument is established in the establishing module by using an XML language; and the first analysis module and the second analysis module are analyzed through a Python script.
It should be noted that, the design system of the embedded graphic frame for the automobile instrument provided in this embodiment is similar to the embodiment, and is not repeated herein.
Compared with the prior art, the method and the device have the advantages that the required codes are automatically generated by analyzing the XML file through the Python script, the problems of memory leakage, memory fragment generation and the like caused by the fact that a tree structure is built through a dynamic memory allocation mechanism are solved, and when the code amount of a project is large, the control force is good, so that the method and the device have the characteristics of high efficiency, safety and light weight.
It is to be noted that the foregoing is only illustrative of the preferred embodiments of the present invention and the technical principles employed. It will be understood by those skilled in the art that the present invention is not limited to the particular embodiments described herein, but is capable of various obvious changes, rearrangements and substitutions as will now become apparent to those skilled in the art without departing from the scope of the invention. Therefore, although the present invention has been described in greater detail by the above embodiments, the present invention is not limited to the above embodiments, and may include other equivalent embodiments without departing from the spirit of the present invention, and the scope of the present invention is determined by the scope of the appended claims.
Claims (10)
1. A design method of an embedded graphic frame for an automobile instrument is characterized by comprising the following steps:
s1, establishing a tree structure corresponding to graphic elements of the automobile instrument;
s2, analyzing the established tree structure to generate an analyzed file;
s3, adding a custom statement describing communication between nodes into the analyzed file to obtain an intermediate file;
s4, analyzing the intermediate file to generate a file finally used for compiling;
and S5, packaging all the project files to generate an executable program.
2. The method as claimed in claim 1, wherein the step S1 of building a tree structure corresponding to the graphic elements of the liquid crystal meter is built by using XML.
3. The method for designing an embedded graphic frame for an automobile instrument according to claim 2, wherein the step S1 specifically comprises:
s11, classifying the graphic elements of the automobile instrument, and representing each layer after the graphic elements are classified by using nodes in a tree structure;
s12, distributing an ID to each node in the tree structure, and representing the parent-child relationship among the nodes in the form of binding the ID;
and S13, describing the attribute of the graphic element represented by the node in the tree structure to obtain the tree structure corresponding to the graphic element of the automobile instrument.
4. The method of claim 1, wherein the parsing in steps S2 and S4 is performed by Python script.
5. The method for designing an embedded graphic frame for an automobile instrument according to claim 4, wherein the step S2 specifically comprises: analyzing the content of the tree structure through an xml.etree.elementtree standard library of a Python script to generate a C file; the content of the analysis comprises preprocessing an XML file, initializing the XML file, analyzing the XML file, converting the XML file into a C file, and packaging the XML file to generate an executable program.
6. The method for designing an embedded graphic frame for an automobile instrument according to claim 1, wherein the step S3 specifically comprises:
s31, describing a custom statement of communication among the graphic elements, wherein the custom statement is SEND _ txnode TO _ rxnode, the txnode represents a source node, and the rxnode represents a target node;
s32, assigning the attribute value of the source node to the target node;
s33, self-defining a message receiving statement in a callback function of a certain node;
and S34, assigning a certain attribute value of the source node to a certain attribute of the current node based on the self-defined message receiving statement.
7. The method for designing an embedded graphic frame for an automobile instrument according to claim 5, wherein the step S4 specifically comprises: analyzing a self-defined statement which describes communication between graphic elements and appears in the C file through a Python script to generate a corresponding source file and a header file; and the source file comprises a corresponding structure pointer array.
8. The method for designing an embedded graphic frame for an automobile instrument according to claim 1, wherein the step S5 specifically comprises: the python script is packaged into an exe executable file using the pip install installation pyinstteller.
9. A system for designing an embedded graphics framework for a dashboard of a vehicle, comprising:
the building module is used for building a tree structure corresponding to the graphic elements of the automobile instrument;
the first analysis module is used for analyzing the established tree structure to generate an analyzed file;
the adding module is used for adding the self-defined sentences describing the communication between the nodes into the analyzed file to obtain an intermediate file;
the second analysis module is used for analyzing the intermediate file to generate a file finally used for compiling;
and the packaging module is used for packaging all the project files to generate an executable program.
10. The system for designing an embedded graphic framework for an automobile instrument as claimed in claim 9, wherein the tree structure corresponding to the graphic elements for establishing the liquid crystal instrument in the establishing module is established using XML language; and the first analysis module and the second analysis module are analyzed through a Python script.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110599359.5A CN113360713A (en) | 2021-05-31 | 2021-05-31 | Design method and system for embedded graphic frame of automobile instrument |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110599359.5A CN113360713A (en) | 2021-05-31 | 2021-05-31 | Design method and system for embedded graphic frame of automobile instrument |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN113360713A true CN113360713A (en) | 2021-09-07 |
Family
ID=77528263
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110599359.5A Pending CN113360713A (en) | 2021-05-31 | 2021-05-31 | Design method and system for embedded graphic frame of automobile instrument |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113360713A (en) |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108804322A (en) * | 2018-06-05 | 2018-11-13 | 中国平安人寿保险股份有限公司 | Automated testing method, device, computer equipment and storage medium |
| US20200264899A1 (en) * | 2019-02-19 | 2020-08-20 | Pivotal Software, Inc. | Executable configuration template language |
| CN112181371A (en) * | 2020-09-17 | 2021-01-05 | 宝能(广州)汽车研究院有限公司 | User interface design method, user interface design apparatus, and storage medium |
-
2021
- 2021-05-31 CN CN202110599359.5A patent/CN113360713A/en active Pending
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108804322A (en) * | 2018-06-05 | 2018-11-13 | 中国平安人寿保险股份有限公司 | Automated testing method, device, computer equipment and storage medium |
| US20200264899A1 (en) * | 2019-02-19 | 2020-08-20 | Pivotal Software, Inc. | Executable configuration template language |
| CN112181371A (en) * | 2020-09-17 | 2021-01-05 | 宝能(广州)汽车研究院有限公司 | User interface design method, user interface design apparatus, and storage medium |
Non-Patent Citations (2)
| Title |
|---|
| 娄宇等: "基于XML的嵌入式图形界面自动生成技术", 《计算机应用》, vol. 29, 30 June 2009 (2009-06-30), pages 285 - 295 * |
| 株式会社ANK: "XML文件", 《图解PYTHON轻松快速掌握实力派脚本语言精华》, 31 August 2019 (2019-08-31), pages 185 - 186 * |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US6769095B1 (en) | Hierarchically structured control information editor | |
| Meliá et al. | A model-driven development for GWT-based rich internet applications with OOH4RIA | |
| US6504554B1 (en) | Dynamic conversion of object-oriented programs to tag-based procedural code | |
| US9015660B1 (en) | Proxy graphical user interface generation | |
| US8875039B2 (en) | Propagation of characteristics in a graphical model environment | |
| JP2006526828A (en) | Uniform device-independent graphical user interface generation method and terminal | |
| US20100251266A1 (en) | Mechanism for interfacing a display screen of another technology with a computing platform | |
| CN113126990B (en) | Page development method, device, equipment and storage medium | |
| CN112364496B (en) | Avionics simulation panel generation system based on HTML5 and VUE technologies | |
| van der Aalst et al. | Ex Spect 6.4 An Executable Specification Tool for Hierarchical Colored Petri Nets | |
| US20110289396A1 (en) | Spreadsheet-Based Graphical User Interface for Dynamic System Modeling and Simulation | |
| CN106775607A (en) | A kind of method that ICD is automatically generated header file data-interface | |
| CN109471632B (en) | A kind of page Dynamic Configuration, device, server and user terminal | |
| CN113360713A (en) | Design method and system for embedded graphic frame of automobile instrument | |
| EP3834080B1 (en) | Static reconcilliation of application view hierarchies | |
| EP0692112B1 (en) | Dynamic browser system | |
| CN112966457A (en) | Graphical cloud development platform | |
| Sayers et al. | A simulation graphical user interface for vehicle dynamics models | |
| CN109542442A (en) | A kind of display interface edit methods based on ARINC661 standard | |
| CN111190581B (en) | Visual flowsheet machine learning and artificial intelligence system | |
| Phanouriou | User interface markup language (uiml) draft specification | |
| CA2377945A1 (en) | Hierarchically structured control information editor | |
| CN113641842A (en) | BIM-based atlas query method | |
| CN116204165A (en) | QT engineering development plug-in and engineering graphical development system and method based on same | |
| Ding et al. | Research of model-driven interactive automatic/semi-automatic form building |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| RJ01 | Rejection of invention patent application after publication | ||
| RJ01 | Rejection of invention patent application after publication |
Application publication date: 20210907 |