Method for generating rear-end software module of automatic driving application graphical developer

Abstract

The invention relates to the technical field of automatic driving, and discloses a method and device for generating a rear-end software module of an automatic driving application graphical developer, and the method comprises the steps: receiving the selection operation of a user in N components in front-end automatic driving, and each component corresponds to a software function in automatic driving; m target codes and the incidence relation among the M target codes are determined according to the selection operation, each target code corresponds to one target assembly, the M target assemblies are used for executing a target task in automatic driving, each target assembly is one of the N assemblies, M is smaller than or equal to N, and M and N are positive integers; based on the incidence relation, determining algorithm logic among the M target codes; and combining the M target codes according to the algorithm logic to generate a software module for executing the target task.

Description

Technical Field

[0001] The present invention relates to the field of autonomous driving technology, and in particular to a method for generating a back-end software module of an autonomous driving application graphical developer. Background Art

[0002] At present, autonomous driving technology is driving the development of automotive electronic architecture from traditional control systems to integrated and intelligent ones. The domain controller of autonomous driving consists of high-performance SoC (System on a Chip) and MCU (Microcontroller Unit). SoC handles computationally intensive tasks, while MCU is responsible for real-time control tasks. The software architecture is divided into system software layer and functional software layer, covering core tasks such as perception, data fusion, prediction, planning and control. The existing development method of autonomous driving system relies on stand-alone development platform, which has high requirements on computer hardware performance and low development efficiency. Summary of the invention

[0003] In view of this, the present invention provides a method, device, computer equipment, and storage medium for generating a back-end software module of a graphical developer for an autonomous driving application, so as to solve the problem of how to develop a back-end software module of a graphical developer for an autonomous driving application.

[0004] In a first aspect, the present invention provides a method for generating a backend software module of an autonomous driving application graphical developer, the method comprising:

[0005] Receiving a user's selection operation among N components in the front-end autonomous driving, each of the above components corresponding to a software function in the autonomous driving;

[0006] According to the above selection operation, M target codes and association relationships between the M target codes are determined, wherein each of the above target codes corresponds to a target component, the above M target components are used to perform target tasks in autonomous driving, and each of the above target components is one of the above N components, M≤N, and M and N are positive integers;

[0007] Based on the above association relationship, determine the algorithm logic between the above M target codes;

[0008] According to the above algorithm logic, the above M target codes are combined to generate a software module for executing the above target tasks.

[0009] In an optional implementation, the determining of the M target codes and the association relationship between the M target codes according to the selection operation includes:

[0010] Analyze the above selection operation to obtain the above M target components and the association relationship between the above M target components;

[0011] According to at least M first preset mapping relationships between the M target components and the M target codes, searching for M target codes corresponding to the M target components;

[0012] According to the at least M first mapping relationships, the M target codes, and the association relationship among the M target components, the association relationship among the M target codes is determined.

[0013] In an optional implementation, the algorithm logic between the M target codes is determined based on the association relationship, including:

[0014] Obtaining input and output parameters and / or functions of each of the M target codes;

[0015] Based on the association information between the above-mentioned M target codes, as well as the input and output parameters and / or functions of the above-mentioned M target codes, it is determined that the substitution relationship between the input and output parameters of the above-mentioned M target codes is the above-mentioned algorithm logic, and / or the calling relationship between the functions of the above-mentioned M target codes is the above-mentioned algorithm logic.

[0016] In an optional implementation, after combining the M target codes according to the algorithm logic to generate a software module for performing the target task, the method further includes:

[0017] Receiving domain controller information sent by the front end, the domain controller information indicating configuration parameters of the domain controller executing the software module;

[0018] Generate a configuration file of the domain controller according to the domain controller information, wherein the configuration file includes the configuration parameters;

[0019] Generate a compiled file of the software module, and install the compiled file and the configuration file to the domain controller, which is used to execute the target task.

[0020] In an optional implementation, before the above-mentioned receiving the user's selection operation among the N components in the front-end autonomous driving, it also includes:

[0021] Obtaining N codes and a second mapping relationship between input and output parameters and / or functions and multiple keywords;

[0022] Extract at least one first keyword from the N codes;

[0023] Determine input and output parameter information and / or function information of the N codes according to the second mapping relationship and the at least one first keyword;

[0024] Based on the input and output parameter information and / or function information of the above N codes, N components are generated, and the above N components are displayed on the above front end.

[0025] In an optional implementation, before the above-mentioned obtaining of N codes, the method further includes:

[0026] In a second operating system, using a container tool, a plurality of container images of different types of compilation environments are generated, and the second operating system is used to run the software module;

[0027] Add the above container images to multiple containers respectively, and export the above containers, adding one container image to each container;

[0028] Running the second operating system in the first operating system through the compatibility layer;

[0029] The plurality of containers are run on the second operating system so that the plurality of containers process tasks of the backend server.

[0030] In an optional implementation, after determining the input and output parameters and / or functions of the N codes according to the second mapping relationship and the at least one first keyword, the method further includes:

[0031] Using a parsing tool, analyzing the input and output parameters and / or functions of the N codes to obtain actual analysis results of each of the codes;

[0032] If the expected analysis result is the same as the actual analysis result of each of the above codes, the code whose actual analysis result is the same as the expected analysis result is determined to be a qualified code.

[0033] In a second aspect, the present invention provides a device for generating a backend software module of a graphical developer for an autonomous driving application, the device comprising:

[0034] A receiving module, used to receive a user's selection operation among N components in the front-end autonomous driving, each of which corresponds to a software function in the autonomous driving;

[0035] A first determination module is used to determine, according to the above selection operation, M target codes and the association relationship between the M target codes, wherein each of the above target codes corresponds to a target component, the above M target components are used to perform a target task in the autonomous driving, and each of the above target components is one of the above N components, M≤N, and M and N are positive integers;

[0036] A second determination module is used to determine the algorithm logic between the M target codes based on the association relationship;

[0037] A generation module is used to combine the above M target codes according to the above algorithm logic to generate a software module for executing the above target task.

[0038] In a third aspect, the present invention provides a computer device, comprising: a memory and a processor, the memory and the processor being communicatively connected to each other, the memory storing computer instructions, and the processor executing the computer instructions to execute the method for generating a back-end software module of a graphical developer for an autonomous driving application according to the first aspect or any corresponding embodiment thereof.

[0039] In a fourth aspect, the present invention provides a computer-readable storage medium having computer instructions stored thereon, the computer instructions being used to enable a computer to execute a method for generating a back-end software module of a graphical developer for an autonomous driving application according to the first aspect or any corresponding embodiment thereof.

[0040] In a fifth aspect, the present invention provides a computer program product, comprising computer instructions, which are used to enable a computer to execute the method for generating a back-end software module of a graphical developer for autonomous driving applications according to the first aspect or any corresponding embodiment thereof.

[0041] The embodiment provided by the present invention has the following effects: by determining the target code according to the user's selection operation on multiple components in the autonomous driving system at the front end, and generating the corresponding algorithm logic according to the association relationship between different components. The generated software module is customized according to specific needs, which can better meet the needs of different autonomous driving scenarios. The target component is determined by the user's selection operation, and the association relationship between M target codes and the combination of algorithm logic make the back-end software module of the autonomous driving application graphical developer highly flexible. By combining the target code, the software module related to the target task is automatically generated, avoiding the cumbersome process of traditional manual writing of complex codes, reducing development costs and time, and improving development efficiency. By determining the algorithm logic between the target codes based on the association relationship, different components can be more independent when performing tasks, thereby reducing the coupling degree within the system. This design helps to improve the maintainability and scalability of the back-end of the application graphical developer. Through the component selection mechanism of the graphical developer, various software modules in the autonomous driving system can be flexibly and intuitively configured to ensure that users can accurately select the required components, and determine the operation logic between the target codes through the association relationship between the codes, avoiding conflicts or inconsistencies between the codes, and reducing the potential safety hazards of the autonomous driving system. By combining M target codes and determining the corresponding algorithm logic based on the association relationship, the generated target module is ensured to have an efficient execution path and the lowest latency. In the subsequent process of calling the software module, it can efficiently process real-time sensor data, achieve rapid response and decision-making, and ensure the real-time operation capability of the autonomous driving system in complex traffic environments. In addition, the user's selection operations on multiple components in the autonomous driving system are obtained at the front end, and other complex processing is deployed on the back-end server, which can reduce the requirements for computer hardware performance during the development process. BRIEF DESCRIPTION OF THE DRAWINGS

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

[0043] Figure 1 is a schematic diagram of a generation platform of a backend software module of an autonomous driving application graphical developer according to an embodiment of the present invention;

[0044] Figure 2 is one of the flow charts of a method for generating a backend software module of a graphical developer of an autonomous driving application according to an embodiment of the present invention;

[0045] Figure 3is a second flowchart of a method for generating a backend software module of an autonomous driving application graphical developer according to an embodiment of the present invention;

[0046] Figure 4 is a schematic diagram of a device for generating a backend software module of a graphical developer of an autonomous driving application according to an embodiment of the present invention;

[0047] Figure 5 It is a schematic diagram of the hardware structure of a computer device according to an embodiment of the present invention. DETAILED DESCRIPTION

[0048] In order to make the purpose, technical solution and advantages of the embodiments of the present invention clearer, the technical solution in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative work are within the scope of protection of the present invention.

[0049] According to an embodiment of the present invention, an embodiment of a method for generating a back-end software module of a graphical developer for an autonomous driving application is provided. It should be noted that the steps shown in the flowchart of the accompanying drawings can be executed in a computer system such as a set of computer executable instructions, and although a logical order is shown in the flowchart, in some cases, the steps shown or described may be executed in an order different from that shown here.

[0050] Figure 1 is a schematic diagram of a generation platform of a backend software module of an autonomous driving application graphical developer according to an embodiment of the present invention, such as Figure 1 As shown, the platform includes: a front end and a back end.

[0051] The platform can be a graphical developer for supporting users in developing autonomous driving systems. The graphical developer displays graphical codes, i.e., components, to developers, responds to the developer's dragging and connecting operations on components, and combines multiple components to form tasks in the autonomous driving system, such as autonomous driving tasks on highways, vehicle following tasks, etc. The graphical developer can display existing codes to developers in the form of components, so that developers can use the written codes to develop autonomous driving systems, thereby improving code reuse and development efficiency of autonomous driving systems.

[0052] The front end can be a client of a graphical developer with a user interface, which is used to display multiple components (component 1, component 2, component 3) to the user (developer) and collect the user's selection operations on multiple components. The front end can also be a command line interface based on the HTTP client. The user interacts with the back-end server through the command line tool and communicates with the back end through the local Socket (an interface used for communication in computer networks) to transmit RESTAPI (Representational State Transfer Application Programming Interface). The front end can also be a browser end, which exchanges data with the back end through RESTAPI.

[0053] The backend can be a server based on the web application architecture, and a Docker container (a lightweight, portable, encapsulated operating environment) in a Linux environment (a second operating system) in a Windows operating system (a first operating system) through WSL (Windows Subsystem for Linux, a compatibility layer), for example, container 1, container 2, container 3. Each container is used to perform service tasks such as scanning, verification, and compilation of the backend code.

[0054] In this embodiment, a method for generating a backend software module of an autonomous driving application graphical developer is provided, which can be used for the above-mentioned backend server. Figure 2 is one of the flow charts of a method for generating a backend software module of an autonomous driving application graphical developer according to an embodiment of the present invention, such as Figure 2 As shown, the method includes:

[0055] Step S201, receiving the user's selection operation among N components in the front-end autonomous driving.

[0056] Each component corresponds to a software function in autonomous driving. Each component can correspond to different software functions in autonomous driving, such as distance acquisition, brake control, image recognition, radar scanning, navigation, etc. The codes corresponding to these software functions can be purchased from third-party developers. Therefore, the front end can also display the universally unique identifier (UUID, Universally Unique Identifier) ​​of each component, the name of the component, the classification information (such as mathematics, physics, perception, etc.), input and output messages or parameter types, versions, developer information, etc.

[0057] One receiving method is: the front end collects the user's dragging and connecting operations on the components in the operation interface, and describes the dragging and connecting operations as a configuration file including the connection relationship of the components, the upper and lower inclusion relationship of the components, and the parameter configuration of the components in the model, and sends it to the back end.

[0058] Step S202: Determine M target codes and the association relationship between the M target codes according to the selection operation.

[0059] Among them, each target code corresponds to a target component, M target components are used to perform the target task in autonomous driving, and each target component is one of N components, M≤N, M and N are positive integers. The target code is the partial code selected from the N components of the front end corresponding to the user's selection operation to perform the user's target task. The association relationship is the connection relationship, inclusion relationship, call relationship, etc. between different target codes.

[0060] One way to determine this is to determine, based on the selection operation, which target code provides input data, which target code processes the input data, and outputs the result; or to define the execution order of each component based on its function and requirements, for example, the execution order of the target code for executing sensor data reception is before the pointing order of the target code for executing obstacle detection.

[0061] S203, based on the association relationship, determine the algorithm logic between the M target codes.

[0062] Among them, the algorithm logic can be the substitution relationship between parameters, the calling relationship between functions, etc.

[0063] One way to determine is to determine the input and output data formats, transmission methods and synchronization requirements of each target code, define the execution order between the target codes, and trigger the execution based on specific conditions, and use the output parameters of the target code that provides input data as input parameters for processing the input data.

[0064] Step S204, combining M target codes according to the algorithm logic to generate a software module for executing the target task.

[0065] Among them, the software module can be a complete independent software that can be developed and run on the autonomous driving system to perform specific autonomous driving tasks, such as autonomous driving, vehicle following and other tasks.

[0066] One generation method is: according to a determined algorithm logic, the target code is combined in a specific order and connection relationship logical relationship to obtain a complete software code as a software module for executing the target task.

[0067] The present invention provides a method for detecting code vulnerabilities, which determines the target code according to the user's selection operation on multiple components in the autonomous driving system at the front end, and generates corresponding algorithm logic according to the association relationship between different components. The generated software module is customized according to specific needs, which can better meet the needs of different autonomous driving scenarios. The target component is determined by the user's selection operation, and the association relationship between M target codes and the combination of algorithm logic make the back-end software module of the autonomous driving application graphical developer highly flexible. By combining the target code, the software module related to the target task is automatically generated, which avoids the cumbersome process of traditional manual writing of complex codes, reduces development costs and time, and improves development efficiency. By determining the algorithm logic between the target codes based on the association relationship, different components can be more independent when performing tasks, thereby reducing the coupling degree within the system. This design helps to improve the maintainability and extensibility of the back-end of the application graphical developer. Through the component selection mechanism of the graphical developer, various software modules in the autonomous driving system can be flexibly and intuitively configured to ensure that the user can accurately select the required components, and determine the operation logic between the target codes through the association relationship between the codes, avoid conflicts or inconsistencies between the codes, and reduce potential safety hazards of the autonomous driving system. By combining M target codes and determining the corresponding algorithm logic based on the association relationship, the generated target module is ensured to have an efficient execution path and the lowest latency. In the subsequent process of calling the software module, it can efficiently process real-time sensor data, achieve rapid response and decision-making, and ensure the real-time operation capability of the autonomous driving system in complex traffic environments. In addition, the user's selection operations on multiple components in the autonomous driving system are obtained at the front end, and other complex processing is deployed on the back-end server, which can reduce the requirements for computer hardware performance during the development process.

[0068] In an optional implementation, in order to further determine the association relationship between the target code and the target code, Figure 3 This is a second flowchart of a method for generating a backend software module of an autonomous driving application graphical developer according to an embodiment of the present invention, step S202 comprising:

[0069] Step S301, parse the selection operation to obtain M target components and the association relationship between the M target components.

[0070] The M target components, i.e., the components corresponding to the M target codes, are selected from the N components through a selection operation. The association relationship of the M target components may be a connection relationship or a containment relationship between the components.

[0071] One way of parsing is to parse the selection operations from the design or configuration phase, identify M target components, and the association relationship between the target components may involve data flow, interface definition, functional dependency, etc. For example, for an autonomous driving system, the target components may include a sensor receiving module, a path planning module, an obstacle detection module, etc. The path planning module may depend on sensor data, while the speed control module may depend on the result of path planning.

[0072] Step S302: searching for M target codes corresponding to the M target components according to at least M first mapping relationships between the preset M target components and the M target codes.

[0073] Each target component corresponds to a section of executable code, namely, the target code. Therefore, based on the first mapping relationship between the target component and the target code, M target codes can be found from multiple codes in the code library.

[0074] Step S303, determining the association relationship between the M target codes according to the association relationship between at least M first mapping relationships, the M target codes, and the M target components.

[0075] Among them, the association relationship between the M target codes can be a substitution relationship between parameters, a calling relationship between functions, a data flow relationship, etc.

[0076] One way to determine is: based on the first mapping relationship, the association relationship between the target code and the target component, the autonomous driving system can automatically infer the calling order, interface call, data flow, etc. between the target codes.

[0077] The method provided in this embodiment can effectively optimize the software development process by clarifying the association relationship of components in the design stage and automatically finding and generating target codes through mapping relationships, especially in the development of large-scale, modular, and complex systems (such as autonomous driving systems), which can improve development efficiency, system maintainability, and scalability, while reducing errors and improving code consistency. This automated generation and association process is one of the important technologies in modern software development, and is particularly suitable for application scenarios that require high modularity and high security requirements.

[0078] In an optional implementation, in order to further determine the algorithm logic, step S203 includes: obtaining the input and output parameters and / or functions of each of the M target codes. According to the association information between the M target codes, and the input and output parameters and / or functions of the M target codes, it is determined that the substitution relationship between the input and output parameters of the M target codes is the algorithm logic, and / or the calling relationship between the functions of the M target codes is the algorithm logic.

[0079] In this embodiment, the input parameter refers to the data or information required by the code segment, and the output parameter is the result generated after the code segment is executed. The target code of a path planning module may have input parameters, such as sensor data, target position, etc., and the output parameter may be a calculated path or navigation instruction. The substitution relationship between input and output parameters refers to that between different target codes, a certain input parameter or output parameter may be interchangeable or replaceable under certain conditions. For example, between different path planning algorithms, the input target position or sensor data may have different representations or processing methods, but they can still be regarded as inputs with the same function. Determine the function call relationship between different target codes. These algorithm logics indicate that the output of one target code is the input of another target code, or that one code segment depends on the function execution result of another code segment. Based on these calling relationships, the entire application graphical developer backend algorithm logic can be constructed, such as controlling the application graphical developer backend signal flow, data flow and functional dependency.

[0080] The method provided in this embodiment further clarifies the entire backend algorithm logic of the graphical application developer by analyzing the input and output parameters and the calling relationship between functions in the M target codes. It improves the flexibility and adaptability of the algorithm logic, and can automatically adjust the parameters and function calling relationship to meet system requirements; it promotes code reuse and modularization, and improves development efficiency; it enhances the scalability and maintainability of the backend of the graphical application developer, so that the system can easily adapt to the addition of new functions; through automated analysis and derivation, it reduces development, debugging and maintenance costs.

[0081] In an optional implementation, in order to further use or test the software module, after step S204, it further includes: receiving domain controller information sent by the front end, the domain controller information indicating the configuration parameters of the domain controller (DC) executing the software module. According to the domain controller information, a configuration file of the domain controller is generated, the configuration file includes the configuration parameters. A compiled file of the software module is generated, and the compiled file and the configuration file are installed to the domain controller, and the domain controller is used to execute the target task.

[0082] In this embodiment, the domain controller of the autonomous driving system is a core component in the autonomous driving vehicle, which is used to centrally process and manage various electronic control units and sensor data of the vehicle. These domain controller information may come from the front-end part of the back-end of the application graphical developer. The front-end part passes the current configuration parameters of the domain controller to the back-end processing unit through interaction with the hardware device. According to the received domain controller information, the system will generate a configuration file for the domain controller. The configuration file contains all the necessary parameters related to the domain controller to ensure that the domain controller can correctly execute the software module. After the configuration file is generated, the system will generate the corresponding compiled file based on the analyzed target code and algorithm logic. This is the process of converting the software module from source code to machine code that can be executed on hardware. After receiving the configuration file and the compiled file, the domain controller will set the hardware resources according to the parameters in the configuration file, load and execute the code in the compiled file to achieve the execution of the target task.

[0083] The method provided in this embodiment can ensure the compatibility between the software module and the hardware platform (domain controller) by generating and installing the configuration file of the domain controller. The program executed on the hardware platform must be closely coordinated with the hardware resources. By generating the configuration file according to the specific information of the domain controller, the resource allocation of the hardware can be optimized so that the software module can run under the optimal conditions. The process of automatically generating the configuration file and compiling the file and installing it to the domain controller greatly simplifies the deployment process of the software module.

[0084] In an optional implementation, in order to further provide multiple components to the front end, before step S201, it also includes: obtaining N codes, and a second mapping relationship between input and output parameters and / or functions and multiple keywords. Extracting at least one first keyword from the above N codes. Determining the input and output parameter information and / or function information of the above N codes based on the above second mapping relationship and the above at least one first keyword. Generating N components based on the input and output parameter information and / or function information of the above N codes, and displaying the above N components on the above front end.

[0085] In this embodiment, the mapping relationship between the input and output parameters and / or functions of these codes and multiple keywords is obtained. These keywords may represent the function, category, type or other characteristics of the code. From the above N codes, the system will extract at least one first keyword, which is used to identify the core function or feature of the code. The mapping relationship can be used to infer the related input and output parameters, function names and functions from the first keyword. These components represent multiple functional modules, and each component can be displayed as an independent unit in the front-end interface. Each component displays the relevant input and output parameters and functional information so that the user can understand its role and perform selection operations.

[0086] The method provided in this embodiment obtains multiple codes and generates multiple components, so that the system modularizes different functions, thereby realizing efficient combination and management of functions. Multiple functional modules are displayed as components on the front-end interface, and users can directly interact with these components, select required functions and perform corresponding operations. Through the use of the second mapping relationship, the system can intelligently identify the input and output parameters and function information of the code, and convert this information into easy-to-understand components to display to the user.

[0087] In an optional embodiment, before obtaining the N codes, it also includes: in the second operating system, using the container tool to generate multiple container images of different types of compilation environments, and the second operating system is used to run the software module. Add the multiple container images to multiple containers respectively, and export the multiple containers, adding one container image to each container. Run the second operating system through the compatibility layer in the first operating system. Run the multiple containers in the second operating system so that the multiple containers can process the tasks of the back-end server.

[0088] In this embodiment, in the second operating system, a container tool (such as Docker or other containerization tools) is used to generate multiple container images for different programming languages, dependent libraries or operating environments. These container images contain the compilation environment and dependencies required to run the software modules. These container images will be added to multiple containers respectively, and each container corresponds to an image. The role of the container is to isolate the environment when different software modules are running, so that different modules can run in a relatively independent environment without interfering with each other. Export multiple containers, each container will contain a specific compilation environment and the required runtime dependencies. Run multiple containers on the second operating system, and each container will handle different tasks of the back-end server. Containers can share different computing tasks, data processing tasks, or request response tasks, thereby improving the back-end concurrent processing capabilities of the back-end application graphical developer.

[0089] The method provided in this embodiment enables the second operating system and the container to run compatibly between different operating systems by running a compatibility layer in the first operating system. It can break through the limitations of the back-end of the operating application graphical developer, achieve cross-platform support, and improve the flexibility and compatibility of the back-end of the application graphical developer. Container technology enables each functional module to run independently in different environments, and developers can freely combine containers for deployment and expansion as needed. Containerized management helps to achieve rapid deployment, upgrades, and recovery, thereby improving the scalability and maintainability of the back-end of the application graphical developer. Running multiple containers in the second operating system can make full use of resources and perform efficient task scheduling. Containerization technology can help assign tasks to different containers, and the independence and lightness of containers make task processing more efficient.

[0090] Furthermore, in order to adapt to cloud deployment, the backend server supports multi-user asynchronous parallel request tasks. After the user requests, the task configuration is sent to the message queue and a task status query link is returned. The task executor obtains the task from the message queue, executes it, and saves the task progress to the storage system. The task scheduler monitors the queue and executor status, allocates tasks according to the capabilities of the executor (such as CPU, disk, network, etc.), ensures load balancing, and reasonably allocates tasks according to the task type (such as compute-intensive or input-output intensive). Users can get task status updates regularly through the task query link.

[0091] In an optional implementation, after determining the input and output parameters and / or functions of the N codes according to the second mapping relationship and the at least one first keyword, the method further includes: using a parsing tool to analyze the input and output parameters and / or functions of the N codes to obtain an actual analysis result of each of the codes. If the expected analysis result is the same as the actual analysis result of each of the codes, the code whose actual analysis result is the same as the expected analysis result is determined to be a qualified code.

[0092] In this embodiment, the system first determines the input and output parameters and / or functions of N codes related to the task based on the second mapping relationship and at least one first keyword. Use a parsing tool to perform a detailed analysis of the input and output parameters and / or functions of these N codes to obtain the actual analysis results of each code. Parse the various parameters, input and output relationships and function calls in the code to extract useful execution information. The system has a preset expected analysis result, which is a result set in advance based on the description of task requirements, functions and goals. The system compares the actual analysis results of each code with the expected analysis results to confirm whether the actual execution meets expectations. If the actual analysis results of a code are consistent with the expected analysis results, the code is considered to be qualified code. That is, the code can perform tasks according to the expected logic, function or performance, meeting the design requirements.

[0093] The method provided in this embodiment can effectively screen out qualified codes that meet the expected functions and performance requirements by comparing the actual analysis results with the expected analysis results. Automated verification of code functions is achieved, avoiding errors and omissions in manual inspections. The use of parsing tools can quickly analyze a large amount of code and make accurate comparisons, thereby improving efficiency. By analyzing input and output parameters and functions, the system can gain an in-depth understanding of the actual behavior of the code and ensure that the code can be executed according to the predetermined goals, thereby improving the accuracy of the back-end execution of the entire application graphical developer. By setting the expected analysis results in advance, the system can detect potential logical problems or functional errors before the code is executed, reducing the probability of erroneous code in the production environment.

[0094] The present invention provides a device for generating a backend software module of an autonomous driving application graphical developer. Figure 4 1 is a schematic diagram of a device for generating a backend software module of a graphical developer of an autonomous driving application according to an embodiment of the present invention, wherein the device comprises:

[0095] The receiving module 401 is used to receive the user's selection operation among N components in the front-end autonomous driving, and each of the above components corresponds to a software function in the autonomous driving.

[0096] The first determination module 402 is used to determine M target codes and the association relationship between the M target codes according to the above selection operation, wherein each of the above target codes corresponds to a target component, the above M target components are used to perform target tasks in autonomous driving, and each of the above target components is one of the above N components, M≤N, and M and N are positive integers.

[0097] The second determination module 403 is used to determine the algorithm logic between the M target codes based on the association relationship.

[0098] The generation module 404 is used to combine the M target codes according to the algorithm logic to generate a software module for executing the target task.

[0099] The present invention provides a code vulnerability detection device, which determines the target code according to the user's selection operation on multiple components in the autonomous driving system at the front end, and generates corresponding algorithm logic according to the association relationship between different components. The generated software module is customized according to specific needs, which can better meet the needs of different autonomous driving scenarios. The target component is determined by the user's selection operation, and the association relationship between M target codes and the combination of algorithm logic make the back-end software module of the autonomous driving application graphical developer highly flexible. By combining the target code, the software module related to the target task is automatically generated, which avoids the cumbersome process of traditional manual writing of complex code, reduces development cost and time, and improves development efficiency. By determining the algorithm logic between the target codes based on the association relationship, different components can be more independent when performing tasks, thereby reducing the coupling degree within the system. This design helps to improve the maintainability and extensibility of the back-end of the application graphical developer. Through the component selection mechanism of the graphical developer, various software modules in the autonomous driving system can be flexibly and intuitively configured to ensure that users can accurately select the required components, and determine the operation logic between the target codes through the association relationship between the codes, avoid conflicts or inconsistencies between the codes, and reduce potential safety hazards of the autonomous driving system. By combining M target codes and determining the corresponding algorithm logic based on the association relationship, the generated target module is ensured to have an efficient execution path and the lowest latency. In the subsequent process of calling the software module, it can efficiently process real-time sensor data, achieve rapid response and decision-making, and ensure the real-time operation capability of the autonomous driving system in complex traffic environments. In addition, the user's selection operations on multiple components in the autonomous driving system are obtained at the front end, and other complex processing is deployed on the back-end server, which can reduce the requirements for computer hardware performance during the development process.

[0100] The further functional description of each of the above modules and units is the same as that of the above corresponding embodiments and will not be repeated here.

[0101] The generation device of the back-end software module of the autonomous driving application graphical developer in this embodiment is presented in the form of a functional unit, where the unit refers to an ASIC (Application Specific Integrated Circuit) circuit, a processor and memory that executes one or more software or fixed programs, and / or other devices that can provide the above-mentioned functions.

[0102] The embodiment of the present invention also provides a computer device having the above Figure 4The device for generating the back-end software module of the graphical developer of the autonomous driving application is shown.

[0103] See also Figure 5 , Figure 5 is a schematic diagram of the structure of a computer device provided by an optional embodiment of the present invention, such as Figure 5 As shown, the computer device includes: one or more processors 10, a memory 20, and interfaces for connecting various components, including high-speed interfaces and low-speed interfaces. Various components are connected to each other using different buses for communication, and can be installed on a common mainboard or installed in other ways as needed. The processor can process the instructions executed in the computer device, including instructions stored in or on the memory to display the graphical information of the GUI on an external input / output device (such as, a display device coupled to the interface). In some optional embodiments, if necessary, multiple processors and / or multiple buses can be used together with multiple memories and multiple memories. Similarly, multiple computer devices can be connected, and each device provides some necessary operations (for example, as a server array, a group of blade servers, or a multi-processor system). Figure 5 A processor 10 is taken as an example.

[0104] The processor 10 may be a central processing unit, a network processor or a combination thereof. The processor 10 may further include an integrated circuit. The integrated circuit may be a dedicated integrated circuit, a programmable logic device or a combination thereof. The programmable logic device may be a complex programmable logic device, a field programmable gate array, a general purpose array logic or any combination thereof.

[0105] The memory 20 stores instructions executable by at least one processor 10, so that the at least one processor 10 executes the method shown in the above embodiment.

[0106] The memory 20 may include a program storage area and a data storage area, wherein the program storage area may store an operating system, an application required for at least one function; the data storage area may store data created according to the use of the computer device, etc. In addition, the memory 20 may include a high-speed random access memory, and may also include a non-transient memory, such as at least one disk storage device, a flash memory device, or other non-transient solid-state storage device. In some optional embodiments, the memory 20 may optionally include a memory remotely arranged relative to the processor 10, and these remote memories may be connected to the computer device via a network. Examples of the above-mentioned network include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and combinations thereof.

[0107] The memory 20 may include a volatile memory, such as a random access memory; the memory may also include a non-volatile memory, such as a flash memory, a hard disk or a solid state drive; the memory 20 may also include a combination of the above types of memory.

[0108] The computer device further comprises a communication interface 30 for the computer device to communicate with other devices or a communication network.

[0109] The embodiment of the present invention also provides a computer-readable storage medium. The method according to the embodiment of the present invention can be implemented in hardware, firmware, or can be implemented as a computer code that can be recorded in a storage medium, or can be implemented as a computer code that is originally stored in a remote storage medium or a non-temporary machine-readable storage medium and will be stored in a local storage medium through a network download, so that the method described herein can be stored in such software processing on a storage medium using a general-purpose computer, a dedicated processor, or programmable or dedicated hardware. Among them, the storage medium can be a magnetic disk, an optical disk, a read-only storage memory, a random access memory, a flash memory, a hard disk or a solid-state hard disk, etc.; further, the storage medium can also include a combination of the above types of memories. It can be understood that a computer, a processor, a microprocessor controller, or programmable hardware includes a storage component that can store or receive software or computer code. When the software or computer code is accessed and executed by a computer, a processor, or hardware, the method shown in the above embodiment is implemented.

[0110] A part of the present invention may be applied as a computer program product, such as a computer program instruction, which, when executed by a computer, can call or provide the method and / or technical solution according to the present invention through the operation of the computer. Those skilled in the art should understand that the existence of the computer program instruction in a computer-readable medium includes, but is not limited to, a source file, an executable file, an installation package file, etc., and accordingly, the way in which the computer program instruction is executed by the computer includes, but is not limited to: the computer directly executes the instruction, or the computer compiles the instruction and then executes the corresponding compiled program, or the computer reads and executes the instruction, or the computer reads and installs the instruction and then executes the corresponding installed program. Here, the computer-readable medium may be any available computer-readable storage medium or communication medium accessible to the computer.

[0111] Although the embodiments of the present invention have been described in conjunction with the accompanying drawings, those skilled in the art may make various modifications and variations without departing from the spirit and scope of the present invention, and such modifications and variations are all within the scope defined by the appended claims.

Claims

1. A method for generating a backend software module of an autonomous driving application graphical developer, characterized in that: The method comprises: Receiving a selection operation of a user among N components in the front-end autonomous driving, each of the components corresponding to a software function in the autonomous driving; According to the selection operation, determine M target codes and associations between the M target codes, wherein each of the target codes corresponds to a target component, the M target components are used to perform a target task in autonomous driving, and each of the target components is one of the N components, M≤N, and M and N are positive integers; Based on the association relationship, determining the algorithm logic between the M target codes; According to the algorithm logic, the M target codes are combined to generate a software module for executing the target task.

2. The method according to claim 1, characterized in that Determining the M target codes and the association relationship between the M target codes according to the selection operation includes: Parsing the selection operation to obtain the M target components and association relationships among the M target components; According to at least M preset first mapping relationships between the M target components and the M target codes, searching for M target codes corresponding to the M target components; According to the at least M first mapping relationships, the M target codes, and the association relationship among the M target components, an association relationship among the M target codes is determined.

3. The method according to claim 1, characterized in that The step of determining the algorithm logic between the M target codes based on the association relationship includes: Obtaining input and output parameters and / or functions of each of the M target codes; Based on the association information between the M target codes, and the input and output parameters and / or functions of the M target codes, it is determined that the substitution relationship between the input and output parameters of the M target codes is the algorithm logic, and / or the calling relationship between the functions of the M target codes is the algorithm logic.

4. The method according to any one of claims 1 to 3, characterized in that: After combining the M target codes according to the algorithm logic to generate a software module for executing the target task, the method further includes: Receiving domain controller information sent by the front end, the domain controller information indicating configuration parameters of the domain controller that executes the software module; Generate a configuration file of the domain controller according to the domain controller information, wherein the configuration file includes the configuration parameters; Generate a compiled file of the software module, and install the compiled file and the configuration file to the domain controller, where the domain controller is used to execute the target task.

5. The method according to any one of claims 1 to 3, characterized in that: Before receiving the user's selection operation among the N components in the front-end autonomous driving, the method further includes: Obtaining N codes and a second mapping relationship between input and output parameters and / or functions and multiple keywords; Extracting at least one first keyword from the N codes; Determine input and output parameter information and / or function information of the N codes according to the second mapping relationship and the at least one first keyword; Based on the input and output parameter information and / or function information of the N codes, N components are generated, and the N components are displayed on the front end.

6. The method according to claim 5, characterized in that Before obtaining N codes, the method further includes: In a second operating system, using a container tool, a plurality of container images of different types of compilation environments are generated, and the second operating system is used to run the software module; Adding the plurality of container images to a plurality of containers respectively, and exporting the plurality of containers, adding one container image to each container; Running the second operating system in the first operating system through the compatibility layer; The plurality of containers are run on the second operating system so that the plurality of containers process tasks of the backend server.

7. The method according to claim 5, characterized in that After determining the input and output parameters and / or functions of the N codes according to the second mapping relationship and the at least one first keyword, the method further includes: Analyze the input and output parameters and / or functions of the N codes using a parsing tool to obtain an actual analysis result of each of the codes; If the expected analysis result is the same as the actual analysis result of each of the codes, the code whose actual analysis result is the same as the expected analysis result is determined to be a qualified code.

8. A device for generating a backend software module of an autonomous driving application graphical developer, characterized in that: The device comprises: A receiving module, used to receive a user's selection operation among N components in the front-end autonomous driving, each of which corresponds to a software function in the autonomous driving; A first determination module is used to determine, according to the selection operation, M target codes and an association relationship between the M target codes, wherein each of the target codes corresponds to a target component, the M target components are used to perform a target task in the autonomous driving, and each of the target components is one of the N components, M≤N, and M and N are positive integers; A second determination module, used to determine the algorithm logic between the M target codes based on the association relationship; A generation module is used to combine the M target codes according to the algorithm logic to generate a software module for executing the target task.

9. A computer device, characterized in that: include: A memory and a processor, wherein the memory and the processor are communicatively connected to each other, the memory stores computer instructions, and the processor executes the method for generating a back-end software module of a graphical developer for autonomous driving applications according to any one of claims 1 to 7 by executing the computer instructions.

10. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores computer instructions, and the computer instructions are used to enable a computer to execute the method for generating a back-end software module of an autonomous driving application graphical developer according to any one of claims 1 to 7.

Images