Low-code standardized component development method based on embedded software

Abstract

The invention discloses an embedded software-based low-code standardized component development method, which comprises the following steps of: collecting a complete embedded software source code, and defining a function or a function module to be packaged; function packaging and screening: identifying and packaging independent functions and interdependent set functions; packaging a function interface, and designing a unified interface template according to the type of the function parameter; performing function framework type selection and packaging, and designing a corresponding packaging framework according to the function type of the function; a standardized component general structure frame is integrated and packaged; mounting a standard component data communication interface, designing the standard data communication interface and verifying the stability of the standard data communication interface; and warehousing the standardized components, adding labels and classification information to the packaged components, and establishing a component library management system for unified management. According to the method, the convenience, the adaptability, the reusability and the system integration degree of embedded software development are remarkably improved through a standardized component development method which is low in code and does not change an original code.

Description

Technical Field

[0001] The present invention relates to the technical field of embedded low-code platform component standardization, and in particular to a low-code standardized component development method based on embedded software. Background Art

[0002] Driven by the wave of digital manufacturing, the intelligent and automated production of embedded devices has become the focus of the industry. In order to achieve rapid iteration and efficient production of embedded devices, the digital generation of embedded software is particularly important. The traditional embedded software development method is limited by the tediousness and time-consuming manual coding, and it is difficult to meet the market's demand for rapid response and flexible customization. Therefore, exploring a new method of embedded software development based on a low-code platform has become an urgent need in the industry.

[0003] Low-code development platforms, with their advantages of rapid deployment, easy scalability, and lower technical barriers, provide a new solution for the digital generation of embedded software. However, when applying the low-code concept to embedded software development, a core challenge is how to build a set of embedded software component libraries that are both standardized and highly reusable.

[0004] To establish a standardized component library for embedded software, it is necessary to modify the general or common software function codes of the embedded software to facilitate quick calling and automatic generation of application code. The modification method needs to be as universal and standardized as possible, while minimizing modifications to the original embedded code to ensure that developers minimize code changes during the low-code application code generation process.

[0005] Currently, low-code development of embedded software faces multiple difficulties in establishing a standardized component library:

[0006] First, the traditional standardization transformation method often directly modifies the original code on a large scale. This approach is not only labor-intensive and time-consuming, but also highly customized, making it difficult to achieve true standardization and generalization. This transformation method not only increases the burden on developers, but also limits the widespread application of low-code platforms in the embedded field.

[0007] Secondly, the existing low-code development platforms mainly focus on Web software (such as Java), and their support for embedded software (especially software based on C language) is still insufficient. As the mainstream programming language in the embedded field, C language has a unique syntax structure (such as pointer operations) and is closely related to hardware, making the low-code transformation method for C language a technical problem that needs to be solved urgently.

[0008] Furthermore, embedded software often involves the control functions of the underlying hardware, which are highly complex and specific and difficult to adapt directly through existing standardized transformation methods. Therefore, the lack of standardized component transformation methods for the underlying hardware control code has become a major bottleneck in the low-code development of embedded software.

[0009] Finally, the extensive use of pointer type operations in C language also brings challenges to low-code transformation. As one of the core features of C language, pointer plays an important role in memory management and data access. However, existing low-code development platforms often lack an effective processing mechanism for pointer type codes, making it difficult to ensure the quality and performance of the code when generating embedded code.

[0010] In summary, in order to promote the digital transformation of the embedded field and improve the digital production efficiency of embedded devices, an innovative, efficient, low-code standardized component development method based on embedded software is urgently needed. This method should be able to overcome the shortcomings of existing technologies, realize the rapid generation and efficient deployment of embedded software, and provide strong support for the intelligent production of embedded devices. Summary of the invention

[0011] In view of this, the present invention proposes a low-code standardized component development method based on embedded software to solve the problem of difficulty in establishing a standardized component library faced by low-code development of embedded software in the prior art.

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

[0013] A low-code standardized component development method based on embedded software, including:

[0014] Step 1: Collect the complete embedded software source code and identify the functions or functional modules to be encapsulated;

[0015] Step 2: Function encapsulation screening, identifying and encapsulating independent functions and interdependent aggregate functions;

[0016] Step 3: Function interface encapsulation: design a unified interface template according to the function parameter type to achieve interface standardization;

[0017] Step 4: Functional framework selection and encapsulation. Design the corresponding encapsulation framework according to the function type, including the underlying hardware control class, data processing algorithm class and data interactive communication class;

[0018] Step 5: Integrate and encapsulate the universal structural framework of standardized components, design a unified external structural framework and ensure its scalability;

[0019] Step 6: Standardize the data communication interface of the component, design a standard data communication interface and verify its stability;

[0020] Step 7: Standardize component storage, add labels and classification information to the packaged components, and establish a component library management system for unified management.

[0021] Furthermore, in step 2, for the aggregate function encapsulation, the dependency relationship between the top-level function and its sub-functions is analyzed in depth to ensure that the encapsulated components will not fail to function due to missing dependencies when used independently.

[0022] Furthermore, in step 3, an error handling mechanism is designed for each encapsulated function interface to capture and handle exceptions or errors that may occur during the function call process.

[0023] Furthermore, in step 5, metadata extension fields are reserved in the unified structure framework to support new attributes or functions that may be added in the future.

[0024] Furthermore, step 2 is provided with: a function analysis module, which is used to import the embedded software source code, analyze the function call relationship, and generate a tree diagram of the function call relationship to clarify the position of each function in the code and its status as a parent node, child node or leaf node; a function selection module, which manually selects the functions to be encapsulated based on the tree diagram generated by the function analysis module. The module supports the selection of leaf node functions, parent node functions or child node functions, and allows the user to choose the entire function set or specific sub-functions as the objects to be encapsulated according to needs.

[0025] Furthermore, in the function selection module, it further includes: set encapsulation, which allows the user to choose to encapsulate the complete set of all its called functions with the current function as the root node, or only select some necessary functions for encapsulation, and process the unselected called functions at the same time, and ensure the completeness of the encapsulated component functions through piling; single function encapsulation option, for leaf node functions or specifically selected child node functions, supports direct encapsulation as a single function module, and processes the unselected called functions under it to ensure that the encapsulated single function module can be used independently.

[0026] Furthermore, in step 3, a function interface parameter type analysis module is provided, which is used to perform static analysis on the imported function module embedded source code to identify and classify the parameter type of each function, mark the parameters as array class parameters, structure class parameters, pointer class parameters and single variable class parameters, and pass the marked functions to the next stage for parameter encapsulation.

[0027] Furthermore, step 3 is also provided with a parameter encapsulation module, which performs encapsulation processing on the classified parameters, including encapsulation of array class parameters, structure class parameters, pointer class parameters and single variable class parameters, so that the original array parameters in the function body are converted into actual parameters, and a type parameter passing interface corresponding to the encapsulation structure is added above the function body to realize the application of different interfaces.

[0028] Furthermore, in step 4, in the encapsulation of the underlying hardware control class functions, characteristic identifiers are added to the underlying hardware control class functions, and the type, characteristics and attribute information of the underlying hardware are encapsulated so that targeted selection and configuration can be performed based on this information in the low-code development environment; in the encapsulation of the data processing algorithm class functions, characteristic identifiers are added to the data processing algorithm class functions, and the data input port and data output port are identified in detail, and standardized data input and output interfaces are designed to ensure the versatility and ease of use of the algorithm functions; in the encapsulation of the data interaction communication class functions, characteristic identifiers are added to the data interaction communication class functions, and a universal and configurable multi-port data interaction interface is designed to support flexible transit and transmission of data while ensuring the stability and scalability of the interface.

[0029] Furthermore, in step 6, the standardized component data communication interface mounting includes an incentive module, a trigger function module and a data pool module; the incentive module, as the trigger source of data communication, is responsible for starting the data sending and receiving process; the trigger function module defines a specific data communication interface to realize the real data transmission between two or more components; the data pool module, as a data center, stores the real entity of all input and output interaction data, realizes lightweight data transmission through the interaction of pointer addresses, and is responsible for data writing, deletion, modification and search operations to ensure the efficiency and accuracy of data interaction.

[0030] The beneficial effects of the present invention are:

[0031] (1) Improve the convenience and adaptability of transformation: Through low-code transformation without changing the original code, componentization is achieved by using standardized framework encapsulation, which significantly improves the convenience of code transformation and the system's adaptability to new requirements.

[0032] (2) Expand the functional scope of components: break through the limitations of single functions, realize unified encapsulation of function-related function sets, and improve the reusability and integrity of components.

[0033] (3) Standardized packaging process: Provide standardized packaging methods and processes for embedded software, especially optimize embedded C language code to ensure the standardization, compatibility and portability of components.

[0034] (4) Comprehensive coverage and diversified solutions: Covering a variety of embedded code types, providing a variety of function interface component transformation solutions to meet different development needs.

[0035] (5) Efficient data transmission path: An innovative bus path model is proposed to achieve efficient and reliable data transmission between components, thereby improving system integration and response speed. BRIEF DESCRIPTION OF THE DRAWINGS

[0036] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative labor.

[0037] Figure 1 A schematic diagram of the encapsulation process in the low-code standardized component development method based on embedded software of the present invention;

[0038] Figure 2 It is a flow chart of function encapsulation screening in the low-code standardized component development method based on embedded software of the present invention;

[0039] Figure 3 A schematic diagram of a leaf node function selected to enter a single function module library to be encapsulated in the function call relationship tree diagram of the present invention;

[0040] Figure 4 A schematic diagram of a parent node or child node function selected to enter a module library of a set of functions to be encapsulated in the function call relationship tree diagram of the present invention;

[0041] Figure 5 A schematic diagram of a parent node or child node function selected to enter a module library of a set of functions to be encapsulated in the function call relationship tree diagram of the present invention;

[0042] Figure 6 A schematic diagram of a parent node or child node function selected to enter a single function module library to be encapsulated in the function call relationship tree diagram of the present invention;

[0043] Figure 7 A schematic diagram of the function interface encapsulation of the present invention;

[0044] Figure 8 It is a schematic diagram of the execution steps of the function interface parameter type analysis module of the present invention;

[0045] Fig. 9 It is a schematic diagram of the execution of the function interface parameter type analysis module of the present invention on the code;

[0046] Fig.10 It is a schematic diagram of the execution of the parameter encapsulation module of the present invention in code;

[0047] Fig.11A schematic diagram of the selection and encapsulation of the functional framework type of the underlying hardware control class function in the present invention;

[0048] Fig.12 A schematic diagram of the type selection and encapsulation of the functional framework of the data processing algorithm class function in the present invention;

[0049] Fig.13 A schematic diagram of the encapsulation of the functional framework type selection of the data interactive communication class function in the present invention;

[0050] Fig.14 It is a schematic diagram of the integrated packaging of the universal structural framework of the standardized components in the present invention;

[0051] Fig.15 A schematic diagram of mounting a standardized component data communication interface in the present invention;

[0052] Fig.16 It is a structural diagram of the data pool module in the present invention;

[0053] Fig.17 This is a schematic diagram of the storage of standardized components in the present invention. DETAILED DESCRIPTION

[0054] In order to make the technical problems, technical solutions and beneficial effects to be solved by the present invention more clearly understood, the present invention is further described in detail below in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present invention and are not intended to limit the present invention.

[0055] The present invention proposes a low-code standardized component development method based on embedded software. The method does not require any editing and modification of the original embedded code itself, but through peripheral encapsulation, each function in the embedded software is carefully classified, linked and technically encapsulated according to specific formats and framework requirements. This process includes collecting and analyzing source code, classifying and screening functions, designing encapsulation frameworks and interface specifications, writing encapsulation codes, performing functional testing and verification, and storing and managing the encapsulated standardized components. In the end, these components not only retain the functional integrity of the original code, but also have a high degree of versatility and reusability, can be directly integrated into the low-code development platform, and can be easily called and used. This method significantly improves the development efficiency and quality of embedded software in a low-code environment, reduces development costs and maintenance difficulties, and opens up a new path for the deep integration of embedded software and low-code technology.

[0056] The schematic flow diagram of the method of the present invention is as follows Figure 1 The execution steps are as follows:

[0057] Step 1: Collect and filter embedded source code and key functions.

[0058] Step 1.1, prepare the source code of the embedded code: The source code of the embedded software written in C / C++ language needs to be collected comprehensively and carefully. This includes but is not limited to all .c, .cpp source files, and the associated .h, .hpp header files. In addition, you should also ensure that all necessary library files are obtained, whether static or dynamic, which are essential for the correct compilation and operation of the source code. At the same time, you also need to check the integrity of the source code to ensure that no key files or components are missing.

[0059] Step 1.2, prepare the source code of each function of the embedded software to be encapsulated: On the basis of clarifying the project requirements and encapsulation goals, it is necessary to screen out the source code of the functions that will be encapsulated as standardized components from the huge source code library. This process requires an in-depth understanding of the source code, and the ability to accurately identify which functions have high reuse value, can run independently, and are of practical significance to the low-code development platform. Subsequently, the source code of these functions is extracted separately to prepare for subsequent encapsulation work. During the preparation process, these functions should also be preliminarily classified and organized to facilitate subsequent classification links and technical encapsulation.

[0060] Step 2: Refine the function screening and packaging strategy construction.

[0061] Function encapsulation and screening is a key step in the transformation of embedded software to low-code development. It aims to extract the functional functions required in the future low-code development environment from the complex embedded source code and encapsulate them into standardized components. This process is not only about the selection of functions, but also involves an in-depth understanding and reconstruction of the calling relationship between functions.

[0062] Function encapsulation screening mainly focuses on two types of functions: completely independent function modules and function groups that need to be encapsulated collectively. Completely independent function modules, as leaf node functions, do not depend on any other function modules and can be used independently after encapsulation, such as simple mathematical operations, status checks, etc. The function group that is encapsulated collectively revolves around a top-level function, which completes a specific functional task by calling a series of sub-functions. When encapsulating, it is necessary to ensure that this group of functions is integrated as a whole to maintain the integrity and correctness of the function. Figure 2 As shown:

[0063] (1) Function analysis module: This module is responsible for importing the embedded source code into the system and constructing a tree diagram of the calling relationship between functions through static analysis or dynamic execution. This diagram clearly shows the location of each function in the code (leaf node, child node, parent node, etc.), providing an intuitive basis for subsequent function selection. Through this step, the key functions in the code and the dependencies between them can be quickly located.

[0064] (2) Function selection module: Based on the call relationship tree diagram generated by the function analysis module, the function selection stage begins. In this stage, functions with potential reuse value need to be manually selected for encapsulation based on the needs and goals of low-code development. Functions may appear as parent nodes, child nodes, or leaf nodes in the call relationship tree.

[0065] For leaf node functions, due to their independence, they can be directly encapsulated as a single function module. This is because leaf node functions will not call any other functions and will only be called by other functions. Figure 3 As shown, the gray functions are selected to enter the single function module library to be encapsulated.

[0066] For parent node or child node functions, it means that other functions may be called in the current function body. In this case, three choices need to be made in the current function selection module. Depending on the specific situation, the entire function set can be encapsulated, or only some key functions can be encapsulated and the unencapsulated functions can be stubbed to ensure that the encapsulated components can run normally.

[0067] The first option is to select all the called functions in the subsequent call tree with the current function as the root node. This group of selected functions becomes a set of functions to be encapsulated as a complete whole and enters the function library, such as Figure 4 As shown, the gray functions represent the functions that are selected to enter the module library of the function set to be encapsulated.

[0068] The second option is to use the current function as the root node to select the functions that need to be encapsulated synchronously from the subsequently called functions. These selected functions are added to the function library as a function set, but not all leaf nodes are added. This will cause some of the child node functions added to the encapsulated function set to have called functions that are not added to the function set. In this case, these called functions need to be stubbed, such as Figure 5 As shown, the gray functions are selected to enter the set of functions to be encapsulated.

[0069] The third option is to select only a certain child node function, but other functions called in this function are not selected, that is, a certain child node function is entered into the single function module library as a single function to be encapsulated. In this case, there are also called functions that are not added to the function set, and these called functions need to be stubbed, such as Figure 6 As shown, the grey function represents the selected single function.

[0070] (3) Store the functions to be encapsulated into the library module: After careful selection, the functions to be encapsulated are stored in the corresponding function library according to their types. Single function modules enter the single function module library, while function collections enter the function collection module library. This step not only provides clear classification and organization for subsequent encapsulation work, but also builds a rich component resource library for the future low-code development environment.

[0071] Step 3: Refine the function interface encapsulation and parameter type adaptation.

[0072] In this key step, the focus is on carefully classifying and encapsulating each function parameter that needs to be encapsulated in the embedded code. Function parameters of embedded code usually include four categories: array parameters, structure parameters, pointer parameters, and single variable parameters. In order to ensure the flexibility and adaptability of the function interface in different application scenarios, a targeted code encapsulation strategy must be adopted according to the specific type of each actual parameter.

[0073] like Figure 7 As shown, the composition of the function interface encapsulation can be divided into two core modules:

[0074] (1) Function interface parameter type analysis module (such as Figure 8-9 ): This module is responsible for in-depth static code analysis of the source code of the imported embedded function modules. At this stage, the system or tool will review the formal parameters of each function one by one, and accurately classify and mark them through intelligent algorithms. The formal parameters will be clearly distinguished into array type parameters, structure type parameters, pointer type parameters and single variable type parameters. This process ensures the accuracy and efficiency of subsequent encapsulation work. After the parameter marking is completed, the function with detailed parameter information will be passed to the next processing stage, that is, the parameter encapsulation stage.

[0075] (2) Parameter encapsulation module: In this module, specific encapsulation operations are performed on arrays, structures, pointers, and single-variable class parameters that have been classified and marked. For array class parameters, a structure may be designed to encapsulate the size of the array and the pointer to the array data to ensure the safe transmission and access of the array data within and outside the function. For structure class parameters, if the structure definition is clear and reasonable, the pointer or copy of the structure can usually be passed directly in the interface. The encapsulation of pointer class parameters requires special care to avoid problems such as memory leaks and wild pointers, which may include adding checks on the validity of the pointer or using advanced features such as smart pointers. The encapsulation of single-variable class parameters is relatively simple, but it is also necessary to pay attention to factors such as data type, value range, and whether type conversion is required. After the encapsulation is completed, the array parameters in the original function body will be replaced by the encapsulated actual parameters, and a parameter passing interface corresponding to the encapsulated structure will be added above the function body (such as Fig.10As shown), so that upper-layer applications can clearly understand and use these interfaces.

[0076] Step 4: Refine the selection and packaging of functional framework.

[0077] In the process of software development, in order to improve the reusability, maintainability and scalability of the code, the function framework is selected and encapsulated. The core of this step is to add adaptive interfaces to different function types to achieve more flexible and efficient code application.

[0078] Specifically, three main types of functional frameworks are distinguished for selection and packaging: underlying hardware control, data processing algorithm, and data interactive communication.

[0079] For low-level hardware control functions, such as Fig.11 As shown, since they interact directly with hardware devices, the complexity and diversity of the underlying interactions need to be considered when encapsulating. The present invention adds feature identifiers to clearly identify the identity of such functions, and encapsulates key information such as the type, characteristics, and properties of the underlying hardware. In this way, in the subsequent low-code development process, developers can directly call and selectively select appropriate underlying hardware control functions based on these encapsulation information, greatly simplifying the complexity of interacting with the hardware.

[0080] For data processing algorithm functions, such as Fig.12 As shown, since it is mainly oriented to data processing tasks, it is relatively simple and direct to encapsulate. The present invention also adds characteristic identifiers to identify the algorithm characteristics of such functions. The focus of encapsulation is to clarify the data input port and the data output port to ensure that the algorithm can receive the correct input data and output the processing results. Through such encapsulation, data processing algorithm functions can be easily integrated and interacted with other system components.

[0081] For data interaction communication functions, such as Fig.13 As shown, they mainly undertake the task of data transfer and are the bridge for communication between different components in the system. When encapsulating such functions, special attention is paid to versatility and configurability. The present invention designs a universal multi-port data interaction interface and supports the configuration of multiple communication protocols. In this way, no matter between which components the data needs to be transmitted, a flexible and efficient solution can be provided. At the same time, the present invention also adds characteristic identifiers to identify the interaction characteristics of such functions, which is convenient for developers to quickly identify and select when using them. The function of this type of function is similar to that of an algorithmic function, but there is no complex data processing algorithm. It only reorganizes the input data and then outputs it, and the focus is also on identifying the data input port and the data output port.

[0082] Step 5: Integrate the standardized component framework to achieve unified management and calling. Fig.14 shown.

[0083] In this critical stage, we focus on building a unified and standardized structural framework for all functions that need to be encapsulated. The core goal of this step is to integrate various functions with different interfaces and types into a standardized external structure, thereby forming reusable standard components. These standard components can be uniformly managed and called in the embedded software low-code development environment, greatly improving development efficiency and software maintainability.

[0084] Specifically, the process of integrating and encapsulating the universal structural framework of standardized components involves tightly binding the scattered independent data structures and their definition codes previously formed through interface encapsulation and functional framework selection encapsulation with the original functions. In this process, the present invention designs a unified structural framework containing metadata such as component identification, version information, and dependencies to ensure that each component can be clearly identified, managed, and maintained. At the same time, the present invention focuses on the extensibility design of the framework to ensure that it can flexibly respond to possible new functions or optimization requirements in the future.

[0085] Through this step, the originally scattered encapsulation codes are integrated into a large function body and its corresponding declaration header file, forming a complete encapsulation module. This integrated encapsulation method not only simplifies the function calling and management process, but also improves the readability and maintainability of the code. In the low-code development process of embedded software, developers can easily reference and call these standard components, thereby achieving rapid development and efficient iteration.

[0086] Step 6: Build a unified communication platform to achieve efficient interconnection between functions. Figure 15-16 shown.

[0087] The core goal of this step is to add a set of standard data communication interfaces for all encapsulated functions to build an efficient and flexible data interaction network. These interfaces not only include key encapsulation information such as trigger signals, trigger action associations, and data transfer classes, but also ensure seamless interaction and interconnection between all functions.

[0088] Specifically, during the mounting process of the standardized component data communication interface, the present invention equips each function with a unified communication interface. These interfaces follow established specifications and standards, making the data transfer between functions safe and efficient. The trigger signal, as the starting point of data communication, is responsible for activating the data exchange process at the appropriate time; and the trigger action association defines which operations should be performed to respond to the signal when a specific signal is received, including data reading, processing and sending. In addition, the data transfer class is responsible for encapsulating the specific format and transmission protocol of the data to ensure the integrity and accuracy of the data during the transmission process.

[0089] In order to achieve this goal, the present invention designs three main modules: an excitation module, a trigger function module and a data pool module. As a trigger of data communication, the excitation module is responsible for monitoring and responding to various trigger signals, thereby starting the data communication process. The trigger function module specifically implements the interactive logic of data communication. It performs operations such as reading, processing and sending data according to the trigger signal and the associated action to ensure that the data is correctly transmitted between components. The data pool module, as a data center, is responsible for storing and managing the real entity of all input and output interactive data. It provides functions such as writing, deleting, changing and searching data, and realizes lightweight data interaction through the interaction of pointer addresses, thereby reducing the overhead of data transmission.

[0090] Through the implementation of this step, a unified and efficient data communication platform was successfully built for all encapsulated functions. This not only makes data exchange between functions simpler and faster, but also provides strong support for embedded low-code development. Developers can focus more on the implementation and innovation of business logic without paying too much attention to the underlying data communication details. At the same time, this platform also has good scalability and maintainability, and can easily cope with possible new functions or optimization needs in the future.

[0091] Step 7: Automate labeling and classification to build an efficient and searchable standardized component library.

[0092] As the final link in the embedded code source zero-modification standard component packaging process, the standardized component storage bears the heavy responsibility of organizing, labeling and classifying the various packaged components. The core goal of this step is to build a component library that is easy to search and efficiently call to support rapid response and flexible deployment in the embedded low-code development process.

[0093] Specifically, during the process of standardized component storage, the system will first automatically extract key information from the rich data accumulated in the previous packaging steps, without the need for manual labeling one by one. This process covers multiple dimensions:

[0094] (1) Module type identification: Based on the results of the function encapsulation screening step, the system automatically determines whether the current component is a single function module or a function collection module, and accurately writes this attribute in the form of a label in the standard component information annotation column to be stored. This label provides developers with an intuitive understanding of the scale and complexity of the component.

[0095] (2) Functional classification: Next, the system goes into the details of the functional framework selection and packaging steps to clarify the functional positioning of each component - whether it is the underlying hardware control function, data processing algorithm function or data interaction communication function, it will be accurately classified and added as an important label to the component information annotation column. This step ensures the clear division and efficient retrieval of the component library at the functional level.

[0096] (3) Retention of original information: In order to maintain the traceability and integrity of the component, the system will also copy the original encapsulated function name and its corresponding function annotation directly to the component information annotation column. This approach not only provides developers with a convenient way to gain an in-depth understanding of the original characteristics of the component, but also lays a solid foundation for subsequent maintenance and upgrade work.

[0097] (4) Manual index supplement: In addition to the label information automatically extracted by the system, space is also reserved for manually adding index information such as keywords. This allows developers or administrators to add more descriptive words or professional terms in specific fields to components according to actual needs, further improving the recognition and search efficiency of components in the library.

[0098] During embedded software development, this patent allows various common embedded software source codes to be packaged into standard components. These packaged embedded standard components can be used as call data sets for the embedded low-code development platform and are the core of the embedded low-code development platform. When embedded developers develop new projects, they can directly use these standard components on the embedded low-code platform to develop embedded code by dragging and dropping. When embedded developers make functional changes to existing low-code developed embedded projects, they can directly replace these packaged standard components to achieve rapid adaptation, development and generation of embedded code. Therefore, this patent provides an implementation method for embedded low-code development, and also provides a feasible solution for the implementation of low-code development in the embedded software direction.

[0099] The beneficial effects of the present invention are:

[0100] (1) Significantly improve the convenience and adaptability of code transformation: By innovatively proposing a low-code transformation method that does not directly modify the original code, the present invention uses the method of encapsulating a standardized framework to achieve component-based transformation of the original code. This method not only avoids the destruction of the code structure in the traditional transformation process, but also greatly improves the convenience of the transformation process, allowing developers to respond to software upgrades and maintenance needs more quickly and flexibly. At the same time, the generation of standardized components enhances the adaptability of the system and facilitates the expansion and integration of future functions.

[0101] (2) Expanding the functional scope of components and improving reusability: This invention breaks through the limitation that the previous standardized component transformation is limited to a single function, and realizes the unified packaging and transformation of a set of functionally related functions to generate components with more complete functions and higher reusability. This innovation not only improves the practicality of components, but also promotes modular design in the software development process, reducing the complexity and maintenance cost of the system.

[0102] (3) Implementing standardized encapsulation of embedded software code: In the field of embedded software development, the present invention provides a set of specialized standardized function encapsulation methods and processes, especially optimized for embedded C language code. Through standardized encapsulation operations, the generated components conform to the unified interface standards, have good compatibility and portability, and provide strong support for the development and integration of embedded software.

[0103] (4) Comprehensive coverage of embedded code types and provision of diversified transformation solutions: The transformation solutions designed by the present invention not only cover various types of function interfaces such as arrays, structures, pointers, and single variable classes, but also provide standardized component transformation methods for a wide range of embedded code types such as underlying hardware control, data processing algorithms, and data interactive communication. This comprehensive coverage capability ensures the wide applicability of the present invention in the development of various embedded systems.

[0104] (5) Build an efficient data transmission channel and improve system integration: In the process of standardized component transformation and packaging, the present invention proposes a novel bus channel model as a communication interface mounting method for the data transmission channel between components. This model defines a unified communication protocol and data exchange format, realizes efficient and reliable data transmission between components, and improves the system integration and response speed. This innovation provides a strong guarantee for building complex and high-performance embedded systems.

[0105] The above are only preferred embodiments of the present invention and are not intended to limit the present invention. Any modifications, equivalent substitutions and improvements made within the spirit and principles of the present invention should be included in the protection scope of the present invention.

Claims

1. A low-code standardized component development method based on embedded software, characterized in that: include: Step 1: Collect the complete embedded software source code and identify the functions or functional modules to be encapsulated; Step 2: Function encapsulation screening, identifying and encapsulating independent functions and interdependent aggregate functions; Step 3: Function interface encapsulation: design a unified interface template according to the function parameter type to achieve interface standardization; Step 4: Functional framework selection and encapsulation. Design the corresponding encapsulation framework according to the function type, including the underlying hardware control class, data processing algorithm class and data interactive communication class; Step 5: Integrate and encapsulate the universal structural framework of standardized components, design a unified external structural framework and ensure its scalability; Step 6: Standardize the data communication interface of the component, design a standard data communication interface and verify its stability; Step 7: Standardize component storage, add labels and classification information to the packaged components, and establish a component library management system for unified management.

2. The low-code standardized component development method based on embedded software according to claim 1, characterized in that: In the step 2, for the aggregate function encapsulation, the dependency relationship between the top-level function and its sub-functions is deeply analyzed to ensure that the encapsulated components will not fail to function due to missing dependencies when used independently.

3. The low-code standardized component development method based on embedded software according to claim 1, characterized in that: In step 3, an error handling mechanism is designed for each encapsulated function interface to capture and handle exceptions or errors that may occur during the function call process.

4. The low-code standardized component development method based on embedded software according to claim 1, characterized in that: In step 5, metadata extension fields are reserved in the unified structure framework to support new attributes or functions that may be added in the future.

5. The low-code standardized component development method based on embedded software according to claim 1, characterized in that: The step 2 is provided with: a function analysis module, which is used to import the embedded software source code, analyze the function call relationship, and generate a tree diagram of the function call relationship to clarify the position of each function in the code and its status as a parent node, child node or leaf node; The function selection module manually selects functions to be encapsulated based on the tree diagram generated by the function analysis module. This module supports the selection of leaf node functions, parent node functions or child node functions, and allows users to choose the entire function set or specific child functions as the objects to be encapsulated according to their needs.

6. The low-code standardized component development method based on embedded software according to claim 5, characterized in that: In the function selection module, it further includes: collection encapsulation, which allows users to choose to encapsulate the complete set of all called functions with the current function as the root node, or only select some necessary functions for encapsulation, and process the unselected called functions at the same time, and ensure the complete functionality of the encapsulated component through piling; single function encapsulation option, for leaf node functions or specifically selected child node functions, supports direct encapsulation as a single function module, and processes the unselected called functions under it to ensure that the encapsulated single function module can be used independently.

7. The low-code standardized component development method based on embedded software according to claim 1, characterized in that: In step 3, a function interface parameter type analysis module is set up, which is used to perform static analysis on the imported function module embedded source code to identify and classify the parameter type of each function, mark the parameters as array type parameters, structure type parameters, pointer type parameters and single variable type parameters, and pass the marked functions to the next stage for parameter encapsulation.

8. The low-code standardized component development method based on embedded software according to claim 7, characterized in that: The step 3 is also provided with a parameter encapsulation module, which performs encapsulation processing on the classified parameters, including encapsulation of array type parameters, structure type parameters, pointer type parameters and single variable type parameters, so that the original array parameters in the function body are converted into actual parameters, and a type parameter passing interface corresponding to the encapsulation structure is added above the function body to realize the application of different interfaces.

9. The low-code standardized component development method based on embedded software according to claim 1, characterized in that: In the step 4, in the encapsulation of the underlying hardware control class function, a characteristic identifier is added to the underlying hardware control class function, and the type, characteristics and attribute information of the underlying hardware are encapsulated, so that targeted selection and configuration can be performed based on this information in the low-code development environment; in the encapsulation of the data processing algorithm class function, a characteristic identifier is added to the data processing algorithm class function, and the data input port and the data output port are identified, and a standardized data input and output interface is designed to ensure the versatility and ease of use of the algorithm function; In the data interaction communication function encapsulation, feature identifiers are added to the data interaction communication function, and a universal and configurable multi-port data interaction interface is designed to support flexible transfer and transmission of data while ensuring the stability and scalability of the interface.

10. The low-code standardized component development method based on embedded software according to claim 1, characterized in that: In step 6, the standardized component data communication interface mounting includes an excitation module, a trigger function module and a data pool module; the excitation module is responsible for starting the data transmission and receiving process as a trigger source of data communication; the trigger function module defines a specific data communication interface to realize the real data transmission between two or more components; The data pool module serves as a data center, storing the real entity of all input and output interaction data, realizing lightweight data transmission through the interaction of pointer addresses, and is responsible for data writing, deletion, modification and search operations to ensure the efficiency and accuracy of data interaction.

Images