User interface generation system and method for vehicle bus development, device, and product

Abstract

A user interface generation system and method for vehicle bus development, a device, and a product. The system comprises a panel compiler, a main interface generator, and an intermediate processor. The panel compiler is configured to compile editable panel style information into a dynamic link library file. The main interface generator is configured to import the dynamic link library file into a bus development tool, and generate a main interface comprising the panel style information. The intermediate processor is configured to: receive a call instruction issued by a user via the main interface and used for calling the intermediate processor to generate an auxiliary interface; and, on the basis of the call instruction and a configuration file of a user interface, generate the auxiliary interface comprising the panel style information and other panel components. The main interface and the auxiliary interface together constitute the user interface.

Description

User interface generation system, method, apparatus and product for vehicle bus development

[0001] Cross-reference to related disclosures

[0002] The present disclosure claims priority to Chinese Patent Publication No. 202411391524.8, filed on September 30, 2024, the entire contents of which are incorporated herein by reference. TECHNICAL FIELD

[0003] The present application relates to the field of information processing technology, and in particular to a user interface generation system, method, device, computer readable storage medium and computer product. BACKGROUND

[0004] In related technologies, the vehicle bus development tool CANOE (CAN Open Environment) is very time-consuming and laborious, and is prone to errors, through manual dragging of controls and performing association operations. Secondly, the number and form of controls provided by Panel Designer are limited, and do not have expandable and customizable interface generation operations. TECHNICAL PROBLEM

[0005] However, the existing vehicle bus development tool CANOE (CAN Open Environment) cannot meet the diversified development needs of the user interface of CANOE Panel. TECHNICAL SOLUTION

[0006] The embodiments of the present application provide a user interface generation system, which improves the development efficiency and expandability of the panel component and user interface in the bus development tool, to at least partially solve the above technical problems.

[0007] In order to achieve the above-mentioned purpose, according to the first aspect of the present application, a user interface generation system is provided, comprising:

[0008] a panel compiler configured to compile editable panel style information into a dynamic link library file;

[0009] a main interface generator configured to import the dynamic link library file into a bus development tool and generate a main interface containing the panel style information;

[0010] an intermediate processor configured to receive a calling instruction issued by a user through the main interface for calling the intermediate processor to generate an auxiliary interface, and generate the auxiliary interface containing the panel style information and other panel components according to the calling instruction and a configuration file of the user interface; the main interface and the auxiliary interface together constitute the user interface.

[0011] Optionally, the intermediate processor comprises:

[0012] a component constructor for constructing panel components of different functions and styles;

[0013] a component wrapper for packaging the panel components and synchronizing behaviors between the panel components;

[0014] a generation controller for reading and parsing the configuration file and invoking the component constructor and the component wrapper according to the parsed configuration file to generate the auxiliary interface.

[0015] Optionally, the component constructor is created based on an abstract factory pattern, and the component constructor comprises:

[0016] a component constructor base class for defining basic attributes and interfaces of the panel components and caching interaction information of the panel components;

[0017] a component constructor implementation class for implementing the component constructor base class;

[0018] a factory base class for defining a creation method of the panel components;

[0019] a factory implementation class for implementing the factory implementation class.

[0020] Optionally, the component wrapper comprises:

[0021] a component wrapper base class for defining attributes of a wrapper component;

[0022] a component wrapper implementation class for implementing the component wrapper base class;

[0023] wherein the component wrapper implementation class comprises a monitoring component wrapper for implementing a wrapper monitoring component, a simulation component wrapper for implementing a wrapper simulation component, and a diagnosis component wrapper for implementing a wrapper diagnosis component;

[0024] the monitoring component, the simulation component, and the diagnosis component are specific implementation classes of the wrapper components; and

[0025] the monitoring component is configured to monitor display states and signal states of the panel components;

[0026] the simulation component is configured to simulate input signals of the user;

[0027] the diagnosis component is configured to detect faults and monitor states of the panel components.

[0028] Optionally, the generation controller comprises:

[0029] A generation controller base class is generated to define attributes of a generation component;

[0030] A generation controller implementation class is generated to implement the generation controller base class;

[0031] The generation controller implementation class includes a monitoring generation controller to implement a monitoring component, a single-section information generation controller to implement a single-section information generation component, a simulation generation controller to implement a simulation component, and a diagnosis generation controller to implement a diagnosis component.

[0032] The monitoring component, the single-section information generation component, the simulation component, and the diagnosis component are specific implementation classes of the generation component; and the single-section information generation component is configured to generate a panel component including a plurality of single-section information.

[0033] Optionally, the configuration file defines the structure and content of the panel component in an Extensible Markup Language (XML) format.

[0034] Optionally, the panel compiler is configured to:

[0035] Inherit an interaction component base class of the component constructor, implement an interaction component interface of the interaction component base class, and define an attribute initialization step of a specific class inheriting the interaction component base class to create a specific product class.

[0036] Create a constructor class component constructor base class corresponding to the factory base class;

[0037] Implement a wrapper class component wrapper base class corresponding to the component wrapper base class, and define a wrapping and assembling generation method of panel style information;

[0038] Implement the generation controller base class, and define a control interface in the generation controller implementation class;

[0039] Associate the generation controller implementation class with an opening event corresponding to an operation of opening a window in a panel by the user in the bus development tool, complete extension of the panel style information, and obtain updated panel style information.

[0040] Compile the updated panel style information into a target dynamic link library file.

[0041] According to a second aspect of the present application, a user interface generation method for vehicle bus development is also provided, including:

[0042] Compile the editable panel style information into a dynamic link library file;

[0043] Import the dynamic link library file into a bus development tool to generate a main interface containing the panel style information;

[0044] Receive a calling instruction issued by a user through the main interface for calling the intermediate processor to generate an auxiliary interface, and generate the auxiliary interface containing the panel style information and other panel components according to the calling instruction and a configuration file of the user interface; the main interface and the auxiliary interface jointly constitute the user interface.

[0045] Optionally, the intermediate processor is configured to:

[0046] Construct panel components with different functions and styles;

[0047] Package the panel components and synchronize behaviors between the panel components; and

[0048] Read and parse the configuration file, and call the component constructor and the component wrapper according to the parsed configuration file to generate the auxiliary interface.

[0049] Optionally, the component constructor is created based on an abstract factory mode, and the component constructor is configured to:

[0050] Define basic attributes and interfaces of the panel components, and cache interaction information of the panel components;

[0051] Implement the component constructor base class;

[0052] Define a creation method of the panel components; and

[0053] Implement the factory base class.

[0054] Optionally, the component wrapper is configured to:

[0055] Define attributes of a wrapped component; and

[0056] Implement the component wrapper base class;

[0057] The component wrapper implementation class includes a monitoring component wrapper for implementing a wrapped monitoring component, an analog component wrapper for implementing a wrapped analog component, and a diagnostic component wrapper for implementing a wrapped diagnostic component.

[0058] Optionally, the monitoring component, the analog component, and the diagnostic component are specific implementation classes of the wrapped component; wherein:

[0059] The monitoring component is configured to monitor display states and signal states of the panel components;

[0060] The simulation component is configured to simulate the input signal of the user; and

[0061] The diagnostic component is configured to perform fault detection and state monitoring on the panel component.

[0062] Optionally, the generation controller is configured to:

[0063] define the attributes of the generation component; and

[0064] implement the generation controller base class;

[0065] and further implement a generation monitoring component, implement a generation single-section information generation component, implement a generation simulation component, implement a generation diagnostic component;

[0066] The monitoring component, the single-section information generation component, the simulation component and the diagnostic component are specific implementation classes of the generation component; the single-section information generation component is configured to generate a panel component including a plurality of single-section information.

[0067] Optionally, the configuration file defines the structure and content of the panel component in an extensible markup language format.

[0068] Optionally, the panel compiler is configured to:

[0069] inherit the interaction component base class of the component constructor, implement the interaction component interface of the interaction component base class, and define the attribute initialization step of the specific class inheriting the interaction component base class, to create a specific product class;

[0070] create a component constructor base class corresponding to the factory base class;

[0071] implement a component wrapper base class corresponding to the component wrapper base class, and define the wrapping and generation method of the panel style information;

[0072] implement the generation controller base class, and define the control interface for the generation controller implementation class;

[0073] associate the generation controller implementation class with an open event corresponding to the operation of the user opening a window in the panel in the bus development tool, complete the extension of the panel style information, and obtain updated panel style information; and

[0074] compile the updated panel style information into a target dynamic link library file.

[0075] Optionally, the method further comprises:

[0076] Inherit the interactive component base class of the component constructor, implement the interactive component interface of the interactive component base class, and define the attribute initialization step of the specific class inheriting the interactive component base class to create a specific product class;

[0077] Create a component constructor base class corresponding to the factory base class;

[0078] Implement a component wrapper implementation class corresponding to the component wrapper base class, and define the wrapping and generating methods of the panel style information;

[0079] Implement the generating controller base class and define the control interface for the generating controller implementation class;

[0080] Associate the generating controller implementation class with the open event corresponding to the operation of opening a window in the panel by the user in the bus development tool, complete the expansion of the panel style information, and obtain updated panel style information;

[0081] Compile the updated panel style information into a target dynamic link library file.

[0082] According to a third aspect of the present application, a computer readable storage medium is also provided, which stores computer instructions, and the computer instructions are executed to implement the method as described above.

[0083] According to a fourth aspect of the present application, a computer product is also provided, which includes computer instructions, and the computer instructions are executed by a processor to implement the method as described above.

[0084] According to a fifth aspect of the present application, an electronic device is also provided, which is configured to execute the method as described above. Advantages

[0085] The embodiments of the present application can realize the codeization, modularization and automation of the development process of panel components based on the extensible CANOE Panel user interface generation architecture. Not only the flexibility and expandability of the development of panel components can be improved through the modular design, but also the standardized process of each panel component can be generated according to the intermediate processor, so that the development personnel can more clearly track and manage the creation and layout process of each panel component, and the problems such as easy error, omission or repeated operation caused by the traditional manual drag-and-drop control and one-by-one association object panel creation method can be avoided. The time and effort required by the development personnel in creating and adjusting a complex panel interface can be significantly reduced, and thus the development efficiency and expandability of the panel components and user interfaces in the bus development tool can be improved. BRIEF DESCRIPTION OF DRAWINGS

[0086] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the following will briefly introduce the drawings needed in the description of the embodiments. Obviously, the drawings in the following description only show some of the embodiments of the present application, and all other drawings obtained by those skilled in the art without creative effort based on these drawings also belong to the protection scope of the present application.

[0087] In order to more completely understand the present application and its beneficial effects, the following will be described in conjunction with the drawings, wherein the same reference numerals in the following description represent the same parts.

[0088] Fig. 1 is a schematic diagram of the architecture of a user interface generation system for vehicle bus development provided in an exemplary embodiment of the present application;

[0089] Fig. 2 is a schematic diagram of data interaction of a user interface generation system for vehicle bus development provided in an exemplary embodiment of the present application;

[0090] Fig. 3 is a schematic diagram of the architecture of an intermediate processor provided in an exemplary embodiment of the present application;

[0091] Fig. 4 is a schematic diagram of the architecture of a generation controller provided in an exemplary embodiment of the present application;

[0092] Fig. 5 is a schematic diagram of the architecture of a component wrapper provided in an exemplary embodiment of the present application;

[0093] Fig. 6 is a schematic diagram of the architecture of a component constructor provided in an exemplary embodiment of the present application;

[0094] Fig. 7 is a schematic diagram of a panel component that can be generated provided in an exemplary embodiment of the present application;

[0095] Fig. 8 is a schematic diagram of one of the flowcharts of a user interface generation system for vehicle bus development provided in an exemplary embodiment of the present application;

[0096] Fig. 9 is a schematic diagram of the other of the flowcharts of a user interface generation system for vehicle bus development provided in an exemplary embodiment of the present application;

[0097] Fig. 10 is a block diagram of an electronic device provided in an exemplary embodiment of the present application.

[0098] Embodiments of the present disclosure

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

[0100] Nowadays, the vehicle bus development tool CANOE is a powerful development, testing and analysis tool widely used in the simulation and verification of vehicle networks. CANOE provides a graphical user interface named Panel, which allows users to monitor and control various objects in CANOE, such as system variables, signals, messages, protocol data stations (PDU), etc. through visualization. The creation and management of CANOE Panel mainly rely on its built-in Panel Designer tool, users can design the interface through the control library provided by Panel Designer, such as dragging and dropping controls to the canvas and associating them with objects in CANOE, users can monitor and operate signals in vehicle networks in real time.

[0101] However, the operation mode of manually dragging and associating objects one by one through Panel Designer is extremely tedious and time-consuming when facing a large number of controls and complex layouts, especially when the interface needs to be repeatedly adjusted and modified, not only inefficient, but also prone to operation errors and omissions. Secondly, the types and quantity of controls provided by Panel Designer are limited, which cannot meet the growing diversification needs, and developers cannot easily implement customized and highly complex user interfaces. In addition, although xvp files can be generated directly by writing scripts or codes to bypass Panel Designer for Panel creation, due to the lack of detailed documentation support and guidance, developers are difficult to master and understand all the settings in xvp files, resulting in a tedious, error-prone, difficult to adjust and maintain development process, making the existing CANOE Panel development method have great limitations in flexibility, scalability and efficiency, and it is difficult to meet the complex and changing development needs and fast iteration project environment.

[0102] Based on the above problems, the present application provides a user interface generation system for vehicle bus development (referred to as "user interface generation system" or "system" for short), which can realize the generation of CANOE Panel user interface based on an extensible architecture, and code, modularize and automate the development process of panel components. Not only can the modular design improve the flexibility and scalability of panel component development, but developers can also more clearly track and manage the creation and layout process of each panel component, avoiding the problems of error-prone, missing or repetitive operations caused by traditional manual dragging and associating objects one by one, which can significantly reduce the time and effort required by developers when creating and adjusting complex panel interfaces, thereby improving the development efficiency and scalability of panel components and user interfaces in vehicle bus development tools.

[0103] The present application will be described in detail below with reference to specific embodiments.

[0104] FIG. 1 is a schematic diagram of an architecture of a user interface generation system for vehicle bus development, according to an example embodiment of the present application. As shown in FIG. 1, the user interface generation system of the present application can include a panel compiler 101, a main interface generator 102, and an intermediate processor 103.

[0105] In some embodiments, the panel compiler 101 can be configured to compile editable panel style information into a dynamic link library file.

[0106] The panel style information refers to information about visual and functional elements involved in the user interface design of a CANOE Panel, which is typically defined by a developer or designer through a visual editing tool or directly by writing code. For example, the editable panel style information can include the layout, appearance, interactive behavior, etc. of various panel UI components.

[0107] In some embodiments, the panel compiler 101 can convert the editable panel style information into a computer executable format. The compilation process typically involves converting a high-level descriptive language (such as C#) or format (such as Extensible Markup Language or custom configuration files) into code that can be understood and executed by the underlying computer. During this process, the compiler can parse, optimize, and finally generate machine code or other low-level code forms.

[0108] Finally, the compiled panel style information can be stored as one or more dynamic link library files, i.e. DLL files. Dynamic link library is a file format that contains functions and logic that can be used by multiple applications simultaneously. In the Windows operating system, DLL files are a common application extension that allows dynamic loading and execution of specific function modules at runtime, thereby achieving modularization and efficient resource management.

[0109] In some embodiments, the panel compiler 101 can be configured to:

[0110] Inherit the interactive component base class of the component constructor, implement the interactive component interface of the interactive component base class, and define the attribute initialization step of the specific class that inherits the interactive component base class to create a specific product class;

[0111] Create a component constructor base class corresponding to the factory base class;

[0112] Implement a component wrapper implementation class corresponding to the component wrapper base class, and define the wrapping and generation method of the panel style information;

[0113] Implement the generation controller class, and define the control interface for the generation controller implementation class;

[0114] The generated controller implementation class is associated with an open event in the bus development tool corresponding to the user's opening a window operation in the panel, and the panel style information is expanded to obtain updated panel style information.

[0115] The updated panel style information is compiled into a target dynamic link library file.

[0116] In some embodiments, the interaction component base class ProductWithEvent can be inherited according to needs, and the relevant interaction component interface can be implemented. In this process, the developer needs to define appropriate attributes according to specific functional requirements, and set these attributes in the initialization step of the class. This step is the basis for creating a new component, ensuring that the component can meet specific functional requirements and interact with the CANOE system.

[0117] In some embodiments, a component constructor base class corresponding to the custom product class can be written. This component constructor base class should inherit from the factory base class and implement the relevant interfaces of the factory. Through these interfaces, the component constructor base class will be able to generate corresponding product components according to the production plan, ensuring that new components can be created and managed through the factory pattern.

[0118] In some embodiments, after implementing the component, a corresponding component wrapper implementation class can also be designed for it. This component wrapper implementation class should inherit from the component wrapper base class and define wrapping and assembly methods in it. The main function of the component wrapper implementation class is to provide additional encapsulation, control and communication capabilities for the component. Through the wrapper, multiple components can be integrated together, or additional behavioral characteristics can be added to the component.

[0119] In some embodiments, in order to manage and generate the final user interface, a controller class can be implemented. In this class, the developer should define relevant interfaces, such as reading configuration files, analyzing configuration files and generating interfaces. The responsibility of the controller class is to coordinate the generation process of the entire interface, ensuring that the components can be correctly laid out and displayed according to the set logic.

[0120] In some embodiments, after implementing the controller class, it can be associated with the event of opening a window. Through this association, when the user performs certain operations in CANOE (such as opening a certain window), the controller will be triggered, and then the corresponding interface will be generated and displayed. This step is a key link in integrating components and interface logic into actual applications.

[0121] In some embodiments, all the panel component codes can be compiled to generate a DLL file, which can be imported into a vehicle bus development tool CANOE as part of a panel user interface. Through the imported DLL file, CANOE can load and use the custom components and interfaces designed by the developer to achieve specific functional requirements.

[0122] Through the above steps, from the inheritance of base classes, the implementation of constructors and wrappers, to the definition of controllers and the association of window events, a DLL file that can use various panel components in CANOE can be finally compiled and generated according to requirements. This process enables developers to efficiently create custom panel components and integrate them into the working environment of CANOE.

[0123] As can be seen from the above, the panel compiler 101 system in the present application converts the panel style information defined by the designer or developer into a DLL file through C# language compilation, so that each panel style information can be dynamically called and used by other modules, thereby flexibly generating and managing the user interface corresponding to the panel, and improving the efficiency and flexibility of user interface generation.

[0124] In some embodiments, the main interface generator 102 can be used to import the dynamic link library file into the bus development tool to generate a main interface containing panel style information.

[0125] In some embodiments, the main interface generator 102 can import the generated DLL file into the bus development tool. The bus development tool is a tool for developing and debugging applications on a communication bus (such as a CAN bus). By importing the DLL file, the bus development tool can recognize and load the panel components and logic generated by the panel compiler, so that these predefined components can be used in the bus development tool.

[0126] It can be understood that by importing these DLL files containing panel style information, the main interface generator 102 can generate a complete main interface in the bus development tool. The main interface can not only contain various panel components defined by the user (such as buttons, text boxes, charts, etc.), but also include the layout and interaction logic of these components. The developer can directly see and operate this main interface in the bus development tool without manually writing additional panel code, thereby greatly improving the development efficiency.

[0127] The main interface generator 102 can also ensure that the main interface accurately reflects the panel style information. For example, the panel style information can include the appearance (such as color, size, font) of the panel components, the layout (such as position, arrangement order), and the interaction logic (such as the response behavior after clicking the button). In this way, the developer can quickly preview and adjust the user interface in the bus development tool, ensuring that it meets the expected design and functional requirements.

[0128] The main interface generator 102 can make the development of the user interface modular and efficient. The developer can first use the panel compiler 101 to generate the DLL file of the panel component, and then import these DLL files directly into the bus development tool through the main interface generator 102, realizing the rapid generation and testing of the user interface. Not only can it reduce the workload of manual coding, but also can improve the flexibility of panel design and function implementation, especially suitable for complex bus communication application scenarios.

[0129] As can be seen from the above, the user interface generation system of the present application can import the pre-compiled dynamic link library file into the bus development tool through the main interface generator 102, generate and display the main interface containing the panel style information, thereby significantly improving the efficiency and flexibility of panel development.

[0130] In some embodiments, the intermediate processor 103 can be used to receive the calling instruction issued by the user through the main interface for calling the intermediate processor to generate the auxiliary interface, and generate the auxiliary interface containing the panel style information and other panel components according to the calling instruction and the configuration file of the user interface.

[0131] The main interface and the auxiliary interface together constitute the user interface. The calling instruction is issued after the user performs certain operations (such as clicking a button or selecting a menu item) on the main interface. The content of the instruction can include a request for a specific panel component in the auxiliary interface, so that the generation of the auxiliary interface can be dynamically adjusted according to the real-time needs of the user, ensuring the flexibility of the user interface generation system.

[0132] The configuration file can define the structure and content of the panel components through the extensible markup language format. The extensible markup language format has good readability and structural characteristics, which is convenient for describing the structure and content of various panel components in the user interface. For example, the configuration file can define which panel components (such as buttons, input boxes, charts, etc.) need to be displayed, and the specific attributes (such as position, size, color, default value, etc.) of these components.

[0133] In some embodiments, the intermediate processor 103 can dynamically generate the auxiliary interface containing panel style information and other components according to the parsed configuration file content and the calling instruction. The generated auxiliary interface not only coordinates with the main interface, but also can be adjusted and updated in real time according to the user's operation requirements. For example, when the user selects a certain option in the main interface, the intermediate processor 103 can also automatically generate the corresponding auxiliary interface according to the configuration file to display more information or operation options related to the option.

[0134] It can be understood that the configuration file defined in the extensible markup language format can facilitate the definition and management of various panel components and their attributes in the interface. For example, the extensible markup language file can contain the following contents: component types such as buttons, text boxes, drop-down menus, etc.; component attributes such as position, size, color, font, default value, etc.; layout information such as arrangement order between components, alignment mode, etc. Through such structured definition, the intermediate processor 103 can quickly read and apply these configuration information to ensure that the generated auxiliary interface meets the expectations.

[0135] The design of the intermediate processor 103 is suitable for application scenarios that require dynamic generation and update of user interfaces, especially in complex systems where user interfaces need to provide different functional views according to different operation scenarios. By using the extensible markup language configuration file, the system can flexibly define and manage interface components, thereby improving the efficiency of development and maintenance. In addition, the scalability of the system is also improved, because developers can conveniently modify or add configuration files to implement new interface layouts and functions without having to rewrite a large amount of code.

[0136] The user interface generation system of the present application can realize the reception and analysis of the main interface calling instruction through the intermediate processor 103, and dynamically generate the auxiliary interface based on the configuration file in the extensible markup language format. This module enables the system to flexibly respond to user needs and generate interfaces containing panel style information and other components, thereby improving the dynamicity, flexibility and scalability of the user interface.

[0137] For a more accurate understanding of the user interface generation system of the present application, please refer to FIG. 2, which is a data interaction schematic diagram of a user interface generation system provided by a vehicle bus development in an exemplary embodiment of the present application.

[0138] As shown in FIG. 2, the main interface 201 of the vehicle bus development tool is generated by the framework of the user interface generation system of the present application. After importing the DLL file containing the panel style information into the vehicle bus development tool CANOE, the main interface 201 is displayed by default. The main interface 201 not only displays some running information of CANOE, but also contains some buttons, through which the user can open other secondary interfaces 202 (also referred to as secondary interfaces).

[0139] The main interface can serve as the control center of the user interface of the entire panel, be responsible for specifying the configuration file, calling the intermediate layer of the framework, and displaying the running information. The secondary interface 202 can be generated by the intermediate layer 204 by clicking the "open secondary interface" button in the main interface 201, and is also part of the panel. In the secondary interface 202, some specific components can be displayed, such as bus signals displayed in different styles.

[0140] In some embodiments, the configuration file 203 can be specified by the main interface 201, and the intermediate layer 204 can use the configuration information of the configuration file 203 to generate the secondary interface 202. The intermediate layer 204 is the core part of the entire framework, and its main function is to receive the calling instructions of the main interface 201 and generate the corresponding secondary interface 202 according to the configuration file 203.

[0141] In some embodiments, the intermediate layer 204 can be divided into three parts: a generation controller, a component wrapper, and a component constructor. The component constructor is responsible for constructing components with different functions and styles, which can communicate with objects inside CANOE to realize the display or control function of bus information. If the existing component type cannot meet the demand, the user can also design and extend according to the demand. The component wrapper is used to encapsulate the components, so that components with the same function can have different display effects. In addition, the component wrapper can also realize the behavior synchronization function between different components, such as message passing and function calling. The generation controller is responsible for the generation process of the entire secondary interface, including reading and parsing the configuration file, calling the component constructor and component wrapper according to the parsed configuration file, and the layout of the control. The above three parts work together to generate the secondary interface 202, and through the modular form, the structure of the intermediate layer can be easily extended and modified.

[0142] In some embodiments, the intermediate processor 103 can include a component constructor, a component wrapper, and a generation controller.

[0143] In some embodiments, the component constructor can be used to construct panel components with different functions and styles, and the component constructor is created based on the abstract factory pattern. The component constructor can include a component constructor base class, a component constructor implementation class, a factory base class, and a factory implementation class.

[0144] The component constructor base class can be used to define the basic attributes and interfaces of a panel component and cache interaction information of the panel component. As shown in FIG. 3, the component constructor base class can include a component base class Product and an interaction component base class ProductWithEvent.

[0145] In a specific implementation, the component base class Product is the base class of all panel components, which is used to provide the basic attributes and interfaces of a component, providing a unified framework and basic functions for various specific components. The basic attributes can include the serial number, name and size of the panel component. Correspondingly, the interface method of the panel component defines how to build or initialize the component. The specific component class needs to implement this method to ensure that the component can be correctly loaded and displayed in the user interface. The interface method allows the component to adjust its size at runtime. For example, when the window size changes, the component may need to be relaid out and resized. The specific component class will implement this method to handle these situations.

[0146] The abstract class component base class Product provides these basic attributes and interfaces, but the specific implementation details are left to the specific component classes that inherit from it. These specific classes can add new attributes or methods while implementing these basic functions to enhance the functionality and flexibility of the component according to the needs.

[0147] The abstract class interaction component base class ProductWithEvent can be an extension of the component base class Product, which mainly adds the function of interacting with the CANOE COM Interface. This layer of extension enables the component to interact with the internal objects of the CANOE system, mainly through the cache mechanism and event handling interface.

[0148] In some embodiments, the attributes added by the interaction component base class ProductWithEvent can include the caching of CANOE system variables, the caching of diagnostic objects, the caching of bus and device names, and the interfaces added can include event handling functions, component information publishing and subscribing interfaces.

[0149] It can be understood that the extension of this level makes the component not only an independent UI element, but also enables deep integration with the CANOE system, thereby realizing more complex functions. For example, through these extensions, the component can directly interact with the bus communication, device management, etc. of the CANOE system, so that the panel becomes an effective operation interface of the CANOE system. Although the interactive component base class ProductWithEvent provides deep integration with the CANOE system, it still maintains great flexibility. If the component needs to be applied to other target platforms, the management of objects in the target platform can be realized by modifying the called library and interface, without making large-scale modifications to the existing component, so that the design of the component is not only suitable for a specific platform, but also can be migrated and extended across platforms according to needs.

[0150] The application defines the basic attributes and interfaces of the panel component through the component base class Product in the component constructor base class, provides a unified framework for all components, and the interactive component base class ProductWithEvent inherits and extends Product to increase the function of interacting with the CANOE system. Through the caching mechanism and event processing interface, the component can communicate and manage the internal objects of the CANOE, not only enhancing the functionality of the component, but also ensuring the flexibility and scalability of the system.

[0151] The component constructor implementation class can be used to implement the component constructor base class. The component constructor implementation class can be a signal monitoring component PValueMonitor, a state monitoring component PStateMonitor, etc. As shown in FIG. 7, various component constructor implementation classes capable of implementing the component base class and the interactive component base class are shown, and this embodiment will not be described one by one. The component constructor implementation class is a class that specifically implements the interactive component base class ProductWithEvent. Taking the signal monitoring component PValueMonitor as an example, it implements various methods inherited from Product and ProductWithEvent as a specific class, which collectively define the control for displaying the value signal. At the same time, the signal monitoring component PValueMonitor also adds a Unit attribute for displaying the unit of the bus signal value. Through the constructor, this specific class can be instantiated to generate a signal display control that can be used in the user interface.

[0152] The factory base class can be used to define the creation method of the panel component. In some embodiments, the factory base class FactoriesBase can have attributes such as factory type, factory number, and production plan, and can define three interfaces for updating the production plan and production, such as the update production plan interface, the start production interface, and the stop production interface.

[0153] The factory base class FactoriesBase provides a standardized, flexible and easy-to-manage framework for the production of panel components by defining factory type, factory number and production plan attributes, and interfaces for updating production plans, starting production and stopping production. This not only improves production efficiency, but also ensures the responsiveness of the system when facing dynamic demands.

[0154] The factory implementation class can be used to implement the factory implementation class. In some embodiments, the factory implementation class can include the signal monitoring component factory FactoryPValueMonitor and other factory implementation classes as shown in FIG. 6, which will not be described one by one in this embodiment. Taking the signal monitoring component factory FactoryPValueMonitor as an example, this factory can generate a signal monitoring component PValueMonitor according to the production plan. The component constructor adopts the abstract factory design pattern, which can conveniently add panel components with new functions and styles by defining specific classes inherited from the interactive component base class ProductWithEvent. In addition, the abstract factory unifies the interface of product manufacturing, which is convenient for the calling of the component wrapper.

[0155] In some embodiments, the component wrapper can be used to encapsulate the panel components and synchronize the behaviors between the panel components. In some embodiments, the component wrapper can include a component wrapper base class and a component wrapper implementation class.

[0156] The component wrapper base class can be used to define the attributes of the wrapped component. The component wrapper base class BuilderBaseAPC can define the attributes required by the wrapped component, such as the factory of the production component, the wrapping parameters and the wrapping temporary bit, etc. At the same time, this component wrapper base class can also define the wrapping process control, component assembly, and the interface for implementing the first layer and the second layer wrapping.

[0157] The component wrapper implementation class can be used to implement the component wrapper base class. In some embodiments, as shown in FIG. 5, the component wrapper implementation class can include a monitoring component wrapper for implementing a wrapping monitoring component, a simulation component wrapper for implementing a wrapping simulation component, and a diagnostic component wrapper for implementing a wrapping diagnostic component.

[0158] In some embodiments, the monitoring component, the simulation component and the diagnostic component are specific implementation classes of the wrapped component; wherein:

[0159] The monitoring component is used to monitor the display state and signal state of the panel component;

[0160] The simulation component is used to simulate the input signal of the user;

[0161] The diagnostic component is used for fault detection and state monitoring of the panel component.

[0162] In a specific implementation, taking the monitoring component wrapper as an example, the class can implement the wrapper of the monitoring component, covering the implementation of each interface of inheritance. By implementing different wrappers, communication, logical control and encapsulation effects between different components can be achieved.

[0163] In some embodiments, the generation controller can be used to read and parse the configuration file, and call the component constructor and component wrapper according to the parsed configuration file to generate the auxiliary interface. In some embodiments, as shown in FIG. 6, the generation controller can include a generation controller base class and a generation controller implementation class.

[0164] Among them, the generation controller base class Director can be used to define the attributes of the wrapped component, such as defining the reading of the configuration file, the caching of the configuration file analysis, and defining the entire generation process as three interfaces: reading the configuration file, analyzing the configuration file, and generating according to the configuration file, and by executing these three steps in order, the generation of the auxiliary interface is completed.

[0165] Among them, the generation controller implementation class can be used to implement the generation controller base class. In some embodiments, the generation controller implementation class can include: a monitoring generation controller for implementing the generation of the monitoring component, a single section information generation controller for implementing the generation of the single section information generation component, a simulation generation controller for implementing the generation of the simulation component, and a diagnostic generation controller for implementing the generation of the diagnostic component.

[0166] In some embodiments, the monitoring component, the single section information generation component, the simulation component and the diagnostic component are specific implementation classes of the generation component; the single section information generation component is used to generate a panel component including a plurality of single section information.

[0167] Taking the monitoring generation controller as an example, the monitoring auxiliary interface can be generated through the monitoring generation controller. The generation controller implementation class can implement the main code flow of constructing the auxiliary interface according to the configuration file analysis result, sequentially call the related interfaces of the wrapper, and place the components into the target interface according to the layout.

[0168] It can be understood that, as can be seen from FIG. 3, the generation controller provides extended functions for reading, analyzing and constructing the configuration file, the component wrapper provides customized functions for component communication, logic control and component packaging, and the component constructor provides extended functions for component styles. These extended capabilities enable the architecture to support a number of components far exceeding the 34 controls of the Panel Designer, while also providing customized functions. The currently defined parts of the architecture are shown in FIG. 4, FIG. 5, FIG. 6 and FIG. 7. As shown in FIG. 4, the current architecture defines four generation controllers for generating auxiliary interfaces for monitoring, simulation, single battery information and diagnosis. As shown in FIG. 5, the system of the present application can define three component wrappers. As shown in FIG. 6 and FIG. 7, three sets of component constructors are shown, totaling 16 components.

[0169] FIG. 8 is a schematic diagram of one of the user interface generation systems provided by embodiments of the present application. As shown in FIG. 8, the method can include the following steps 301-303, which are as follows:

[0170] Step 301, compiling editable panel style information into a dynamic link library file;

[0171] Step 302, importing the dynamic link library file into a bus development tool to generate a main interface containing the panel style information;

[0172] Step 303, receiving a call instruction issued by a user through the main interface for calling the intermediate processor to generate an auxiliary interface, and generating the auxiliary interface containing the panel style information and other panel components according to the call instruction and the configuration file of the user interface; the main interface and the auxiliary interface together constitute the user interface.

[0173] It should be noted that the content of the above steps 301-303 is described in detail in the detailed description of the user interface generation system of the present application, and will not be repeated here.

[0174] In some embodiments, the intermediate processor can be used to:

[0175] construct panel components of different functions and styles;

[0176] package panel components and synchronize the behaviors between panel components; and

[0177] read and parse the configuration file, and call the component constructor and the component wrapper according to the parsed configuration file to generate an auxiliary interface.

[0178] In some embodiments, the component constructor is created based on an abstract factory pattern. The component constructor can be used to:

[0179] define the basic attributes and interfaces of the panel component, and cache the interaction information of the panel component;

[0180] implement the component constructor base class;

[0181] define the creation method of the panel component; and

[0182] implement the factory base class.

[0183] In some embodiments, the component wrapper can be used for:

[0184] define the attributes of the wrapped component; and

[0185] implement the component wrapper base class;

[0186] The component wrapper implementation class includes: a monitoring component wrapper for implementing a wrapped monitoring component, a simulation component wrapper for implementing a wrapped simulation component, and a diagnostic component wrapper for implementing a wrapped diagnostic component.

[0187] In some embodiments, the monitoring component, the simulation component, and the diagnostic component can be specific implementation classes of the wrapped component; wherein:

[0188] The monitoring component is used to monitor the display state and signal state of the panel component;

[0189] The simulation component is used to simulate the input signal of the user; and

[0190] The diagnostic component is used for fault detection and state monitoring of the panel component.

[0191] In some embodiments, the generation controller can be used for:

[0192] define the attributes of the generated component; and

[0193] implement the generation controller base class;

[0194] and is also used to implement a generated monitoring component, implement a generated single-section information generation component, implement a generated simulation component, and implement a generated diagnostic component.

[0195] The monitoring component, the single-section information generation component, the simulation component, and the diagnostic component are specific implementation classes of the generated component; the single-section information generation component is used to generate a panel component including a plurality of single-section information.

[0196] In some embodiments, the configuration file can define the structure and content of the panel component in an extensible markup language format.

[0197] In some embodiments, the panel compiler can be specifically used for:

[0198] The inheriting component constructor interacts with the component base class, implements the component interface of the component base class, and defines the attribute initialization step of the specific class inheriting the component base class to create the specific product class;

[0199] A component constructor base class corresponding to the factory base class is created.

[0200] A component wrapper base class corresponding to the component wrapper base class is implemented, and a wrapping and generating method of the panel style information is defined.

[0201] A generating controller base class is implemented, and a control interface is defined for the generating controller implementation class.

[0202] The generating controller implementation class is associated with an open event corresponding to the operation of opening a window in the panel by the user in the bus development tool, the panel style information is expanded, and updated panel style information is obtained.

[0203] The updated panel style information is compiled into a target dynamic link library file.

[0204] It should be noted that the repeated content of the above steps is not repeated here.

[0205] In order to facilitate the understanding of the content executed by the above steps, reference can be made to FIG. 9.

[0206] FIG. 9 is a flowchart of a user interface generation system provided in an exemplary embodiment of the present application, which can include the following steps 401-408, as shown in FIG. 9, and specifically as follows:

[0207] Step 401, determining the target platform;

[0208] Step 402, judging whether the interface to be created can be implemented in the existing framework, if not, entering step 403, if yes, entering step 408;

[0209] Step 403, writing a new product class;

[0210] Step 404, writing a new factory class;

[0211] Step 405, writing a new wrapper class;

[0212] Step 406, writing a new control class;

[0213] Step 407, associating the event with the new control class;

[0214] Step 408, exporting the target dynamic link library file of the updated panel style information.

[0215] It should be noted that the content of the above steps 401-407 is repeated in the introduction of the user interface generation system, and will not be described here.

[0216] In some embodiments, the method of the present application can further comprise:

[0217] Inheritance of the interactive component base class of the component constructor, implementation of the interactive component interface of the interactive component base class, and definition of the attribute initialization step of the specific class inheriting the interactive component base class to create a specific product class;

[0218] Creating a constructor class component constructor base class corresponding to the factory base class;

[0219] Implementing a wrapper class component wrapper base class corresponding to the component wrapper base class, and defining a wrapping and assembling generation method of panel style information;

[0220] Implementing the generation controller base class and defining the control interface in the generation controller implementation class;

[0221] Associating the generation controller implementation class with the open event corresponding to the operation of opening a window in the panel by the user in the bus development tool, completing the expansion of the panel style information, and obtaining updated panel style information;

[0222] Compiling the updated panel style information into a target dynamic link library file.

[0223] The above steps involve the expansion step of the current user interface generation system of the present application, which corresponds to the aforementioned steps 403-408 and will not be described here.

[0224] In some embodiments, the method of the present application can further comprise:

[0225] Obtaining a first user interface to be created;

[0226] Based on the content and function of the first panel component defined in the configuration file of the first user interface, detecting whether the current intermediate processor can implement the content and function of the first panel component;

[0227] If not, generate corresponding prompt information, and record the first content and the first function that the intermediate processor cannot implement, and extend the intermediate processor for the first content and the first function.

[0228] In a specific implementation, it can be checked whether the intermediate processor can generate a specific component defined in the configuration file. For example, the configuration file can require a certain panel component to display a certain data type or provide a specific interaction function, and the system needs to detect whether the intermediate processor supports the creation and display of the component. It can also be checked whether the intermediate processor has the ability to implement these component functions, such as whether a certain component can interact with the CANoe system in real time or whether it supports specific operations by the user on the interface.

[0229] In some embodiments, the system can generate corresponding prompt information to inform the user or developer that the current function of the intermediate processor does not meet the requirements in the configuration file, and the prompt information usually includes a detailed description of the specific components or functions that cannot be implemented.

[0230] In some embodiments, the content and functions that the intermediate processor cannot implement can be recorded, which can help the developer to analyze and optimize the system later, and also help to determine which components or functions are not yet supported during the interface generation process.

[0231] If the intermediate processor does not have the ability to create a certain specific component, a new component constructor can be added to support the generation of the component. If the intermediate processor cannot implement a certain function interaction (such as data communication, event processing), existing component wrappers can be extended or new interaction logic can be added to implement these functions.

[0232] Through this process, the system can continuously optimize and expand the functions of the intermediate processor, thereby better meeting the creation needs of the user interface and improving the flexibility and scalability of the entire system.

[0233] FIG. 10 is a block diagram illustrating an electronic device 500, according to an example embodiment. As shown in FIG. 10, the electronic device 500 can include a processor 501, a memory 502. The electronic device 500 can also include one or more of a multimedia component 503, an input / output (I / O) component 504, and a communication component 505.

[0234] The processor 501 is configured to control overall operations of the electronic device 500 to complete all or part of the steps of the user interface generation system described above. The memory 502 is configured to store various types of data to support operations of the electronic device 500, which can include, for example, instructions for operating any application or method on the electronic device 500, and application-related data such as contact data, transmitted and received messages, pictures, audio, video, and the like. The memory 502 can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as a static random access memory (SRAM), an electrically erasable programmable read-only memory (EEPROM), an erasable programmable read-only memory (EPROM), a programmable read-only memory (PROM), a read-only memory (ROM), a magnetic storage, a flash memory, a magnetic disk, or an optical disk. The multimedia component 503 can include a screen and an audio component. The screen can be, for example, a touch screen, and the audio component is configured to output and / or input audio signals. For example, the audio component can include a microphone configured to receive external audio signals. The received audio signals can be further stored in the memory 502 or transmitted through the communication component 505. The audio component also includes at least one speaker configured to output audio signals. The I / O component 504 provides an interface between the processor 501 and other interface modules, which can be a keyboard, a mouse, a button, and the like. The buttons can be virtual buttons or physical buttons. The communication component 505 is configured to perform wired or wireless communication between the electronic device 500 and other devices. The wireless communication, such as WiFi, Bluetooth, near field communication (NFC), 2G, 3G, 4G, NB-IOT, eMTC, or other 5G, and the like, the wired communication, such as CAN communication, CANFD communication, LIN communication, and the like, or a combination of one or more of them, is not limited herein. Therefore, the communication component 505 can include, for example, a WiFi module, a Bluetooth module, an NFC module, and the like.

[0235] In an exemplary embodiment, the electronic device 500 can be implemented by one or more Application Specific Integrated Circuits (ASICs), Digital Signal Processors (DSPs), Digital Signal Processing Devices (DSPDs), Programmable Logic Devices (PLDs), Field Programmable Gate Arrays (FPGAs), controllers, micro-controllers, microprocessors, or other electronic elements for performing the user interface generation system described above.

[0236] In another exemplary embodiment, a computer readable storage medium including computer instructions is also provided, which, when executed by a domain controller, implements the steps of the user interface generation system described above. For example, the computer readable storage medium can be the memory 502 described above including program instructions executable by the processor 501 of the electronic device 500 to perform the following steps:

[0237] compiling the editable panel style information into a dynamic link library file;

[0238] importing the dynamic link library file into a bus development tool to generate a main interface including the panel style information;

[0239] receiving a calling instruction issued by the main interface, and generating an auxiliary interface including the panel style information and other panel components according to the calling instruction and a configuration file of the user interface.

[0240] The embodiments of the present application also provide a computer readable storage medium storing computer instructions for electronic data exchange, which causes a computer to perform some or all steps of any one of the charging control methods described in the method embodiments above.

[0241] It should be noted that, for the above method embodiments, in order to simply describe, they are all expressed as a series of action combinations, but those skilled in the art should know that the present application is not limited to the action sequence described, because according to the present application, some steps can be performed in other sequences or simultaneously. Secondly, those skilled in the art should know that the embodiments described in the specification all belong to preferred embodiments, and the actions and modules involved are not necessarily necessary for the present application.

[0242] In the above embodiments, the description of each embodiment is focused on, and the part not described in detail in a certain embodiment can be referred to the relevant description of other embodiments.

[0243] The preferred embodiments of the present application are described in detail above with reference to the drawings, but the present application is not limited to the specific details in the above embodiments. Within the technical concept of the present application, various simple modifications can be made to the technical solutions of the present application, and these simple modifications all belong to the protection scope of the present application.

[0244] In addition, it should be noted that each specific technical feature described in the above specific embodiments can be combined in any appropriate manner without contradiction. In order to avoid unnecessary repetition, various possible combinations are not described again in the present application.

[0245] In addition, various different embodiments of the present application can also be combined in any manner, as long as it does not deviate from the idea of the present application, and it should be considered as disclosed in the present application.

Claims

1. A user interface generation system for vehicle bus development, comprising: a panel compiler configured to compile editable panel style information into a dynamic link library file; a main interface generator configured to import the dynamic link library file into a bus development tool to generate a main interface containing the panel style information; and an intermediate processor configured to receive a call instruction issued by a user through the main interface to call the intermediate processor to generate an auxiliary interface, and generate the auxiliary interface containing the panel style information and other panel components according to the call instruction and a configuration file of the user interface; the main interface and the auxiliary interface together constitute the user interface. 2.The user interface generation system of claim 1, wherein the intermediate processor comprises: a component constructor configured to construct panel components with different functions and styles; a component wrapper configured to encapsulate the panel components and synchronize behaviors between the panel components; and a generation controller configured to read and parse the configuration file, and call the component constructor and the component wrapper according to the parsed configuration file to generate the auxiliary interface. 3.The system of claim 2, wherein the component constructor is created based on an abstract factory pattern, and the component constructor comprises: a component constructor base class configured to define basic attributes and interfaces of the panel components, and cache interaction information of the panel components; a component constructor implementation class configured to implement the component constructor base class; a factory base class configured to define a creation method of the panel components; and a factory implementation class configured to implement the factory base class. 4.The system of claim 2 or 3, wherein the component wrapper comprises: a component wrapper base class configured to define attributes of a wrapped component; and a component wrapper implementation class configured to implement the component wrapper base class; wherein the component wrapper implementation class comprises a monitoring component wrapper configured to implement a wrapped monitoring component, a simulation component wrapper configured to implement a wrapped simulation component, and a diagnosis component wrapper configured to implement a wrapped diagnosis component; the monitoring component, the simulation component, and the diagnosis component are specific implementation classes of the wrapped components; and the monitoring component is configured to monitor display states and signal states of the panel components; the simulation component is configured to simulate input signals of the user; the diagnosis component is configured to detect faults and monitor states of the panel components. 5.The system of any one of claims 2-4, wherein the generation controller comprises: a generation controller base class configured to define attributes of a generated component; and a generation controller implementation class configured to implement the generation controller base class; wherein the generation controller implementation class comprises a monitoring generation controller configured to implement a generated monitoring component, a single-section information generation controller configured to implement a generated single-section information generation component, a simulation generation controller configured to implement a generated simulation component, and a diagnosis generation controller configured to implement a generated diagnosis component. ​ ​ ​ ​ The monitoring component, the single-section information generating component, the simulation component and the diagnosis component are specific implementation classes of the generating component; the single-section information generating component is used for generating a panel component including multiple single-section information.

6. The system of claim 5, wherein the configuration file defines the structure and content of the panel component in an extensible markup language (XML) format.

7. The system of claim 6, wherein the panel compiler is configured to: inherit an interaction component base class of the component constructor, implement an interaction component interface of the interaction component base class, and define an attribute initialization step of a specific class inheriting the interaction component base class to create a specific product class; create a component constructor base class corresponding to the factory base class; implement a component wrapper base class corresponding to the component wrapper base class, and define a wrapping and generating method of panel style information; implement the generating controller base class, and define a control interface for the generating controller implementation class; associate the generating controller implementation class with an open event corresponding to an operation of the user opening a window in a panel in the bus development tool, complete the extension of the panel style information, and obtain updated panel style information; and compile the updated panel style information into a target dynamic link library file.

8. A user interface generation method for vehicle bus development, comprising: compiling editable panel style information into a dynamic link library file; importing the dynamic link library file into a bus development tool to generate a main interface containing the panel style information; and receiving a calling instruction for calling the intermediate processor to generate an auxiliary interface by the user through the main interface, and generating the auxiliary interface containing the panel style information and other panel components according to the calling instruction and a configuration file of the user interface; the main interface and the auxiliary interface together constitute the user interface.

9. The method of claim 8, wherein the intermediate processor is configured to: construct panel components with different functions and styles; encapsulate the panel components, and synchronize behaviors between the panel components; and read and parse the configuration file, and call the component constructor and the component wrapper according to the parsed configuration file to generate the auxiliary interface.

10. The method of claim 9, wherein the component constructor is created based on an abstract factory pattern, and the component constructor is configured to: define basic attributes and interfaces of the panel components, and cache interaction information of the panel components; implement the component constructor base class; define a creation method of the panel components; and implement the factory base class.

11. The method of claim 9, wherein the component wrapper is configured to: define attributes of a wrapped component; and implement the component wrapper base class; wherein, the component wrapper implementation class includes a monitoring component wrapper for implementing a wrapped monitoring component, a simulation component wrapper for implementing a wrapped simulation component, and a diagnosis component wrapper for implementing a wrapped diagnosis component.

12. The method of claim 11, wherein the monitor component, the simulation component and the diagnostic component are concrete implementation classes of the panel component; wherein: the monitor component is configured to monitor display state and signal state of the panel component; the simulation component is configured to simulate input signals of the user; and the diagnostic component is configured to perform fault detection and state monitoring of the panel component.

13. The method of claim 9, wherein the generation controller is configured to: define properties of a generation component; and implement the generation controller base class; and further configured to implement a generation monitor component, implement a generation single-section information generation component, implement a generation simulation component, implement a generation diagnostic component; wherein the monitor component, the single-section information generation component, the simulation component and the diagnostic component are concrete implementation classes of the generation component; and the single-section information generation component is configured to generate a panel component including a plurality of single-section information.

14. The method of claim 13, wherein the configuration file defines structure and content of the panel component in an extensible markup language format.

15. The method of claim 14, wherein the panel compiler is configured to: inherit an interaction component base class of the component builder, implement an interaction component interface of the interaction component base class, and define a property initialization step of a concrete class inheriting the interaction component base class to create a concrete product class; create a component builder base class corresponding to the factory base class; implement a component wrapper base class corresponding to the component wrapper base class, and define a wrapping and generation method of panel style information; implement the generation controller base class, and define a control interface for the generation controller implementation class; associate the generation controller implementation class with an open event corresponding to an operation of the user opening a window in a panel in the bus development tool, complete extension of the panel style information, and obtain updated panel style information; and compile the updated panel style information into a target dynamic link library file.

16. The method of any one of claims 8-15, further comprising: inheriting an interaction component base class, implementing an interaction component interface, and defining a property initialization step to create a concrete product class; creating a component builder base class corresponding to the factory base class; implementing a component wrapper implementation class corresponding to the component wrapper base class, and defining a wrapping and assembly method of panel style information; implementing a controller class, and defining a control interface in the controller class; associating the controller class with an open event of a panel in the bus development tool, completing extension of the panel style information, and obtaining updated panel style information; and compiling the updated panel style information into a target dynamic link library file, and importing the target dynamic link library file into the bus development tool to generate a user interface including the updated panel style information.

17. The method of claim 8, further comprising: obtaining a first user interface to be created; and ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ detecting whether the current intermediate processor can implement the content and the function of the first panel component defined in the configuration file of the first user interface; if not, generating corresponding prompt information, recording the first content and the first function that the intermediate processor cannot implement, and extending the intermediate processor for the first content and the first function. 18.A computer readable storage medium, storing computer instructions, which when executed implement the method of any one of claims 8-17. 19.A computer product, comprising computer instructions, which when executed by a processor implement the method of any one of claims 8-17. 20.An electronic device configured to perform the method of any one of claims 8-17.

Images