Domain controller software integration method and device, computer equipment and vehicle

Abstract

The invention provides a domain controller software integration method and device, computer equipment and a vehicle, and belongs to the technical field of vehicles, and the method comprises the following steps: generating a software integration configuration file of a domain controller based on an upstream software integration demand; loading an application compressed file corresponding to the domain controller into a standardized integrated compiling folder of the domain controller based on the software integrated configuration file; and in combination with the software integration configuration file and the standardized integration compiling folder, executing an automatic integration compiling script of the domain controller to generate a software package of the domain controller. By adopting the method, the integration efficiency of the vehicle domain controller software can be improved, and errors caused by tedious operation of a traditional manual integration mode are avoided.

Description

Technical Field

[0001] This application relates to the field of vehicle technology. In particular, it relates to a method, apparatus, computer equipment, and vehicle for integrating domain controller software. Background Technology

[0002] In the electronic and electrical architecture of vehicles, with the requirements of intelligent driving technology and the speed and rate of vehicle communication data response, domain control schemes are gradually replacing the original distributed controller structure. The integration of controllers has also changed from the integration of single controller systems to the integration of domain controller software.

[0003] Domain controller integration involves the simultaneous integration of controller software. Furthermore, for different core software on the controller, there are integration requirements that, after successful single-core integration, require software merging and consolidation. Each controller and core is configured with different functional applications. If the integration of each controller and core is done manually by downloading applications and then merging or consolidating them based on the flashing packages, it is not only cumbersome but also prone to errors. Summary of the Invention

[0004] This application provides a method, apparatus, computer device, and vehicle for integrating domain controller software, aiming to improve the integration efficiency of vehicle domain controller software and avoid errors caused by the cumbersome operation of traditional manual integration methods.

[0005] To achieve the above objectives, a first aspect of this application provides a method for integrating domain controller software, the method comprising: The software integration configuration file for the domain controller is generated based on the upstream software integration requirements; Based on the software integration configuration file, the application compressed file corresponding to the domain controller is loaded into the standardized integration compilation folder of the domain controller; Combining the software integration configuration file and the standardized integration compilation folder, the automatic integration compilation script of the domain controller is executed to generate the software package for the domain controller.

[0006] In some embodiments, after generating the domain controller's software integration configuration file based on upstream software integration requirements, the method further includes: The domain controllers to be merged in the domain controllers are determined based on the standard information in the software integration configuration file. Copy the software package of the domain controller to be merged to the integration operation folder.

[0007] In some embodiments, after generating the domain controller's software integration configuration file based on upstream software integration requirements, the method further includes: The domain controllers to be integrated in the domain controllers are determined based on the standard information in the software integration configuration file. Load the flash file corresponding to the domain controller to be integrated into the integration operation folder; The integration operation script is automatically executed based on the integration operation folder to perform the integration operation and generate the integration flash file and the integration version release file.

[0008] In some embodiments, the upstream software integration requirements include software package integration requirements with different parameters; The software integration configuration file for generating the domain controller based on upstream software integration requirements includes: Based on the different software package integration requirements, the application keyword software definition sub-version configuration column is used to generate different versions of the integrated software package.

[0009] In some embodiments, loading the application compressed file corresponding to the domain controller into the standardized integration compilation folder of the domain controller based on the software integration configuration file includes: Based on the integration unit keywords of the domain controller in the software integration configuration file, each integration unit in the domain controller is determined; Automatically load the application compressed files of the specified version number of each integration unit into the standardized integration compilation folder of the domain controller.

[0010] In some embodiments, the step of combining the software integration configuration file and the standardized integration compilation folder to execute the automatic integration compilation script of the domain controller to generate the software package for the domain controller includes: According to the definition of the software integration configuration file, the automatic integration compilation script of the domain controller is executed sequentially; the automatic integration compilation script is used to generate software packages with corresponding names and version numbers according to the standardized integration compilation folder, and load the software packages into the integration operation folder.

[0011] In some embodiments, the method further includes: Perform integration testing on the domain controller; If the integration test passes, the software package will be uploaded to the corresponding location in the artifact repository for unified version release management.

[0012] Furthermore, to achieve the above objectives, a second aspect of this application provides an integration apparatus for domain controller software, the apparatus comprising: The requirements analysis module is used to generate software integration configuration files for domain controllers based on upstream software integration requirements. The application file loading module is used to load the application compressed file corresponding to the domain controller into the standardized integration compilation folder of the domain controller based on the software integration configuration file; The script execution module is used to combine the software integration configuration file and the standardized integration compilation folder to execute the automatic integration compilation script of the domain controller to generate the software package of the domain controller.

[0013] Furthermore, to achieve the above objectives, a third aspect of the present application provides a computer device, which includes a processor, a communication interface, a memory, and a communication bus, wherein the processor, the communication interface, and the memory communicate with each other through the communication bus; Memory, used to store computer programs; When a processor executes a program stored in memory, it implements the steps of the method for integrating the domain controller software described in the first aspect above.

[0014] To achieve the above objectives, a fourth aspect of this application provides a vehicle that includes a computer device. When the processor of the computer device executes a computer program, it implements the steps of the domain controller software integration method described in the first aspect.

[0015] To achieve the above objectives, a fifth aspect of the present application provides a computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the steps of the domain controller software integration method described in the first aspect.

[0016] To achieve the above objectives, a sixth aspect of this application provides a computer program product, including a computer program that, when executed by a processor, implements the steps of the domain controller software integration method described in the first aspect.

[0017] The domain controller software integration method, apparatus, computer equipment, vehicle, computer-readable storage medium, and computer program product provided in this application embodiment generate a domain controller software integration configuration file based on upstream software integration requirements; load the application compressed file corresponding to the domain controller into the standardized integration compilation folder of the domain controller based on the software integration configuration file; and execute the domain controller's automatic integration compilation script to generate the domain controller's software package by combining the software integration configuration file and the standardized integration compilation folder.

[0018] Thus, this embodiment generates a software integration configuration file based on upstream integration requirements, then loads the application compressed file based on this configuration file. Once preparation is complete, an automatic integration compilation script is executed to automatically integrate the domain controller software, greatly improving integration efficiency and avoiding errors caused by tedious operations. Specifically, by first analyzing the integration requirements, the consistency of the integrated functions of the domain controller software is ensured, guaranteeing the effectiveness of the integrated software. For the automatic integration of applications into the domain controller, a standardized file structure is created by loading the application compressed file into a standardized integration compilation folder. This allows for the selection of individual integration for different controllers and cores, or the execution of the automatic compilation script in the configuration file sequentially to complete the final full compilation and generate the integrated flash package. Therefore, any type of integration step can be selected based on the integration requirements without affecting the final integration step, and it also serves as a reference for configuring the integration pipeline. Attached Figure Description

[0019] To more clearly illustrate the technical solutions of the embodiments of this application, the drawings used in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0020] Figure 1 A flowchart illustrating the steps of the domain controller software integration method provided in some embodiments of this application; Figure 2 for Figure 1 A detailed flowchart of step S102; Figure 3 A flowchart illustrating the steps of the domain controller software integration method provided in this application embodiment in some other embodiments; Figure 4 A flowchart illustrating the steps of the domain controller software integration method provided in some other embodiments of this application; Figure 5 A flowchart illustrating the steps of the domain controller software integration method provided in some other embodiments of this application; Figure 6 A flowchart illustrating the steps of the domain controller software integration method provided in an embodiment of this application in a complete embodiment; Figure 7 A schematic diagram of the structure of the integrated device for domain controller software provided in the embodiments of this application; Figure 8 This is a schematic diagram of the hardware structure of a computer device provided in an embodiment of this application. Detailed Implementation

[0021] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.

[0022] It should be noted that although functional modules are divided in the device schematic diagram and a logical order is shown in the flowchart, in some cases, the steps shown or described may be performed in a different order than the module division in the device or the order in the flowchart. The terms "first," "second," etc., in the specification, claims, and the aforementioned drawings are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence.

[0023] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this application belongs. The terminology used herein is for the purpose of describing embodiments of this application only and is not intended to limit this application.

[0024] First, the overall concept of the embodiments of this application will be explained.

[0025] The current mainstream automotive electronic and electrical architecture, driven by the demands of intelligent driving technology and the requirements for faster and more efficient vehicle communication data response, is gradually replacing the original distributed controller structure with domain control solutions. Consequently, controller integration has shifted from single-controller system integration to domain controller software integration. Domain controller integration involves the simultaneous integration of controller software. Furthermore, for different core software on the controller, there are integration requirements involving merging and consolidating software after successful single-core integration. Each controller and core is configured with different functional applications. If the integration of each controller and core involves manually downloading applications and then merging or consolidating them using flashing packages, the process is cumbersome and prone to errors.

[0026] To address this, this application provides a method for integrating domain controller software. This is an automatic integration method. Based on the upstream integration requirements, an integration file is configured, including the settings for each controller and core integration unit that needs to be integrated. The controllers and cores that need to be merged or integrated are also marked. After preparation, the automatic integration script is executed sequentially, which greatly improves integration efficiency and avoids errors caused by tedious operations. It also allows for the selection of any type of integration to be performed in the intermediate steps as needed, without affecting the final integration steps. It also serves as a reference for the configuration of the integration pipeline.

[0027] In this embodiment, a software integration configuration file for the domain controller is generated based on upstream software integration requirements; an application compressed file corresponding to the domain controller is loaded into the standardized integration compilation folder of the domain controller based on the software integration configuration file; and an automatic integration compilation script for the domain controller is executed to generate the software package for the domain controller, combining the software integration configuration file and the standardized integration compilation folder.

[0028] Thus, this embodiment generates a software integration configuration file based on upstream integration requirements, then loads the application compressed file based on this configuration file. Once preparation is complete, an automatic integration compilation script is executed to automatically integrate the domain controller software, greatly improving integration efficiency and avoiding errors caused by tedious operations. Specifically, by first analyzing the integration requirements, the consistency of the integrated functions of the domain controller software is ensured, guaranteeing the effectiveness of the integrated software. For the automatic integration of applications into the domain controller, a standardized file structure is created by loading the application compressed file into a standardized integration compilation folder. This allows for the selection of individual integration for different controllers and cores, or the execution of the automatic compilation script in the configuration file sequentially to complete the final full compilation and generate the integrated flash package. Therefore, any type of integration step can be selected based on the integration requirements without affecting the final integration step, and it also serves as a reference for configuring the integration pipeline.

[0029] Furthermore, in this embodiment, for integrated applications with different controllers and cores, different versions of the same application can be identified, and different versions of software with different requirements can be generated. Compared with fully automatic software integration methods, this method has greater flexibility and is more suitable for integration scenarios where applications are gradually added at different stages and the same application version is frequently tested. Different integration application keywords and versions can be configured to complete the automatic integration operation.

[0030] Based on the overall concept of the embodiments of this application described above, further specific embodiments of the domain controller software integration method, apparatus, computer equipment, vehicle, computer-readable storage medium, and computer program product provided in the embodiments of this application are proposed. First, the specific embodiments of the domain controller software integration method provided in the embodiments of this application are described.

[0031] It should be noted that the domain controller software integration method provided in this application embodiment can be applied to terminal devices configured in vehicles. It should also be understood that the domain controller software integration method provided in this application embodiment can also be applied to servers communicating with vehicles. Alternatively, the domain controller software integration method provided in this application embodiment can also be software running on the aforementioned terminal devices or servers. In some embodiments, the terminal device can be a smartphone, tablet, laptop, desktop computer, etc.; the server can be configured as an independent physical server, or as a server cluster or distributed system composed of multiple physical servers, or as a cloud server providing basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, content delivery networks (CDN), and big data and artificial intelligence platforms; the software can be an application implementing the domain controller software integration method, etc., but is not limited to the above forms.

[0032] Alternatively, this application can also be used in numerous general-purpose or special-purpose computer system environments or configurations that connect to vehicles for policy control of vehicle driving. For example, these computer system environments or configurations can be personal computers, server computers, handheld or portable devices, tablet devices, multiprocessor systems, microprocessor-based systems, set-top boxes, programmable consumer computer devices, network PCs, minicomputers, mainframe computers, distributed computing environments including any of the above systems or devices, etc. This application can be described in the general context of computer-executable instructions executed by a computer, such as program modules. Generally, program modules include routines, programs, objects, components, data structures, etc., that perform specific tasks or implement specific abstract data types.

[0033] For ease of understanding and explanation, the following text uses the integration method of the domain controller software provided in the embodiments of this application on a terminal device as an example to describe this application in detail. The implementation of the integration method of the domain controller software provided in the embodiments of this application on any other subject matter described above can refer to the process of integrating the domain controller software on a terminal device as described below.

[0034] Please refer to Figure 1 , Figure 1 The flowchart illustrates the steps of the domain controller software integration method provided in some embodiments of this application. It should be understood that, although... Figure 1 The figures illustrate the execution order of some method steps, but based on different design needs in practical applications, the domain controller software integration method provided in this application embodiment can, of course, employ a different execution order of method steps than those shown in the figures. That is, Figure 1 The order of the method steps shown does not constitute a limitation on the execution logic order of the domain controller software integration method provided in the embodiments of this application. Any other method based on... Figure 1 Reasonable changes to the sequence of steps shown should be included within the protection scope of the domain controller software integration method provided in the embodiments of this application.

[0035] like Figure 1 As shown, in some embodiments, the domain controller software integration method provided in this application may include steps S101 to S103.

[0036] Step S101: Generate the software integration configuration file for the domain controller based on the upstream software integration requirements.

[0037] When a terminal device performs an automatic integration task for domain controller software, it first conducts an integration requirements analysis based on the upstream software integration needs to ensure the consistency of integrated functions across different controllers and cores. This process involves configuring the versions of the integrated controllers and cores and generating an integration configuration file. This integration configuration file then becomes the software integration configuration file for the domain controller whose software is to be integrated.

[0038] In some embodiments, when a terminal device generates a software integration configuration file for a domain controller based on upstream software integration requirements, it can analyze the version information of the controllers, cores, underlying software, and applications involved in the integration according to the upstream integration requirements, and complete the setting of the integration file.

[0039] In some embodiments, the upstream software integration requirements include software package integration requirements with different parameters. In this case, step S101 may include the following steps: Based on the different software package integration requirements, the application keyword software definition sub-version configuration column is used to generate different versions of the integrated software package.

[0040] When terminal devices generate software integration configuration files for domain controllers based on upstream software integration requirements, the settings for the integration files can be configured by defining sub-version configuration columns for the same application keyword software (App) based on different package integration requirements. This allows for the definition of different versions of the integrated package. In this way, merging and consolidation operations corresponding to different requirements can be matched.

[0041] In some embodiments, when configuring an integration file, the terminal device may mainly perform the following steps: 1) Confirm the controllers, cores, and applications involved in the integration, and confirm the versions of the integrated software and applications; 2) To address the integration requirements of new controllers and cores, create controller and core integration groups and configure a standard file structure including the compilation environment; 3) For the changed application version, confirm whether the versions of the controllers, underlying software, and related applications that are integrated have the corresponding functions to ensure the consistency of function integration. 4) Confirmation of other integration configuration-related parameters and rules, such as diagnostic version number, application parameter integration rules, etc.; 5) For other controllers and core integration groups that remain unchanged, the integration package name and version should be consistent with the existing version; 6) Integration file settings, including the name and version number of the integration controller and core integration package, and the keywords and version numbers of the integration unit software, applications, etc.

[0042] 7) For the integration settings file, define a sub-version configuration column for the same application keyword "App" to define different versions of the integration package; 8) Mark the flash packages that need to be merged and integrated, and define the name and version number of the merged or integrated file flash package.

[0043] For example, the software integration configuration file can be shown in Table 1 below: Table 1

[0044] Step S102: Load the application compressed file corresponding to the domain controller into the standardized integration compilation folder of the domain controller based on the software integration configuration file.

[0045] After generating the software integration configuration file for the domain controller, the terminal device further loads the corresponding application compressed files for the domain controller into the corresponding controller integration folder, based on the configuration file, for subsequent automatic compilation operations. This controller integration folder is the standardized integration compilation folder for the domain controller.

[0046] In some embodiments, the terminal device can automatically load application files of specified version numbers of each integration unit into the standardized integration compilation folder of the corresponding controller or core according to the integration unit keywords, based on the software integration configuration file, for the controller or core that needs to be integrated, in preparation for subsequent automatic compilation operations.

[0047] Please refer to Figure 2 , Figure 2 for Figure 1 A detailed flowchart of step S102.

[0048] like Figure 2 As shown, in some embodiments, step S102 may include steps S201 and S202 as shown below.

[0049] Step S201: Based on the integration unit keywords of the domain controller in the software integration configuration file, determine each integration unit in the domain controller; Step S201: Automatically load the application compressed file of the specified version number of each integration unit into the standardized integration compilation folder of the domain controller.

[0050] After generating the software integration configuration file, the terminal device can first determine the integration units in the domain controller based on the integration unit keywords of the controllers and cores to be integrated recorded in the configuration file. Then, based on the integration unit keywords, it automatically loads the application compressed file with the specified version number of each integration unit into the standardized integration compilation folder of the corresponding controller and core.

[0051] It should be noted that the standard integrated compilation folder structure is consistent across all controllers and cores. For example, the structure of the standard integrated compilation folder can be shown in Table 2 below: Table 2

[0052] Step S103: Combining the software integration configuration file and the standardized integration compilation folder, execute the automatic integration compilation script of the domain controller to generate the software package of the domain controller.

[0053] After the terminal device configures the integration file according to the upstream integration requirements and loads the corresponding application compressed file into the corresponding controller integration folder to complete the preparation, it further executes the automatic integration compilation scripts of the controller and core in sequence based on the integration configuration file, thereby generating software packages with predefined names and version numbers for different controllers and cores for automatic integration of controllers and cores.

[0054] In some embodiments, when the terminal device executes the automatic integration compilation script of the controller and the core to generate the domain controller software package, it can execute the automatic integration compilation script of the controller and the core in sequence according to the definition of the software integration configuration file, thereby combining the above steps S102 to perform automatic integration of the controller and the core.

[0055] In some embodiments, step S103 may include the following steps: According to the definition of the software integration configuration file, the automatic integration compilation script of the domain controller is executed sequentially; the automatic integration compilation script is used to generate software packages with corresponding names and version numbers according to the standardized integration compilation folder, and load the software packages into the integration operation folder.

[0056] After the terminal device is ready, it can execute the automatic integration compilation scripts of the controller and core in the order defined in the software integration configuration file. Based on the execution of the automatic integration compilation scripts, the software packages with predefined names and version numbers of the controller and core are generated according to the standardized integration compilation folder, and the software packages are loaded into the integration operation folder.

[0057] In some embodiments, the steps of automatically integrating the controller and the core by the terminal device sequentially executing the automatic integration compilation script according to the definition mainly include: 1) Download the specified version number of the integrated unit file defined for the current integrated controller and core from the artifact library and automatically load it into the input folder under the controller and core folder; 2) After the integrated script is executed, it decompresses the files sequentially and records the names of all compressed files to input.txt; 3) Copy the files from each application folder (Appy) in the integration unit to the corresponding location in the underlying software (Bsw) folder; after modifying the underlying software version and other parameter configuration information, perform the compilation operation; 4) Merge the version information and changes of each integration unit in input.txt to generate release.json file; 5) After compilation, package and compress the generated flashing-related files and release.json file into a definition file, and copy it to the output folder under the controller and core folders. Based on the annotation of the merge or integration column, automatically load the compressed package into the Ota_RUN input folder for later use.

[0058] This application's embodiment generates a software integration configuration file based on upstream integration requirements, then loads application compressed files based on this configuration file. Once preparation is complete, an automatic integration compilation script is executed to automatically integrate the domain controller software, significantly improving integration efficiency and avoiding errors caused by tedious operations. Specifically, by first analyzing the integration requirements, the consistency of integrated functions of the domain controller software is ensured, guaranteeing the effectiveness of the integrated software. For the automatic integration of applications into the domain controller, a standardized file structure is created by loading application compressed files into a standardized integration compilation folder. This allows for the selection of individual integration for different controllers and cores, or the execution of the configuration file's automatic compilation script sequentially to complete the final full compilation and generate an integrated flash package. Thus, any type of integration step can be selected based on the integration requirements without affecting the final integration step, and it also serves as a reference for configuring the integration pipeline.

[0059] Please refer to Figure 3 , Figure 3The following are schematic flowcharts illustrating the steps of the domain controller software integration method provided in the embodiments of this application in other embodiments.

[0060] like Figure 3 As shown, in some embodiments, after step S103 above: combining the software integration configuration file and the standardized integration compilation folder, executing the automatic integration compilation script of the domain controller to generate the software package of the domain controller, the domain controller software integration method provided in this application embodiment may further include steps S301 and S302 as shown below.

[0061] Step S301: Determine the domain controllers to be merged in the domain controllers based on the standard information in the software integration configuration file; Step S302: Copy the software compressed package of the domain controller to be merged to the integration operation folder.

[0062] For cores requiring merged flashing, the terminal device can also automatically perform the merging operation based on the annotation information in the software integration configuration file, and copy the merged files to the integration operation folder for later use. That is, the terminal device first determines the domain controllers to be merged based on the standard information in the software integration configuration file, and then copies the software compressed package of the domain controller to be merged to the integration operation folder.

[0063] In some embodiments, the terminal device can automatically complete the merging operation for the software compressed packages of the controller and core marked for merging operation according to the following steps: 1) First, confirm that all the versions required for merging already exist in the Ota_Run folder and the input folder. If they already exist, proceed directly to step 4). 2) If a version is not found, check if the corresponding integrated package defined in the integrated compilation folder (output folder) contains the integrated package for that version. If the integrated package with the defined name and version number can be found, then the integrated package will be automatically loaded into the Ota_Run folder (input folder). 3) If the integrated package with the defined name and version number cannot be found, refer to step S30. First, perform the integration of the controller and core. For software packages that use existing versions of controllers and cores, after confirming the download path, download the correct version from the artifact library to this folder. 4) In the input folder under the Ota_RUN folder, decompress all RUN packages involved in the merge operation, and copy the corresponding hex or bin files of the compressed files to the merge environment operation folder; 5) Once all files to be merged are copied, the merge operation script will be executed automatically; 6) After the merge script is executed, the generated hex merge file will be automatically copied to the input folder under the Ota_RUN folder for later integration or separate flashing.

[0064] Please refer to Figure 4 , Figure 4 A flowchart illustrating the steps of the domain controller software integration method provided in some other embodiments of this application.

[0065] like Figure 4 As shown, in some embodiments, after step S103 above: combining the software integration configuration file and the standardized integration compilation folder, executing the automatic integration compilation script of the domain controller to generate the domain controller software package, the domain controller software integration method provided in this application embodiment may further include steps S401 to S403 as shown below.

[0066] Step S401: Determine the domain controllers to be integrated in the domain controllers based on the standard information in the software integration configuration file; Step S402: Load the flash file corresponding to the domain controller to be integrated into the integration operation folder; Step S403: Based on the integrated operation folder, automatically execute the integrated operation script to perform the integrated operation, and generate the integrated flash file and the integrated version release file.

[0067] For controllers and cores requiring integration and flashing, the terminal device can automatically load the necessary flashing files into the integration operation folder based on the annotation information in the software integration configuration file, execute the integration operation, and generate an integration flashing file and an integration version release file with the specified file names. Specifically, the terminal device first determines the domain controllers to be integrated based on the standard information in the software integration configuration file, then loads the corresponding flashing files for those domain controllers into the integration operation folder, and then automatically executes the integration operation script based on the integration operation folder to perform the integration operation and generate the integration flashing file and the integration version release file.

[0068] In some embodiments, for a RUN packet labeled with an integration operation, the terminal device can automatically complete the integration operation according to the following steps: 1) For the controller and core of the annotation integration operation, first confirm that all the versions required for integration already exist in the input folder of the Ota_Run folder. If they already exist, proceed directly to step 5). 2) For versions that are not found, confirm that the integrated package for the version defined in the integrated file is in the output folder under the corresponding integrated compilation folder. If the integrated package with the defined name and version number can be found, then the integrated package will be automatically loaded into the input folder under the Ota_Run folder. 3) If the integrated package with the defined name and version number cannot be found, refer to step S30. First, perform the integration of the controller and core. For software packages that use existing versions of controllers and cores, after confirming the download path, download the correct version from the artifact library to this folder. 4) Perform the merge operation; 5) Switch to the integration working folder, automatically decompress the package files involved in the integration, and generate an input.txt file for the names of all compressed packages that need to be merged, for use in generating the release.json file after the subsequent integration operation; 6) Unzip all package files in the input folder under the Ota_RUN folder. After completion, automatically copy the files that need to be integrated to the Ota integration work folder according to the integration requirements. 7) After the file copying is complete, the integration operation script will be executed automatically; 8) After the script is executed, an integrated flashing file package that conforms to the integrated file definition is generated. The release.json file generated in step 5) is automatically copied to the output folder under the Ota_RUN folder to complete the integration operation.

[0069] Please refer to Figure 5 , Figure 5 A flowchart illustrating the steps of the domain controller software integration method provided in some other embodiments of this application.

[0070] like Figure 5 As shown, in some embodiments, the domain controller software integration method provided in this application may further include steps S501 and S502 as described below.

[0071] Step S501: Perform integration testing on the domain controller; Step S502: If the integration test passes, upload the software package to the corresponding location in the artifact repository for unified version release management.

[0072] After automatically integrating applications for the required controllers and cores, the terminal device can further upload the defined integration software packages, merge and integration flash packages to the artifact website for unified management according to the configuration file. That is, the terminal device performs integration testing on the domain controller, such as testing the final generated software packages and merge and integration flash packages (if any). After the integration test passes, the final generated software packages and merge and integration flash packages (if any) are uploaded to the corresponding location in the artifact repository for unified version release management.

[0073] In this embodiment, a requirements analysis is first performed on the integration needs to ensure the consistency of the integrated functions of the domain controller software and the effectiveness of the integrated software. For the automatic integration of domain controller applications, this embodiment creates a standardized file structure. It allows for the selection of individual integration of different controllers and cores, or the execution of automatic compilation scripts in the configuration file sequentially to complete the final compilation and generate an integrated flash package. For integrated applications on different controllers and cores, different versions of the same application are identified, and different versions of the software can be generated to meet different requirements. Compared to fully automated software integration methods, this approach offers greater flexibility and is better suited to integration scenarios where applications gradually increase in number and the same application version is frequently tested. Different integration application keywords and versions are configured to complete the automatic integration operation. The following is a complete embodiment of the domain controller software integration method provided in this application. Based on upstream integration requirements, this embodiment performs integration configuration of the controller and core, and simultaneously configures keywords and version numbers for the integration units to generate an integration configuration file for automatic integration script execution.

[0074] like Figure 6 As shown, the technical solution adopted in this implementation is as follows: S10. Based on the upstream software integration requirements, first conduct an integration requirements analysis to ensure consistency between different controllers and integration functions; configure the versions of the integration controllers and cores, and generate integration configuration files; S20. Load the corresponding version of the application compressed file into the corresponding controller integration folder according to the integration configuration file; S30. Based on the integration configuration file, execute the automatic integration script in sequence to generate software packages with predefined names and version numbers for different controllers and cores; S40. For cores that require merged flashing files, the automatic merging operation is completed according to the annotation information in the configuration file, and the merged files are copied to the integration operation folder for later use. S50: For controllers and cores that require integrated flashing files, based on the annotation information in the configuration file, automatically load the required flashing files into the integration operation folder, perform the integration operation, and generate an integrated flashing file with the set file name and an integrated version release file. S60. According to the configuration file, upload the defined integrated software package, merged and integrated flashing package to the product website for unified management.

[0075] In this embodiment, before setting the integration file, the upstream integration requirements are analyzed to determine whether a new integration function needs to be synchronously integrated within the controller and core, ensuring consistency in function integration. For controller and core integration operations, when different software package integration requirements are involved, such as the difference between information security versions and non-information security versions, the integration settings file defines a sub-version configuration column for the same application keyword "App," generating integration software packages with different requirements, and matching the merging and integration operations corresponding to different requirement configurations. For the merging and integration operations of software flashing packages, all involved software flashing packages are uniformly loaded into the same input folder, and then compressed and loaded into the merging or integration operation folder according to the operation requirements, ensuring the standardization of the operation.

[0076] Furthermore, in this embodiment, the integration, merging, and consolidation operations of the controller and core can be performed individually or automatically with one click to execute all steps.

[0077] Furthermore, this embodiment adopts standardized worksheet definitions and execution processes, which can automate one-click operations and reduce the probability of misoperation.

[0078] Based on the same inventive concept, embodiments of this application also provide an integrated apparatus for implementing the domain controller software involved above.

[0079] The implementation scheme of the domain controller software integration device provided in this application is similar to the implementation scheme described in the various embodiments of the domain controller software integration method above. Therefore, the specific limitations of one or more domain controller software integration device embodiments provided below can be found in the limitations of the domain controller software integration method above, and will not be repeated here.

[0080] In one embodiment, such as Figure 7 As shown, the domain controller software integration device provided in this application embodiment includes: a requirements analysis module 701, an application file loading module 702, and a script execution module 703, wherein: Requirements analysis module 701 is used to generate software integration configuration files for domain controllers based on upstream software integration requirements; Application file loading module 702 is used to load the application compressed file corresponding to the domain controller into the standardized integration compilation folder of the domain controller based on the software integration configuration file; The script execution module 703 is used to combine the software integration configuration file and the standardized integration compilation folder to execute the automatic integration compilation script of the domain controller to generate the software package of the domain controller.

[0081] In some embodiments, the domain controller software integration apparatus provided in this application further includes: The automatic merging module is used to determine the domain controllers to be merged in the domain controllers based on the standard information in the software integration configuration file; and to copy the software compressed package of the domain controllers to be merged to the integration operation folder.

[0082] In some embodiments, the domain controller software integration apparatus provided in this application further includes: The automatic integration module is used to determine the domain controllers to be integrated based on the standard information in the software integration configuration file; load the flash file corresponding to the domain controller to be integrated into the integration operation folder; automatically execute the integration operation script based on the integration operation folder to perform the integration operation, and generate the integration flash file and the integration version release file.

[0083] In some embodiments, the upstream software integration requirements include software package integration requirements with different parameters; The requirements analysis module 701 is also used to configure the application keyword software definition sub-version column based on the software package integration requirements of the different parameters, so as to generate different versions of the integrated software package.

[0084] In some embodiments, the application file loading module 702 is further configured to determine each integration unit in the domain controller based on the integration unit keywords of the domain controller in the software integration configuration file; and automatically load the application compressed file of each integration unit with a specified version number into the standardized integration compilation folder of the domain controller.

[0085] In some embodiments, the script execution module 703 is further configured to execute the automatic integration compilation script of the domain controller sequentially according to the definition of the software integration configuration file; the automatic integration compilation script is configured to generate software packages with corresponding names and version numbers according to the standardized integration compilation folder, and load the software packages into the integration operation folder.

[0086] In some embodiments, the domain controller software integration apparatus provided in this application further includes: Perform integration testing on the domain controller; The software package management module is used to upload the software package to the corresponding location in the artifact repository for unified version release management after the integration test is passed.

[0087] It should be noted that the modules in the aforementioned integrated domain controller software can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in the processor of the computer device in hardware form or independent of it, or they can be stored in the memory of the computer device in software form, so that the processor can call and execute the operations corresponding to each module.

[0088] Based on the same inventive concept, this application also provides a computer device, which can be a server, and its internal structure diagram can be as follows. Figure 8 As shown, this computer device includes a processor, memory, input / output (I / O) interfaces, and a communication interface. The processor, memory, and I / O interfaces are connected via a system bus, and the communication interface is also connected to the system bus via the I / O interfaces. The processor provides computing and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system, computer programs, and a database. The internal memory provides the environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The database stores model parameters related to the liquid metal reactor. The I / O interfaces are used for exchanging information between the processor and external devices. The communication interface is used for communication with external terminals via a network connection. When executed by the processor, the computer program implements an integration method for domain controller software.

[0089] When the processor of the computer device provided in this application executes a computer program, it performs the following steps: The software integration configuration file for the domain controller is generated based on the upstream software integration requirements; Based on the software integration configuration file, the application compressed file corresponding to the domain controller is loaded into the standardized integration compilation folder of the domain controller; Combining the software integration configuration file and the standardized integration compilation folder, the automatic integration compilation script of the domain controller is executed to generate the software package for the domain controller.

[0090] In some embodiments, after executing the software integration configuration file for the domain controller based on upstream software integration requirements, the processor executing computer program further performs the following steps: The domain controllers to be merged in the domain controllers are determined based on the standard information in the software integration configuration file. Copy the software package of the domain controller to be merged to the integration operation folder.

[0091] In some embodiments, after executing the software integration configuration file for the domain controller based on upstream software integration requirements, the processor executing computer program further performs the following steps: The domain controllers to be integrated in the domain controllers are determined based on the standard information in the software integration configuration file. Load the flash file corresponding to the domain controller to be integrated into the integration operation folder; The integration operation script is automatically executed based on the integration operation folder to perform the integration operation and generate the integration flash file and the integration version release file.

[0092] In some embodiments, the upstream software integration requirements include software package integration requirements with different parameters; The software integration configuration file for generating the domain controller based on upstream software integration requirements includes: Based on the different software package integration requirements, the application keyword software definition sub-version configuration column is used to generate different versions of the integrated software package.

[0093] In some embodiments, loading the application compressed file corresponding to the domain controller into the standardized integration compilation folder of the domain controller based on the software integration configuration file includes: Based on the integration unit keywords of the domain controller in the software integration configuration file, each integration unit in the domain controller is determined; Automatically load the application compressed files of the specified version number of each integration unit into the standardized integration compilation folder of the domain controller.

[0094] In some embodiments, the step of combining the software integration configuration file and the standardized integration compilation folder to execute the automatic integration compilation script of the domain controller to generate the software package for the domain controller includes: According to the definition of the software integration configuration file, the automatic integration compilation script of the domain controller is executed sequentially; the automatic integration compilation script is used to generate software packages with corresponding names and version numbers according to the standardized integration compilation folder, and load the software packages into the integration operation folder.

[0095] In some embodiments, when a processor executes a computer program, it further performs the following steps: Perform integration testing on the domain controller; If the integration test passes, the software package will be uploaded to the corresponding location in the artifact repository for unified version release management.

[0096] Those skilled in the art will understand that Figure 8 The structure shown is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the computer device to which the present application is applied. Specific computer devices may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.

[0097] Based on the same inventive concept, this application also provides a vehicle equipped with a computer device. The steps implemented by the processor of the computer device when executing a computer program are the same as the steps implemented by the processor of the aforementioned computer device when executing a computer program. The same content will not be described again here.

[0098] Based on the same inventive concept, embodiments of this application also provide a computer-readable storage medium, including a computer program. When the computer program is executed by a processor, the steps implemented are the same as the steps implemented by the processor in the computer device described above when it executes the computer program. The same content will not be described again here.

[0099] Based on the same inventive concept, this application also provides a computer program product, including a computer program. When the computer program is executed by a processor, the steps implemented are the same as the steps implemented by the processor in the computer device when it executes the computer program. The same content will not be described again here.

[0100] Those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. Any references to memory, databases, or other media used in the embodiments provided in this application can include at least one of non-volatile and volatile memory. Non-volatile memory may include read-only memory (Read-Only Memory). Memory includes ROM, magnetic tape, floppy disk, flash memory, optical storage, high-density embedded non-volatile memory, resistive random access memory (ReRAM), magnetic random access memory (MRAM), ferroelectric random access memory (FRAM), phase change memory (PCM), graphene memory, etc. Volatile memory may include random access memory (RAM) or external cache memory, etc. By way of illustration and not limitation, RAM can be in various forms, such as static random access memory (SRAM) or dynamic random access memory (DRAM), etc. The databases involved in the embodiments provided in this application may include at least one of relational databases and non-relational databases. Non-relational databases may include distributed databases based on blockchain, etc., and are not limited thereto. The processors involved in the embodiments provided in this application may be general-purpose processors, central processing units, graphics processing units, digital signal processors, programmable logic devices, quantum computing-based data processing logic devices, etc., and are not limited thereto.

[0101] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0102] The embodiments described above are merely illustrative of several implementation methods of this application, and while the descriptions are specific and detailed, they should not be construed as limiting the scope of this patent application. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these all fall within the protection scope of this application. Therefore, the protection scope of this application should be determined by the appended claims.

Claims

1. A method of integration of domain controller software, characterized in that, The method comprises: generating a software integration configuration file of the domain controller based on upstream software integration requirements; loading application compressed files corresponding to the domain controller into a standardized integration compilation folder of the domain controller based on the software integration configuration file; executing an automatic integration compilation script of the domain controller in combination with the software integration configuration file and the standardized integration compilation folder to generate a software package of the domain controller.

2. The method of claim 1, wherein, After the generation of the software integration configuration file of the domain controller based on the upstream software integration requirements, the method further comprises: determining domain controllers to be merged in the domain controller based on standard information in the software integration configuration file; copying software compressed packages of the domain controllers to be merged to a merging operation folder.

3. The method of claim 1, wherein, After the generation of the software integration configuration file of the domain controller based on the upstream software integration requirements, the method further comprises: determining domain controllers to be integrated in the domain controller based on standard information in the software integration configuration file; loading a flashing file corresponding to the domain controllers to be integrated into a merging operation folder; automatically executing a merging operation script based on the merging operation folder to perform a merging operation and generate a merging flashing file and an integrated version release file.

4. The method of claim 1, wherein, The upstream software integration requirements comprise software package integration requirements of different parameters; The generation of the software integration configuration file of the domain controller based on the upstream software integration requirements comprises: configuring a version column of a keyword software definition based on the software package integration requirements of different parameters to generate integrated software packages of different versions.

5. The method of claim 1, wherein, The loading of the application compressed files corresponding to the domain controller into the standardized integration compilation folder of the domain controller based on the software integration configuration file comprises: determining each integration unit in the domain controller based on an integration unit keyword of the domain controller in the software integration configuration file; automatically loading application compressed files of a specified version number of each integration unit into the standardized integration compilation folder of the domain controller.

6. The method of claim 1, wherein, The execution of the automatic integration compilation script of the domain controller in combination with the software integration configuration file and the standardized integration compilation folder to generate the software package of the domain controller comprises: sequentially executing the automatic integration compilation script of the domain controller according to a definition of the software integration configuration file; the automatic integration compilation script is used to generate software packages of corresponding names and version numbers according to the standardized integration compilation folder and load the software packages into a merging operation folder.

7. The method according to any one of claims 1 to 6, characterized in that, The method further comprises: performing integration testing on the domain controller; uploading the software package to a corresponding position of a product library for unified version release management in a case where the integration testing is passed.

8. An apparatus for integration of domain controller software, the apparatus comprising: The apparatus comprises: a requirement analysis module configured to generate a software integration configuration file of a domain controller based on upstream software integration requirements; an application file loading module configured to load application compressed files corresponding to the domain controller into a standardized integration compilation folder of the domain controller based on the software integration configuration file; and an integration compiling module configured to execute an automatic integration compilation script of the domain controller in combination with the software integration configuration file and the standardized integration compilation folder to generate a software package of the domain controller. A script execution module is configured to execute an automatic integration and compilation script of the domain controller by combining the software integration configuration file and the standardized integration and compilation folder, to generate a software package of the domain controller.

9. A computer device, comprising: The device comprises a processor, a communication interface, a memory and a communication bus, wherein the processor, the communication interface and the memory communicate with each other through the communication bus; The memory is configured to store a computer program. The processor is configured to execute the program stored in the memory, and implement the steps of the integration method of the domain controller software according to any one of claims 1-7.

10. A vehicle comprising a computer device, characterized in that The processor of the computer device executes the computer program, and implements the steps of the integration method of the domain controller software according to any one of claims 1-7.

11. A computer readable storage medium having stored thereon a computer program, characterized in that, The computer program is executed by the processor, and implements the steps of the integration method of the domain controller software according to any one of claims 1-7.

12. A computer program product comprising a computer program, characterized in that, The computer program is executed by the processor, and implements the steps of the integration method of the domain controller software according to any one of claims 1-7.

Images