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

Abstract

The invention relates to a user interface generation system, method, equipment and product for vehicle bus development, and relates to the technical field of information processing. The system comprises a panel compiling module used for compiling editable panel style information into a dynamic link library file; the main interface module is used for importing the dynamic link library file into a bus development tool and generating a main interface containing the panel style information; the middle module is used for receiving a calling instruction which is sent by a user through the main interface and is used for calling the middle module to generate an auxiliary 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 jointly form the user interface. According to the method and the device, the development efficiency and expansibility of the panel component and the user interface in the bus development tool can be improved.

Description

Technical Field

[0001] 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 program product. Background Art

[0002] The vehicle bus development tool CANOE (CAN Open Environment) is a tool used for the development, testing and analysis of vehicle buses. Panel, also known as "panel", is a function of the vehicle bus development tool, which is used to intuitively display and control objects in the vehicle bus development tool (such as system variables, signals, messages, etc.). Developers mainly create panels through the built-in Panel Designer of the vehicle bus development tool. Users can add various predefined controls such as buttons, text boxes, dashboards, etc. by dragging and dropping to build the user interface required for vehicle network testing and simulation.

[0003] However, manually dragging controls and performing associated operations is very time-consuming and labor-intensive, and prone to errors. Secondly, the number and form of controls provided by Panel Designer are limited, and there is no scalable and customizable interface generation operation, which cannot meet the diverse development needs of the CANOE Panel user interface. Summary of the invention

[0004] The embodiment of the present application provides a user interface generation system, which improves the development efficiency and scalability of panel components and user interfaces in a bus development tool, so as to at least partially solve the above-mentioned technical problems.

[0005] In order to achieve the above objective, according to a first aspect of the present application, a user interface generation system is provided, the method comprising:

[0006] The panel compilation module is used to compile the editable panel style information into a dynamic link library file;

[0007] A main interface module, used for importing the dynamic link library file into a bus development tool to generate a main interface including the panel style information;

[0008] The intermediate module is used to receive a calling instruction issued by the user through the main interface to call the intermediate module to generate an auxiliary interface, and generate the auxiliary interface including the panel style information and other panel components according to the calling instruction and the configuration file of the user interface; the main interface and the auxiliary interface together constitute the user interface.

[0009] Optionally, the intermediate module includes:

[0010] Component builder, used to construct panel components with different functions and styles;

[0011] A component wrapper, used to encapsulate the panel components and synchronize the behaviors between the panel components;

[0012] A controller is generated, which is used 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.

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

[0014] A component constructor base class, used to define the basic properties and interfaces of the panel component and cache the interaction information of the panel component;

[0015] A component constructor implementation class, used to implement the component constructor base class;

[0016] A factory base class, used to define the creation method of the panel component;

[0017] A factory implementation class, used to implement the factory implementation class.

[0018] Optionally, the component wrapper includes:

[0019] Component wrapper base class, used to define the properties of the wrapped component;

[0020] A component wrapper implementation class, used to implement the component wrapper base class;

[0021] The component wrapper implementation class includes: a monitoring component wrapper for implementing the packaging of a monitoring component, a simulation component wrapper for implementing the packaging of a simulation component, and a diagnosis component wrapper for implementing the packaging of a diagnosis component;

[0022] The monitoring component, the simulation component and the diagnosis component are specific implementation classes of the packaging component; wherein:

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

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

[0025] The diagnostic component is used for performing fault detection and status monitoring on the panel component.

[0026] Optionally, the generation controller includes:

[0027] Generates the controller base class, which is used to define the properties of the generated component;

[0028] A generation controller implementation class, used to implement the generation controller base class;

[0029] The generation controller implementation class includes: a monitoring generation controller for realizing generation of a monitoring component, a single-section information generation controller for realizing generation of a single-section information generation component, a simulation generation controller for realizing generation of a simulation component, and a diagnosis generation controller for realizing generation of a diagnosis component;

[0030] 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 to generate a panel component including a plurality of single-section information.

[0031] Optionally, the configuration file defines the structure and content of the panel component in XML format.

[0032] Optionally, the panel compilation module is specifically used for:

[0033] Inheriting the interactive component base class of the component constructor, implementing the interactive component interface of the interactive component base class, and defining the property initialization steps of the specific class inheriting the interactive component base class to create a specific product class;

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

[0035] Implementing a wrapper class component wrapper base class corresponding to the component wrapper base class, and defining a packaging and assembly generation method for panel style information;

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

[0037] The generated controller implementation class is associated with an opening event corresponding to the user's window opening operation in the panel in the bus development tool, so as to complete the expansion of the panel style information and obtain updated panel style information.

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

[0039] According to a second aspect of the present application, a method for generating a user interface for vehicle bus development is also provided, the method comprising:

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

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

[0042] Receive a calling instruction issued by the user through the main interface to call the intermediate module to generate an auxiliary interface, and generate the auxiliary interface including the panel style information and other panel components according to the calling instruction and the configuration file of the user interface; the main interface and the auxiliary interface together constitute the user interface.

[0043] Optionally, the method further comprises:

[0044] Inheriting the interactive component base class of the component constructor, implementing the interactive component interface of the interactive component base class, and defining the property initialization steps of the specific class inheriting the interactive component base class to create a specific product class;

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

[0046] Implementing a component wrapper implementation class corresponding to the component wrapper base class, and defining a method for packaging and generating panel style information;

[0047] Implement the generation controller base class and define a control interface for the generation controller implementation class;

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

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

[0050] According to a third aspect of the present application, a computer-readable storage medium is further provided, wherein program instructions are stored in the computer-readable storage medium, and the program instructions implement the method described above when executed.

[0051] According to a fourth aspect of the present application, a computer program product is also provided, wherein the computer program product comprises program instructions, and when the program instructions are executed by a processor, the method as described above is implemented.

[0052] According to a fifth aspect of the present application, an electronic device is also provided for executing the method as described above.

[0053] In summary, the embodiment of the present application can realize the scalable CANOE Panel user interface generation architecture, and code, modularize and automate the development process of the panel component. Not only can the flexibility and scalability of panel component development be improved through modular design, but developers can also generate a standardized process for each panel component based on the intermediate module, and more clearly track and manage the creation and layout process of each panel component, avoiding problems such as error-prone, omissions or repeated operations caused by the traditional manual drag and drop controls and the panel creation method of associating objects one by one, which can significantly reduce the time and energy required by developers to create and adjust complex panel interfaces, thereby improving the development efficiency and scalability of panel components and user interfaces in vehicle bus development tools.

[0054] Other features and advantages of the present application will be described in detail in the subsequent specific implementation section. BRIEF DESCRIPTION OF THE DRAWINGS

[0055] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the following briefly introduces the drawings required for use in the description of the embodiments. Obviously, the drawings described below are only some embodiments of the present application, and those skilled in the art can obtain other drawings based on these drawings without creative work.

[0056] In order to more completely understand the present application and its beneficial effects, the following description will be given in conjunction with the accompanying drawings, wherein the same figure numbers represent the same parts in the following description.

[0057] Figure 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;

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

[0059] Figure 3 is a schematic diagram of the architecture of the intermediate module provided in the exemplary embodiment of the present application;

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

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

[0062] Figure 6 is a schematic diagram of the architecture of a component builder provided in an exemplary embodiment of the present application;

[0063] Figure 7 is a schematic diagram of a panel assembly that can be generated in an exemplary embodiment of the present application;

[0064] Figure 8 It is one of the flowcharts of a user interface generation system for vehicle bus development provided in an exemplary embodiment of the present application;

[0065] Fig. 9 This is a second flow chart of a user interface generation system for vehicle bus development provided in an exemplary embodiment of the present application;

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

[0067] The technical solutions in the embodiments of the present application will be described clearly and completely below in conjunction with the drawings in the embodiments of the present application. Obviously, the described embodiments are only part of the embodiments of the present application, rather than all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative work are within the scope of protection of the present application.

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

[0069] However, the manual dragging of controls and associating objects one by one through Panel Designer is extremely cumbersome and time-consuming when faced with a large number of controls and complex layouts. Especially when the interface needs to be repeatedly adjusted and modified, it is not only inefficient, but also prone to operational errors and omissions. Secondly, the types and number of controls provided by Panel Designer are limited, which cannot meet the growing and diverse needs, and developers cannot easily implement customized and highly complex user interfaces. In addition, although it is possible to bypass Panel Designer to create a panel by directly generating an xvp file by writing scripts or codes, due to the lack of detailed document support and guidance, it is difficult for developers to master and understand all the settings in the xvp file, resulting in a cumbersome, error-prone, difficult to adjust and maintain development process. The existing CANOE Panel development method has great limitations in flexibility, scalability and efficiency, and it is difficult to cope with complex and changing development needs and fast-iterative project environments.

[0070] 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"), which can realize the coding, modularization and automation of the panel component development process based on the scalable CANOE Panel user interface generation architecture. Not only can the flexibility and scalability of panel component development be improved through modular design, but developers can also track and manage the creation and layout process of each panel component more clearly, avoiding problems such as error-prone, omissions or repeated operations caused by the traditional panel creation method of manually dragging controls and associating objects one by one, and can significantly reduce the time and energy required by developers to create and adjust complex panel interfaces, thereby improving the development efficiency and scalability of panel components and user interfaces in vehicle bus development tools.

[0071] The present application is described below in conjunction with specific embodiments.

[0072] Figure 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, such as Figure 1 As shown, the user interface generation system of the present application may include a panel compilation module 101 , a main interface module 102 and an intermediate module 103 .

[0073] In some embodiments, the panel compiling module 101 may be used to compile editable panel style information into a dynamic link library file.

[0074] The panel style information refers to the information of visual and functional elements involved in the user interface design of CANOE Panel, which is usually defined by developers or designers through visual editing tools or direct code writing. For example, the editable panel style information can include the layout, appearance, interactive behavior, etc. of various panel UI components.

[0075] In some embodiments, the panel compilation module 101 can convert the editable panel style information into a computer executable format. The compilation process usually involves converting a high-level descriptive language (such as C# language) or format (such as XML or a custom configuration file) into a code that can be understood and executed by the computer bottom layer. In this process, the compiler can parse, optimize and finally generate machine code or other low-level code forms.

[0076] Finally, the compiled panel style information can be stored as one or more dynamic link library files, namely DLL files. Dynamic link library is a file format that contains functions and program logic that can be used by multiple programs at the same time. In Windows operating system, DLL files are a common application extension method that allows programs to dynamically load and execute specific functional modules at runtime, thereby achieving modularization and efficient resource management.

[0077] In some embodiments, the panel compilation module 101 may be specifically used for:

[0078] Inheriting the interactive component base class of the component constructor, implementing the interactive component interface of the interactive component base class, and defining the property initialization steps of the specific class inheriting the interactive component base class to create a specific product class;

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

[0080] Implement the component wrapper implementation class corresponding to the component wrapper base class, and define the packaging and generation methods of the panel style information;

[0081] Implementing the generation controller class and defining a control interface for the generation controller implementation class;

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

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

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

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

[0086] In some embodiments, after implementing a component, a corresponding component wrapper implementation class may be designed for it. This component wrapper implementation class should inherit from the component wrapper base class and define packaging and assembly methods therein. 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 features can be added to the component.

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

[0088] In some embodiments, after the controller class is implemented, 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 window), the controller will be triggered to generate and display the corresponding interface. This step is the key link to integrate components and interface logic into practical applications.

[0089] In some embodiments, all panel component codes can be compiled to generate a DLL file, which can be imported into the vehicle bus development tool CANOE as part of the 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.

[0090] Through the above steps, you can compile and generate a DLL file that can use various panel components in CANOE according to your needs, from base class inheritance, constructor and wrapper implementation, to controller definition and window event association. This process enables developers to efficiently create custom panel components and integrate them into the CANOE working environment.

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

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

[0093] In some embodiments, the main interface module 102 can import the generated DLL file into a 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 identify and load the panel components and logic generated by the panel compilation module, so that these predefined components can be used in the bus development tool.

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

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

[0096] The main interface module 102 can make the development of the user interface modular and efficient. Developers can first use the panel compilation module 101 to generate the DLL files of the panel components, and then directly import these DLL files into the bus development tool through the main interface module 102 to achieve rapid generation and testing of the user interface. This can not only reduce the workload of manual coding, but also improve the flexibility of panel design and function implementation, especially suitable for complex bus communication application scenarios.

[0097] From the above, it can be seen that the user interface generation system of the present application can import the precompiled dynamic link library file into the bus development tool through the main interface module 102, generate and display the main interface containing panel style information, thereby significantly improving the efficiency and flexibility of panel development.

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

[0099] The main interface and the auxiliary interface together constitute the user interface. The call instruction is an instruction 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 may 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.

[0100] The configuration file can define the structure and content of the panel components in XML format. XML format has good readability and structured features, 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, as well as the specific properties of these components (such as position, size, color, default value, etc.).

[0101] In some embodiments, the intermediate module 103 can dynamically generate an auxiliary interface including panel style information and other components according to the parsed configuration file content and call instructions. The generated auxiliary interface is not only coordinated 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 an option in the main interface, the intermediate module 103 can also automatically generate a corresponding auxiliary interface according to the configuration file to display more information or operation options related to the option.

[0102] It can be understood that the configuration file adopts XML format definition to conveniently define and manage various panel components and their properties in the interface. For example, the XML file can contain the following content: component type, such as button, text box, drop-down menu, etc.; component properties, such as position, size, color, font, default value, etc.; layout information, such as the arrangement order and alignment between components, etc. Through this structured definition, the intermediate module 103 can quickly read and apply these configuration information to ensure that the generated auxiliary interface meets expectations.

[0103] The design of the intermediate module 103 is suitable for application scenarios that require dynamic generation and updating of user interfaces, especially in complex systems where the user interface needs to provide different functional views according to different operation scenarios. By using XML configuration files, 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 easily modify or add configuration files to implement new interface layouts and functions without rewriting a large amount of code.

[0104] The user interface generation system of the present application can receive and parse the main interface call instruction through the intermediate module 103, and dynamically generate the auxiliary interface based on the configuration file in XML format. This module enables the system to flexibly respond to user needs and generate an interface containing panel style information and other components, thereby improving the dynamics, flexibility and scalability of the user interface.

[0105] To more accurately understand the user interface generation system of this application, please refer to Figure 2 , Figure 2 It is a data interaction diagram of a user interface generation system for vehicle bus development provided in an exemplary embodiment of the present application.

[0106] like Figure 2 As shown, 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 the DLL file containing the panel style information is imported into the vehicle bus development tool CANOE, the main interface 201 is opened and displayed by default. The main interface 201 can not only display some operating information of CANOE, but also contains some buttons, and the user can open other auxiliary interfaces 202 (also called auxiliary interfaces) by clicking these buttons.

[0107] The main interface can be used as the control center of the user interface of the entire panel, responsible for specifying configuration files, calling the middle layer of the framework, and displaying operation information. The auxiliary interface 202 can be opened by clicking the "Open auxiliary interface" button through the main interface 201. The interface generated by the middle layer 204 is also part of the panel. In the auxiliary interface 202, some specific components can be displayed, such as bus signals displayed in different styles.

[0108] In some embodiments, the configuration file 203 can be specified by the main interface 201, and the middle layer 204 can use the configuration information of the configuration file 203 to generate the auxiliary interface 202. The middle layer 204 is the core part of the entire framework, and its main function is to receive the call instruction of the main interface 201 and generate the corresponding auxiliary interface 202 according to the configuration file 203.

[0109] In some embodiments, the middle layer 204 can be divided into three parts: generation controller, component wrapper and component constructor. The component constructor is responsible for building components of 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 expand it according to the demand design. The component wrapper is used to encapsulate the component so that the 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 transmission and function call. The generation controller is responsible for the generation process of the entire auxiliary 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 auxiliary interface 202 together, and the structure of the middle layer is conveniently expanded and modified in a modular form.

[0110] In some embodiments, the intermediate module 103 may include a component constructor, a component wrapper, and a generation controller.

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

[0112] The component constructor base class can be used to define the basic properties and interfaces of the panel component and cache the interaction information of the panel component. Figure 3 As shown, the component builder base class may include the component base class Product and the interactive component base class ProductWithEvent.

[0113] In the specific implementation, the component base class Product is the base class of all panel components, which is used to provide the basic properties and interfaces of the components. These properties and interfaces provide a unified framework and basic functions for various specific components. Among them, the basic properties 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 re-layouted and resized. The specific component class will implement this method to handle these situations.

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

[0115] The abstract class interaction component base class ProductWithEvent can be an extension inherited from 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 processing interface.

[0116] In some embodiments, the properties added to the interaction component base class ProductWithEvent may include a cache of CANoe system variables, a cache of diagnostic objects, a cache of bus and device names, and the added interfaces may include event processing functions, component information publishing and subscription interfaces.

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

[0118] This application defines the basic properties and interfaces of the panel components through the component base class Product in the component constructor base class, providing a unified framework for all components. The interactive component base class ProductWithEvent inherits and extends Product to add the function of interacting with the CANOE system. Through the caching mechanism and event processing interface, the component can communicate and manage with CANOE internal objects, which not only enhances the functionality of the component, but also ensures the flexibility and scalability of the system.

[0119] Among them, 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. Figure 7 As shown, various component constructor implementation classes that can implement component base classes and interactive component base classes are shown, which will not be described one by one in this embodiment. The component constructor implementation class is a class that specifically implements the interactive component base class Product WithEvent. Taking the signal monitoring component PValueMonitor as an example, as a specific class, it implements various methods inherited from Product and ProductWithEvent. These methods jointly define controls for displaying value signals. At the same time, a Unit property is added to the signal monitoring component PValueMonitor to display 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.

[0120] 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 production plan and production, such as update production plan interface, start production interface, and stop production interface.

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

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

[0123] 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.

[0124] Among them, the component wrapper base class can be used to define the properties of the packaged component. The component wrapper base class BuilderBaseAPC can define the properties required for the packaged component, such as the factory that produces the component, packaging parameters, and packaging temporary storage. At the same time, the component wrapper base class can also define packaging process control, component assembly, and implement the first and second layer packaging interfaces.

[0125] Wherein, the component wrapper implementation class can be used to implement the component wrapper base class. In some embodiments, Figure 5 As shown, the component wrapper implementation class may include: a monitoring component wrapper for implementing the packaging of a monitoring component, a simulation component wrapper for implementing the packaging of a simulation component, and a diagnosis component wrapper for implementing the packaging of a diagnosis component.

[0126] In some embodiments, the monitoring component, the simulation component and the diagnosis component are specific implementation classes of the packaging component; wherein:

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

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

[0129] The diagnostic component is used for performing fault detection and status monitoring on the panel component.

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

[0131] In some embodiments, the generation controller can be used 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. Figure 6 As shown, the generation controller may include a generation controller base class and a generation controller implementation class.

[0132] Among them, the generated controller base class Director can be used to define the properties of the packaging component, such as defining the reading of the configuration file, the cache 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. By executing these three steps in sequence, the generation of the auxiliary interface is completed.

[0133] The generation controller implementation class can be used to implement the generation controller base class. In some embodiments, the generation controller implementation class may include: a monitoring generation controller for implementing the generation of a monitoring component, a single-section information generation controller for implementing the generation of a single-section information generation component, a simulation generation controller for implementing the generation of a simulation component, and a diagnosis generation controller for implementing the generation of a diagnosis component.

[0134] In some embodiments, 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 to generate a panel component including multiple single-section information.

[0135] Taking the monitoring generation controller as an example, a monitoring auxiliary interface can be generated through the monitoring generation controller. The generation controller implementation class can implement the main code flow of building the auxiliary interface according to the analysis results of the configuration file, sequentially call the relevant interfaces of the wrapper, and place the components in the target interface according to the layout.

[0136] Understandably, from Figure 3 As can be seen, the generation controller provides extended functions for reading, analyzing and building configuration files, 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 more components than the 34 controls of PanelDesigner, while also providing customized functions. The currently defined parts of the architecture are as follows Figure 4 , Figure 5 , Figure 6 , Figure 7 shown. Figure 4 As shown, the current architecture defines four generation controllers, which are used to generate auxiliary interfaces for monitoring, simulation, single battery information and diagnosis. Figure 5 As described above, the system of the present application can define three types of component wrappers. Figure 6 and Figure 7 As shown, three groups of component constructors are implemented, totaling 16 components.

[0137] Figure 8 is one of the schematic diagrams of a user interface generation system provided in an embodiment of the present application, such as Figure 8 As shown, the method may include the following steps 301-303, which are specifically as follows:

[0138] Step 301, compile the editable panel style information into a dynamic link library file;

[0139] Step 302: import the dynamic link library file into a bus development tool to generate a main interface including the panel style information;

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

[0141] It should be noted that, for the contents of the above steps 301-303, please refer to the detailed description of the user interface generation system of the present application, which will not be repeated here.

[0142] In order to simplify the understanding of the above steps, please refer to Fig. 9 .

[0143] Fig. 9 This is a second flow chart of a user interface generation system provided in an exemplary embodiment of the present application. Fig. 9 As shown, the following steps 401-408 may be included, which are specifically as follows:

[0144] Step 401: determine the target platform;

[0145] Step 402, determine whether the interface to be created can be implemented in the existing framework, if not, proceed to step 403, if yes, proceed to step 408;

[0146] Step 403: Write a new product class;

[0147] Step 404, write a new factory class;

[0148] Step 405: Write a new packaging class;

[0149] Step 406: Write a new control class;

[0150] Step 407, associate the event with the new control class;

[0151] Step 408: Export the target dynamic link library file of the updated panel style information.

[0152] It should be noted that the contents of the above steps 401-407 that overlap with the introduction of the user interface generation system will not be repeated here.

[0153] In some embodiments, the method of the present application may further include:

[0154] Inheriting the interactive component base class of the component constructor, implementing the interactive component interface of the interactive component base class, and defining the property initialization steps of the specific class inheriting the interactive component base class to create a specific product class;

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

[0156] Implementing a wrapper class component wrapper base class corresponding to the component wrapper base class, and defining a packaging and assembly generation method for panel style information;

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

[0158] Associating the generated controller implementation class with an opening event corresponding to the window opening operation of the user in the panel in the bus development tool, completing the expansion of the panel style information, and obtaining updated panel style information;

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

[0160] The above steps involve steps for expanding the current user interface generation system of the present application, which specifically correspond to the aforementioned steps 403-408 and will not be repeated here.

[0161] In some embodiments, the method of the present application may further include:

[0162] Obtain a first user interface to be created;

[0163] 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 module can implement the content and function of the first panel component;

[0164] If not, a corresponding prompt message is generated, and the first content and the first function that cannot be realized by the intermediate module are recorded, and the intermediate module is expanded according to the first content and the first function.

[0165] In the specific implementation, it is possible to check whether the intermediate module can generate specific components defined in the configuration file. For example, the configuration file may require a panel component to display a certain data type or provide specific interactive functions. The system needs to detect whether the intermediate module supports the creation and display of the component. It is also possible to check whether the intermediate module has the ability to implement the functions of these components, such as whether a component can interact with the CANoe system in real time, or whether it supports users to perform specific operations on the interface.

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

[0167] In some embodiments, the content and functions that cannot be implemented by the intermediate module can be recorded, which can help developers to subsequently analyze and optimize the system, and also help to clarify which components or functions are not yet supported during the interface generation process.

[0168] If the intermediate module does not have the ability to create a specific component, you can add a new component constructor to support the generation of the component. If the intermediate module cannot implement a certain functional interaction (such as data communication, event processing), you can implement these functions by extending the existing component wrapper or adding new interaction logic.

[0169] Through this process, the system can continuously optimize and expand the functions of the intermediate modules to better meet the needs of user interface creation and enhance the flexibility and scalability of the entire system.

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

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

[0172] In an exemplary embodiment, the electronic device 500 can be implemented by one or more application specific integrated circuits (ASIC), digital signal processors (DSP), digital signal processing devices (DSPD), programmable logic devices (PLD), field programmable gate arrays (FPGA), controllers, microcontrollers, microprocessors or other electronic components to execute the above-mentioned user interface generation system.

[0173] In another exemplary embodiment, a computer-readable storage medium including program instructions is also provided, and when the program instructions are executed by the domain controller, the steps of the above-mentioned user interface generation system are implemented. For example, the computer-readable storage medium may be the above-mentioned memory 502 including program instructions, and the above-mentioned program instructions may be executed by the processor 501 of the electronic device 500 to complete the following steps:

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

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

[0176] A calling instruction sent by the main interface is received, and an auxiliary interface including the panel style information and other panel components is generated according to the calling instruction and a configuration file of the user interface.

[0177] An embodiment of the present application also provides a computer-readable storage medium, wherein the computer-readable storage medium stores a computer program for electronic data exchange, and the computer program enables a computer to execute part or all of the steps of any one of the charging control methods recorded in the above method embodiments.

[0178] It should be noted that, for the aforementioned method embodiments, for the sake of simplicity, they are all expressed as a series of action combinations, but those skilled in the art should be aware that the present application is not limited by the described order of actions, because according to the present application, certain steps can be performed in other orders or simultaneously. Secondly, those skilled in the art should also be aware that the embodiments described in the specification are all preferred embodiments, and the actions and modules involved are not necessarily required by the present application.

[0179] In the above embodiments, the description of each embodiment has its own emphasis. For parts that are not described in detail in a certain embodiment, reference can be made to the relevant descriptions of other embodiments.

[0180] In the several embodiments provided in the present application, it should be understood that the disclosed device can be implemented in other ways. For example, the device embodiments described above are only schematic, such as the division of the units, which is only a logical function division. There may be other division methods in actual implementation, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, and the indirect coupling or communication connection of the device or unit can be electrical or other forms.

[0181] The units described as separate components may or may not be physically separated, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed on multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.

[0182] In addition, the functional units in the various embodiments of the application may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit. The above-mentioned integrated units may be implemented in the form of hardware or in the form of software program modules.

[0183] If the integrated unit is implemented in the form of a software program module and sold or used as an independent product, it can be stored in a computer-readable storage unit. Based on this understanding, the technical solution of the present application is essentially or the part that contributes to the prior art or all or part of the technical solution can be embodied in the form of a software product, and the computer software product is stored in a storage unit, including a number of instructions to enable a computer device (which can be a personal computer, server or network device, etc.) to perform all or part of the steps of the method described in each embodiment of the present application. The aforementioned storage unit includes: U disk, read-only memory (ROM), random access memory (RAM), mobile hard disk, disk or optical disk and other media that can store program codes.

[0184] A person of ordinary skill in the art can understand that all or part of the steps in the various methods of the above embodiments can be completed by instructing related hardware through a program, and the program can be stored in a computer-readable storage unit, which can include: a flash drive, a read-only storage unit, a random access memory, a magnetic disk or an optical disk, etc.

[0185] The preferred embodiments of the present application are described in detail above in conjunction with the accompanying drawings; however, the present application is not limited to the specific details in the above embodiments. Within the technical concept of the present application, a variety of simple modifications can be made to the technical solution of the present application, and these simple modifications all fall within the protection scope of the present application.

[0186] It should also be noted that the various specific technical features described in the above specific embodiments can be combined in any suitable manner without contradiction. In order to avoid unnecessary repetition, this application will not further describe various possible combinations.

[0187] In addition, the various implementation modes of the present application may be arbitrarily combined, and as long as they do not violate the concept of the present application, they should also be regarded as the contents disclosed in the present application.

Claims

1. A user interface generation system for vehicle bus development, characterized in that: The system comprises: The panel compilation module is used to compile the editable panel style information into a dynamic link library file; A main interface module, used for importing the dynamic link library file into a bus development tool to generate a main interface including the panel style information; The intermediate module is used to receive a calling instruction issued by the user through the main interface to call the intermediate module to generate an auxiliary interface, and generate the auxiliary interface including the panel style information and other panel components according to the calling instruction and the configuration file of the user interface; the main interface and the auxiliary interface together constitute the user interface.

2. The user interface generation system according to claim 1, characterized in that: The intermediate module comprises: Component builder, used to construct panel components with different functions and styles; A component wrapper, used to encapsulate the panel components and synchronize the behaviors between the panel components; A controller is generated, which is used 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 according to claim 2, characterized in that The component constructor is created based on the abstract factory pattern, and the component constructor includes: A component constructor base class, used to define the basic properties and interfaces of the panel component and cache the interaction information of the panel component; A component constructor implementation class, used to implement the component constructor base class; A factory base class, used to define a method for creating the panel component; The factory implementation class is used to implement the factory base class.

4. The system according to claim 2, characterized in that The component wrapper includes: Component wrapper base class, used to define the properties of the wrapped component; A component wrapper implementation class, used to implement the component wrapper base class; The component wrapper implementation class includes: a monitoring component wrapper for implementing the packaging of a monitoring component, a simulation component wrapper for implementing the packaging of a simulation component, and a diagnosis component wrapper for implementing the packaging of a diagnosis component; The monitoring component, the simulation component and the diagnosis component are specific implementation classes of the packaging component; wherein: The monitoring component is used to monitor the display status and signal status of the panel component; The simulation component is used to simulate the input signal of the user; The diagnostic component is used for performing fault detection and status monitoring on the panel component.

5. The system according to claim 2, characterized in that The generation controller comprises: Generates the controller base class, which is used to define the properties of the generated component; A generation controller implementation class, used to implement the generation controller base class; The generation controller implementation class includes: a monitoring generation controller for realizing generation of a monitoring component, a single-section information generation controller for realizing generation of a single-section information generation component, a simulation generation controller for realizing generation of a simulation component, and a diagnosis generation controller for realizing generation of a 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 to generate a panel component including a plurality of single-section information.

6. The system according to claim 5, characterized in that The configuration file defines the structure and content of the panel component in XML format.

7. The system according to claim 6, characterized in that The panel compilation module is specifically used for: Inheriting the interactive component base class of the component constructor, implementing the interactive component interface of the interactive component base class, and defining the property initialization steps of the specific class inheriting the interactive component base class to create a specific product class; Create a component constructor base class corresponding to the factory base class; Implementing a component wrapper base class corresponding to the component wrapper base class, and defining a method for packaging and generating panel style information; Implement the generation controller base class and define a control interface for the generation controller implementation class; Associating the generated controller implementation class with an opening event corresponding to the window opening operation of the user in the panel in the bus development tool, completing the expansion of the panel style information, and obtaining updated panel style information; Compile the updated panel style information into a target dynamic link library file.

8. A method for generating a user interface for vehicle bus development, characterized in that: The method comprises: Compile 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 including the panel style information; Receive a calling instruction issued by the user through the main interface to call the intermediate module to generate an auxiliary interface, and generate the auxiliary interface including the panel style information and other panel components according to the calling instruction and the configuration file of the user interface; the main interface and the auxiliary interface together constitute the user interface.

9. The method according to claim 8, characterized in that The method further comprises: Inherit the interactive component base class, implement the interactive component interface, and define the attribute initialization steps to create a specific product class; Create a component constructor base class corresponding to the factory base class; Implement the component wrapper implementation class corresponding to the component wrapper base class, and define the packaging and assembly methods of the panel style information; Implementing a controller class and defining a control interface in the controller class; Associating the controller class with an opening event of a panel in the bus development tool, completing the expansion of the panel style information, and obtaining updated panel style information; The updated panel style information is compiled into a target dynamic link library file, and the target dynamic link library file is imported into the bus development tool to generate a user interface including the updated panel style information.

10. The method according to claim 8, characterized in that The method further comprises: Obtain a first user interface to be created; 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 module can implement the content and function of the first panel component; If not, a corresponding prompt message is generated, and the first content and the first function that cannot be realized by the intermediate module are recorded, and the intermediate module is expanded according to the first content and the first function.

11. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores program instructions, which implement the method according to any one of claims 8 to 10 when executed.

12. A computer program product, characterized in that The computer program product comprises program instructions, and when the program instructions are executed by a processor, the method according to any one of claims 8 to 10 is implemented.

13. An electronic device, characterized in that: Used to perform the method according to any one of claims 8 to 10.

Images