CN116360768A

CN116360768A - Software integration device, method, electronic equipment and storage medium

Info

Publication number: CN116360768A
Application number: CN202211722265.3A
Authority: CN
Inventors: 姜琦; 纪新宇
Original assignee: Hozon New Energy Automobile Co Ltd
Current assignee: Hozon New Energy Automobile Co Ltd
Priority date: 2022-12-30
Filing date: 2022-12-30
Publication date: 2023-06-30

Abstract

The application discloses a software integration device, a software integration method, electronic equipment and a storage medium, and relates to the technical field of software development. The device comprises: the platform library packaging unit is used for responding to the first command input of a first terminal, updating a first service file belonging to a platform part in the iteration target service, wherein the first terminal belongs to a terminal of a platform side; an external abstract interface unit, configured to provide a second service file belonging to an algorithm part in the target service; and the operation script unit is used for responding to command input of a second terminal, generating an executable file of the target service according to the algorithm source code of the target service, the first service file and the second service file, and deploying the executable file on the MCU, wherein the second terminal belongs to a terminal of an algorithm party and is used for improving the software integration efficiency.

Description

Software integration device, method, electronic equipment and storage medium

Technical Field

The present disclosure relates to the field of computer technologies, and in particular, to a software integration apparatus, a software integration method, an electronic device, and a storage medium.

Background

Along with the development of society, the development of automobile industry technology enters an intelligent express way, and the intelligent driving technology product is clearly mature in the ground. An intelligent driving vehicle is a vehicle with intelligent driving technology added on the basis of a traditional vehicle. Intelligent driving vehicles may utilize onboard sensors to sense various environmental information surrounding the vehicle, such as: lane lines, obstacles, positioning, road signs, etc.; and intelligent decision and path planning are carried out according to the road where the vehicle is located, the vehicle position and the obstacle information obtained through perception, and the transverse (steering) and longitudinal (vehicle speed) movement of the vehicle is controlled, so that the vehicle can safely and reliably automatically run on the road.

The development process of the intelligent driving vehicle comprises the development of parts and the whole vehicle. Development of intelligent driving vehicles generally includes: system design, software development, software testing, and system testing. The support of the high-order intelligent driving algorithm is realized by heterogeneous combination of a System on Chip (Soc) and a micro control unit (Microcontroller Unit; MCU) on the development architecture level, and an algorithm part with high real-time performance and safety requirements is moved to be deployed on the MCU, so that the platform software of the MCU needs to support rapid iteration and autonomous integration of the algorithm for functional rollback verification and acceleration of functional closed loop.

Currently, on MCU software stack solutions oriented to the auto sar software architecture, downstream providers deliver mostly native software development kits (Software Development Kit, SDKs) to upstream clients. As shown in fig. 1, in this architecture, the automotive embedded system software may include an application software layer (Application Software Layer, ASL), a runtime environment (Runtime Environment, RTE), a base software layer (Basic Software Layer, BSW) from top to bottom. The application layer can realize specific application functions and consists of a plurality of software components (SWCs), each SWC is equivalent to a file c, communication between the SWCs is realized through ports, and a plurality of running entities (runable) are arranged in the SWCs; RTE is used to isolate ASL and BSW; BSW can be divided into Service Layer (SL), ECU abstraction Layer, microcontroller abstraction Layer (Microcontroller Abstraction Layer, MCAL), complex device driver (Complex Device Driver, CDD), etc.

The structure shown in fig. 1 is easy to couple the platform characteristic component and the algorithm component at the application level (both are regarded as SWC from the perspective of AUTOSAR), for example, when the algorithm component is integrated and supported, the platform characteristic component also can be integrated with algorithm iteration, which results in problems of version management confusion, unstable phase delivery state, long compiling time and other engineering efficiency.

Disclosure of Invention

The application provides a software integration device which is used for improving software integration efficiency.

In a first aspect, a software integration apparatus is provided, including:

the platform library packaging unit is used for responding to the first command input of a first terminal, updating a first service file belonging to a platform part in the iteration target service, wherein the first terminal belongs to a terminal of a platform side; an external abstract interface unit, configured to provide a second service file belonging to an algorithm part in the target service; and the operation script unit is used for responding to command input of a second terminal, generating an executable file of the target service according to the algorithm source code of the target service, the first service file and the second service file, and deploying the executable file on the MCU, wherein the second terminal belongs to a terminal of an algorithm party.

In one possible implementation manner, the apparatus further includes a link script unit and a CMAKE engineering unit;

the operation script unit is specifically configured to:

copying the algorithm source code, the first service file and the second service file to a compiling path, and checking the validity of the compiling path; if the executable file is effective, calling the CMAKE engineering unit to acquire a construction rule and a compiling rule for constructing the executable file, and calling the link script unit to acquire a static link rule; and compiling the algorithm source code, the first service file and the second service file according to the construction rule, the compiling rule and the static link rule to obtain the executable file of the target service.

In one possible implementation, the validity of the compilation path is determined by an embedded compiler.

In one possible implementation, the platform library packaging unit includes a property component, an AUTOSAR support component, and middleware, an extension component;

the characteristic component is used for providing a first characteristic function for realizing the target service; the AUTOSAR supporting component and the middleware are used for providing a second characteristic function for realizing the target service; the expansion component is configured to provide a third feature function for implementing the target service.

In one possible implementation manner, when the executable file is deployed on the MCU, the operation script unit is specifically configured to: executing standard operation on the executable file to obtain a standard executable file; deploying the canonical executable file on the MCU; wherein the canonical operation includes at least one of: cyclic redundancy check, file splicing, format normalization.

In one possible implementation, the algorithm source code is generated based on an assembled code of Simulink.

In a second aspect, a software integration method is provided, applied to the apparatus as in any one of the first aspects, including:

responding to command input of a second terminal, and generating an executable file of a target service according to an algorithm source code, a first service file and a second service file of the target service; the executable file is deployed on the MCU, and the second terminal belongs to a terminal of an algorithm party; the first service file is a file belonging to a platform part in the iteration target service, and the platform library packaging unit responds to a first command input of a first terminal, wherein the first terminal belongs to a terminal of a platform side; the second file is a file which belongs to an algorithm part in the target service and is provided by the external abstract interface unit.

In one possible implementation manner, the generating the executable file of the target service according to the algorithm source code, the first service file and the second service file of the target service includes:

In a third aspect, there is provided an electronic device comprising:

a memory for storing a computer program; a processor for implementing the method steps of any of the second aspects when executing a computer program stored on the memory.

In a fourth aspect, a computer-readable storage medium is provided, in which a computer program is stored, which computer program, when being executed by a processor, carries out the method steps of any of the second aspects.

In the embodiment of the application, the constructed software integrated device comprises a platform library packaging unit, an external abstract interface unit and an operation script unit, and because the platform library packaging unit is based, a first service file belonging to a platform part in an iteration target service can be updated in response to a first command input of a first terminal; providing a second service file belonging to the algorithm part in the realization target service based on the pair of external abstract interface units; based on the operation script unit, the executable file of the target service is generated according to the algorithm source code, the first service file and the second service file of the target service in response to the command input of the second terminal; therefore, the platform part and the algorithm part are decoupled in the product software development process, the platform side and the algorithm side can independently control the development rhythm of the platform side and the algorithm side, the product software development period and the cost are reduced, and the software integration efficiency is improved.

The technical effects of each of the second to fourth aspects and the technical effects that may be achieved by each aspect are referred to above for the technical effects that may be achieved by the first aspect or each possible aspect in the first aspect, and the detailed description is not repeated here.

Drawings

FIG. 1 is an AUTOSAR software architecture diagram;

fig. 2 is a schematic view of an application scenario provided in an embodiment of the present application;

fig. 3 is a schematic structural diagram of a software integrated device according to an embodiment of the present application;

fig. 4 is a schematic structural diagram of a platform library packaging unit according to an embodiment of the present application;

fig. 5 is a schematic structural diagram of an external abstract interface unit according to an embodiment of the present application;

FIG. 6 is a flowchart of a software integration method according to an embodiment of the present application;

fig. 7 is a schematic structural diagram of an electronic device according to an embodiment of the present application.

Detailed Description

For the purpose of making the objects, technical solutions and advantages of the present application more apparent, the present application will be described in further detail with reference to the accompanying drawings. The specific method of operation in the method embodiment may also be applied to the device embodiment or the system embodiment. It should be noted that "a plurality of" is understood as "at least two" in the description of the present application. "and/or", describes an association relationship of an association object, and indicates that there may be three relationships, for example, a and/or B, and may indicate: a exists alone, A and B exist together, and B exists alone. A is connected with B, and can be represented as follows: both cases of direct connection of A and B and connection of A and B through C. In addition, in the description of the present application, the words "first," "second," and the like are used merely for distinguishing between the descriptions and not be construed as indicating or implying a relative importance or order.

For a better understanding of the embodiments of the present application, the technical terms related to the embodiments of the present application will be first described in detail below.

(1) Soc means that it is a product, an integrated circuit with special purpose, containing the complete system and having the entire contents of embedded software.

(2) The MCU is also called a single chip microcomputer (Single Chip Microcomputer) or a single chip microcomputer, which properly reduces the frequency and specification of a central processing unit (Central Process Unit; CPU), and integrates peripheral interfaces such as a memory (memory), a counter (Timer), USB, A/D conversion, UART, PLC, DMA and the like, and even LCD driving circuits on a single chip to form a chip-level computer for different application occasions to perform different combination control. Such as mobile phones, PC peripherals, remote controllers, to automotive electronics, industrial stepper motors, robotic arm control, etc., can see the shadow of the MCU.

(3) A Component (Component) is a simple package of data and methods. In C++ Builder, a component is a specific object derived from TComponent. The components may have their own properties and methods. The attribute is a simple visitor to the component data. The method is some simple and visible function of the assembly.

(4) The static link refers to that when an application program is written, if the existing functions in the running function library need to be called, a technical operator can execute corresponding operations without rewriting the functions in the function library in own source code, but only giving out the function names and required parameters.

(5) Cyclic redundancy check (Cyclic Redundancy Check, CRC) is a commonly used error checking check, characterized in that the length of the information field and the check field can be chosen arbitrarily. Cyclic Redundancy Check (CRC) is a data transmission error detection function that performs polynomial computation on data and attaches the resulting result to the back of the frame, and the receiving device also performs a similar algorithm to ensure the correctness and integrity of the data transmission.

(6) CMAkE is a cross-platform installation (compilation) tool that can describe the installation (compilation process) of all platforms in simple statements. A variety of makefile or project files can be output and c++ properties supported by the compiler can be tested, like auto make under UNIX.

(7) The functional safety (Function Safety Definition, fuSD) development kit has increasingly important significance in the software development of the current products, is a system engineering of integrated software and hardware, generally conforms to a three-layer architecture in the industry, and is also applicable to intelligent driving software products. The function realization layer and the function monitoring layer (function monitoring level) are close to the function logic, so that in the embodiment of the application, the function realization layer and the function monitoring layer are integrated into an algorithm side to realize, and the controller monitoring layer (controller monitoring level) is used as a bottom security mechanism and is independently provided by a platform side, and the part is a security Pack development kit, and the content can be tailored to different functional security overall requirements of intelligent driving products.

(8) Continuous Integration (CI) is the process of building software and completing initial testing, and Continuous Deployment (CD) is the process of integrating code with the infrastructure, ensuring that all testing is completed and policies are followed, and then deploying the code into the intended environment.

The following description is made for some simple descriptions of application scenarios applicable to the technical solutions of the embodiments of the present application, and it should be noted that the application scenarios described below are only used for illustrating the embodiments of the present application and are not limiting. In specific implementation, the technical scheme provided by the embodiment of the application can be flexibly applied according to actual needs.

Fig. 2 is a schematic view of an application scenario provided in the embodiment of the present application. As shown in fig. 2, the scenario includes a first terminal 20, a second terminal 21, and a server 22. The interaction between the server 22 and the first terminal 20 may be performed through a communication network, and the interaction between the server 22 and the second terminal 21 may also be performed through a communication network, where the communication manner adopted by the communication network may include: wireless communication and wired communication.

It should be noted that the number of the first terminals and the second terminals is not limited, and fig. 2 only illustrates the first terminal 20 and the second terminal 21 as an example.

The development host of the first terminal 20 as the platform side may communicate with the server 22 through a cellular mobile communication technology access network, which may include fifth generation mobile communication (5th Generation Mobile Networks,5G) technology, or through a short-range wireless communication mode access network, which may include wireless fidelity (Wireless Fidelity, wi-Fi) technology; platform characteristic components that may be used to periodically develop or update a service on the platform side are sent to the server 22 for update iterations.

The second terminal 21, acting as a development host for the algorithm party (also called user party), can communicate with the server 22 through a cellular mobile communication technology access network, which may include fifth generation mobile communication (5th Generation Mobile Networks,5G) technology, or through a short-range wireless communication mode access network, which may include wireless fidelity (Wireless Fidelity, wi-Fi) technology; when the second terminal 21 needs to update the algorithm component of the iterative service, the algorithm component can be used for acquiring the latest version of the platform characteristic component from the server 22, and performing the actual compiling process in combination with the algorithm source code of the service to generate the executable file of the service.

The server 22 may be an independent physical server, a server cluster or a distributed system formed by a plurality of physical servers, or may be a cloud server providing cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, a content delivery network (Content Delivery Network, CDN), basic cloud computing services such as big data and an artificial intelligence platform.

Further, in this embodiment of the present application, the server 22 may be equipped with a software integration device corresponding to the client, where the software integration device is configured to respond to the command input of each of the first terminal 21 and the second terminal 22, perform independent control on a platform portion and an algorithm portion related to product software (corresponding to the target service below) development, and maintain independent development progress, so as to ensure product software development quality and stable promotion.

Of course, the method provided in the embodiment of the present application is not limited to the application scenario shown in fig. 2, but may be used in other possible application scenarios, and the embodiment of the present application is not limited. The functions that can be implemented by each device in the application scenario shown in fig. 2 will be described together in the following method embodiments, which are not described in detail herein.

In order to further explain the functions of the software integrated device, fig. 3 is a schematic structural diagram of the software integrated device according to an embodiment of the present application. As shown in fig. 3, the software integrated device 300 includes a platform library packaging unit 301, an external abstract interface unit 302, an operation script unit 303, and further may further include a link script unit 304 and a CMAKE engineering unit 305. The operation script unit 303 is connected to the platform library packaging unit 301, the external abstract interface unit 302, the link script unit 304, and the CMAKE engineering unit 305, respectively.

The platform library packaging unit 301 may be configured to update the first service file belonging to the platform part in the iteration target service in response to the first command input of the first terminal.

The first terminal belongs to a terminal of a platform side, specifically may refer to the first terminal 20 in fig. 2, and the target service may refer to product software, for example, intelligent driving product software, intelligent cabin product software, and the like.

For example, when the first terminal may update or develop a new version of the service file (first service file) periodically (e.g., every month), the first command is input, and the platform library packaging unit 301 may replace the old version of the service file with the new version of the service file for use by a subsequent algorithm party based on the first command.

Alternatively, the platform library packaging unit 301 may be divided into a property component, an AUTOSAR supporting component, a middleware, an extension component, and the like, and from a more macroscopic and customized perspective, a platform component set in an intelligent driving scenario is defined, as shown in FIG. 4, which schematically illustrates a structure of the platform library packaging unit.

The feature component 401, which is a collection of necessary middle layer frames supporting intelligent driving products, may be composed of a plurality of sub-components for providing a first feature function for realizing the above-mentioned target service, and may specifically include a high performance data communication frame, a system time synchronization abstraction, a power management, a platform health management, a storage control and management, a big data calibration, and the like.

The AUTOSAR support component and middleware 402 can also be comprised of a plurality of sub-components for providing a second feature function for achieving a targeted service, which can include, in particular, operating system, RTE, network management, time synchronization, storage, SOME/IP, etc. communication stacks.

The expansion component 403 may also be composed of a plurality of sub-components, and is configured to provide a third characteristic function for implementing a target service, and may implement software and hardware decoupling with maximum capability of product software (target service), so as to flexibly expand the functional implementation of the target service, where the implementation may specifically include an MCAL hardware driver, a security Pack development kit, a basic mathematical operation function library, and the like, where the MCAL hardware driver may implement a hardware driver related to the target service; the security Pack development bag realizes different target supports with safe functions; the basic mathematical operation function library can comprise a large number of basic mathematical operators, such as (sin, fsin, cos, fcos, tan, sqrt, powf, expf, fabsf and the like), and a large number of calculations, such as coordinate system conversion, track reference line generation and the like, which depend on the basic mathematical algorithms are involved in the development process of product software, so that the purpose of accelerating the basic calculation of the algorithm can be realized based on the basic mathematical operation function library.

Alternatively, the first service file may be a first service file obtained based on the update of the multiple sub-component versions based on the actual development requirement of the target service.

The platform library packaging unit highly summarizes core components of product software, the clear modular design of the components and the customized guide of the product are clear, so that the development efficiency of technicians is improved.

It should be noted that the schematic structural diagram of the platform library packaging unit provided in fig. 4 is only an example, and the platform library packaging unit may be extended and modified according to actual requirements during the development of the actual product software.

The external abstract interface unit 302, which is an important component of the software integrated device, may be used to provide a second service file belonging to the algorithm part in implementing the target service based on the characteristics of the target service development (for example, the characteristics of the intelligent driving product software development).

Optionally, the pair of external abstract interface units 302 may include a plurality of components, such as an algorithm data component 501, a debug data component 502, a platform real-time scheduling component 503, a functional configuration word memorizing component 504, a fault detecting component 505, and the like, as shown in fig. 5, where the algorithm data component 501 may be used to provide algorithm logic data for implementing a target service; the debug data component 502 can be used to debug development data (e.g., algorithmic logic data) of a target service in real-time; the platform real-time scheduling component 503 can realize real-time task scheduling of the target service; the function configuration word memory component 504 can be used to store and memorize the intelligent driving function switches and parameters involved in the target business in a power-down mode and read in a power-up mode; the fault detection component 505 can be used for detecting the working state of each component in the development process of the target service, and when a certain component fails, the fault detection component can report in real time, so that a user can be reminded to take corresponding measures conveniently.

Alternatively, the second service file may be a service file obtained based on the one or more components described above, based on actual development requirements of the target service.

The operation script unit 303 is configured to generate an executable file of the target service according to the algorithm source code of the target service, the first service file, and the second service file in response to the command input of the second terminal, and deploy the executable file on the MCU. The second terminal belongs to a terminal of the algorithm party, in particular may be the second terminal 21 in fig. 2, and the command input may in particular refer to an update iteration of the target traffic algorithm part.

Optionally, during the generation process of the executable file, the operation script unit 303 is specifically configured to: copying the algorithm source code, the first service file and the second service file to a compiling path, and checking the validity of the compiling path; if so, calling a CMAKE engineering unit 304 to acquire a construction rule and a compiling rule for constructing an executable file, and calling a link script unit 305 to acquire a static link rule; and compiling the algorithm source code, the first service file and the second service file according to the construction rule, the compiling rule and the static link rule to obtain an executable file of the target service.

Alternatively, the validity of the compilation path may be determined by a third party's embedded compiler (e.g., task, or High Tec, etc.).

Optionally, the algorithmic source code of the target service is generated based on an Embedded compiler of Simulink.

Optionally, the static link rule may specifically refer to static mapping between symbols of each service file and a memory location, for example, when multiple service files are linked, similar segments are combined, and a mapping relationship is established by calculating a length and a location of each segment in the output service file after being combined.

Optionally, when the executable file is deployed on the MCU, the operation script unit 303 is specifically configured to perform a canonical operation on the executable file, to obtain a canonical executable file; and deploying the standardized executable files on the MCU, wherein the standardized operations can specifically comprise cyclic redundancy check, file splicing, format standardization and the like, so that the development quality of the target service is improved.

In some embodiments, the link script unit 303 may use a computer language with strong "viscosity" such as Python, so as to facilitate to communicate with various stages in a Continuous Integration (CI) and Continuous Deployment (CD) process, for example, using a CI and a CD built by Jenkins, and may implement easy calling of a build command in the operation script unit 303.

In some embodiments, the first service file may be packaged into a static library file with a suffix.

The operation script unit is used for realizing the landing of the product software (target business), and the core control is carried out on the whole development process of the product software, so that the operation is simple, and the integration efficiency of the product software is accelerated.

Fig. 6 is a flowchart of a software integration method according to an embodiment of the present application. The process may be performed by a software integration apparatus (such as the software execution apparatus 300 shown in fig. 3), and as shown in fig. 6, the process includes the following steps:

601: and responding to command input of the second terminal, and generating an executable file of the target service according to the algorithm source code, the first service file and the second service file of the target service.

In this step, the first service file may be obtained with reference to the related description of the platform library encapsulation unit 301 shown in fig. 3, the second service file may be obtained with reference to the related description of the external abstract interface unit 302 shown in fig. 3, and the executable file generation process may be performed with reference to the related description of the operation script unit 303 shown in fig. 3, and thus the description will not be repeated.

602: and deploying the executable files on the MCU.

In this step, the deployment of the executable file may refer to the related description of the operation script unit 303 shown in fig. 3, and the description will not be repeated here.

Based on the same technical concept, the embodiment of the application also provides electronic equipment, which can realize the functions of the software integration device.

At least one processor 701, and a memory 702 connected to the at least one processor 701, in this embodiment of the present application, a specific connection medium between the processor 701 and the memory 702 is not limited, and in fig. 7, the processor 701 and the memory 702 are connected by a bus 700 as an example. Bus 700 is shown in bold lines in fig. 7, and the manner in which the other components are connected is illustrated schematically and not by way of limitation. The bus 700 may be divided into an address bus, a data bus, a control bus, etc., and is represented by only one thick line in fig. 7 for convenience of representation, but does not represent only one bus or one type of bus. Alternatively, the processor 701 may be referred to as a controller, and the names are not limited.

In the embodiment of the present application, the memory 702 stores instructions executable by the at least one processor 701, and the at least one processor 701 may perform a software integration method as described above by executing the instructions stored in the memory 702. The processor 701 may implement the functions of the various modules in the apparatus shown in fig. 3.

The processor 701 is a control center of the apparatus, and may connect various parts of the entire control device using various interfaces and lines, and by executing or executing instructions stored in the memory 702 and invoking data stored in the memory 702, various functions of the apparatus and processing data, thereby performing overall monitoring of the apparatus.

In one possible design, processor 701 may include one or more processing units, and processor 701 may integrate an application processor and a modem processor, wherein the application processor primarily processes operating systems, driver interfaces, application programs, and the like, and the modem processor primarily processes wireless communications. It will be appreciated that the modem processor described above may not be integrated into the processor 701. In some embodiments, processor 701 and memory 702 may be implemented on the same chip, or they may be implemented separately on separate chips in some embodiments.

The processor 701 may be a general purpose processor such as a Central Processing Unit (CPU), digital signal processor, application specific integrated circuit, field programmable gate array or other programmable logic device, discrete gate or transistor logic device, discrete hardware components, which may implement or perform the methods, steps, and logic blocks disclosed in embodiments of the present application. The general purpose processor may be a microprocessor or any conventional processor or the like. The steps of a software integration method disclosed in connection with the embodiments of the present application may be directly embodied as a hardware processor executing or may be executed by a combination of hardware and software modules in the processor.

The memory 702 is a non-volatile computer-readable storage medium that can be used to store non-volatile software programs, non-volatile computer-executable programs, and modules. The Memory 702 may include at least one type of storage medium, and may include, for example, flash Memory, hard disk, multimedia card, card Memory, random access Memory (Random Access Memory, RAM), static random access Memory (Static Random Access Memory, SRAM), programmable Read-Only Memory (Programmable Read Only Memory, PROM), read-Only Memory (ROM), charged erasable programmable Read-Only Memory (Electrically Erasable Programmable Read-Only Memory), magnetic Memory, magnetic disk, optical disk, and the like. Memory 702 is any other medium that can be used to carry or store desired program code in the form of instructions or data structures and that can be accessed by a computer, but is not limited to such. The memory 702 in the embodiments of the present application may also be circuitry or any other device capable of implementing a memory function for storing program instructions and/or data.

By programming the processor 701, code corresponding to one of the software integration methods described in the foregoing embodiments may be solidified into a chip, so that the chip can execute one of the software integration methods of the embodiment shown in fig. 6 at runtime. How to design and program the processor 701 is a technology well known to those skilled in the art, and will not be described in detail herein.

It should be noted that, the above power-on electronic device provided in the embodiment of the present application can implement all the method steps implemented in the embodiment of the method, and can achieve the same technical effects, and specific details of the same parts and beneficial effects as those of the embodiment of the method in the embodiment are not described herein.

The present application also provides a computer-readable storage medium storing computer-executable instructions for causing a computer to perform a software integration method of the above embodiments.

Embodiments of the present application also provide a computer program product which, when invoked by a computer, causes the computer to perform one of the software integration methods of the above embodiments.

It will be appreciated by those skilled in the art that embodiments of the present application may be provided as a method, system, or computer program product. Accordingly, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present application may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.

The present application is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to the application. It will be understood that each flow and/or block of the flowchart illustrations and/or block diagrams, and combinations of flows and/or blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

Claims

1. A software integration apparatus, comprising:

the platform library packaging unit is used for responding to the first command input of a first terminal, updating a first service file belonging to a platform part in the iteration target service, wherein the first terminal belongs to a terminal of a platform side;

an external abstract interface unit, configured to provide a second service file belonging to an algorithm part in the target service;

and the operation script unit is used for responding to command input of a second terminal, generating an executable file of the target service according to the algorithm source code of the target service, the first service file and the second service file, and deploying the executable file on the MCU, wherein the second terminal belongs to a terminal of an algorithm party.

2. The apparatus of claim 1, wherein the apparatus further comprises a link script unit and a CMAKE engineering unit;

the operation script unit is specifically configured to:

copying the algorithm source code, the first service file and the second service file to a compiling path, and checking the validity of the compiling path;

if the executable file is effective, calling the CMAKE engineering unit to acquire a construction rule and a compiling rule for constructing the executable file, and calling the link script unit to acquire a static link rule;

and compiling the algorithm source code, the first service file and the second service file according to the construction rule, the compiling rule and the static link rule to obtain the executable file of the target service.

3. The apparatus of claim 2, wherein the validity of the compilation path is determined by an embedded compiler.

4. The apparatus of claim 1, wherein the platform library packaging unit comprises a property component, an AUTOSAR support component, and middleware, an expansion component;

the characteristic component is used for providing a first characteristic function for realizing the target service;

the AUTOSAR supporting component and the middleware are used for providing a second characteristic function for realizing the target service;

the expansion component is configured to provide a third feature function for implementing the target service.

5. The apparatus of claim 1, wherein the operation script unit is specifically configured to, when the executable file is deployed on the MCU:

executing standard operation on the executable file to obtain a standard executable file;

deploying the canonical executable file on the MCU;

wherein the canonical operation includes at least one of: cyclic redundancy check, file splicing, format normalization.

6. The apparatus of claim 1, wherein the algorithmic source code is generated based on an Simulink's Embedded code.

7. A software integration method applied to the device according to any one of claims 1 to 6, comprising:

responding to command input of a second terminal, and generating an executable file of a target service according to an algorithm source code, a first service file and a second service file of the target service;

the executable file is deployed on a micro control unit MCU, and the second terminal belongs to a terminal of an algorithm party;

the first service file is a file belonging to a platform part in the iteration target service, and the platform library packaging unit responds to a first command input of a first terminal, wherein the first terminal belongs to a terminal of a platform side; the second file is a file which belongs to an algorithm part in the target service and is provided by the external abstract interface unit.

8. The method of claim 7, wherein generating the executable file of the target service based on the algorithmic source code of the target service, the first service file, the second service file, comprises:

9. An electronic device, comprising:

a memory for storing a computer program;

a processor for carrying out the method steps of any one of claims 7-8 when executing a computer program stored on said memory.

10. A computer-readable storage medium, characterized in that the computer-readable storage medium has stored therein a computer program which, when executed by a processor, implements the method steps of any of claims 7-8.