CN113254020A - System and method for automatically compiling and packaging firmware - Google Patents
System and method for automatically compiling and packaging firmware Download PDFInfo
- Publication number
- CN113254020A CN113254020A CN202011238410.1A CN202011238410A CN113254020A CN 113254020 A CN113254020 A CN 113254020A CN 202011238410 A CN202011238410 A CN 202011238410A CN 113254020 A CN113254020 A CN 113254020A
- Authority
- CN
- China
- Prior art keywords
- source code
- packaging
- compiling
- slave device
- firmware
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5027—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Security & Cryptography (AREA)
- Stored Programmes (AREA)
Abstract
The application relates to a system and a method for automatically compiling and packaging firmware, which comprises the following steps: the device comprises a master device and a plurality of slave devices, wherein the plurality of slave devices comprise at least one target slave device; the main equipment is used for receiving the compiling and packaging task instruction, acquiring corresponding task allocation information according to the compiling and packaging task instruction, dividing the compiling and packaging task into a plurality of subtasks according to the task allocation information, and distributing each subtask to corresponding slave equipment according to the task allocation information; each slave device is used for compiling according to the received subtasks and sending the binary file obtained by compiling to the target slave device responsible for packaging; and the target slave device is used for packaging according to the received binary file to generate a firmware package. According to the system and the method for automatically compiling and packaging the firmware, an engineer is not required to participate in the whole process, so that the labor cost is saved, the time is saved, the working efficiency is improved, and the system and the method for automatically compiling and packaging the firmware are accurate and reliable.
Description
Technical Field
The invention relates to the technical field of computers, in particular to a system and a method for automatically compiling and packaging firmware.
Background
Firmware is a program written to an EROM or EPROM (programmable read only memory), and is colloquially understood to be solidified software. Most of various module products developed at present involve the control of modules by developing software and firmware, and the developed firmware must generate corresponding binary files through a compiler tool from the beginning to the realization of specific functions and download the binary files to chips in the final module products.
For example, a cycle core may include a main control chip, a sub-control chip, a driver library and a service library, which may use VS development, a test tool may use QT development, and an upgrade may use a script, so that different compilers may be used to compile binary files during packaging, and different system compiles (such as Window and Linux) may also be used, and after the compilation is completed, the binary files are manually copied and packaged into an upgrade package for upgrading the module product.
Because the compiling and packaging work of the source code relates to a plurality of chip schemes and compiling platforms, and a pure manual or semi-automatic mode is used, the compiling and packaging work is time-consuming and very easy to make mistakes, and different people can have differences if using different environments to complete compiling and packaging. In addition, in the case of frequent source code modification or in the case of diversified and complicated forms of company product lines, a large number of compiling and packaging personnel are required or excessive development time is occupied, and the effectiveness is very low.
Disclosure of Invention
Therefore, it is necessary to provide a system and a method for automatically compiling and packaging firmware, which can greatly save the compiling and packaging time, thereby improving the working efficiency, and the program is automatically compiled and packaged, accurate and reliable.
The embodiment of the invention provides a system for automatically compiling and packaging firmware, which comprises: the device comprises a master device and a plurality of slave devices, wherein at least one target slave device is included in the plurality of slave devices;
the main device is used for acquiring corresponding task allocation information according to the received compiled and packaged task identifier, dividing the compiled and packaged task into a plurality of subtasks according to the task allocation information, and distributing each subtask to corresponding slave devices according to the task allocation information;
each slave device is used for compiling according to the received subtasks and sending the binary file obtained by compiling to the target slave device responsible for packaging;
and the target slave equipment is used for packaging according to the received binary file to generate a firmware package.
The embodiment of the invention provides a method for automatically compiling and packaging firmware, which is applied to a system for automatically compiling and packaging the firmware, wherein the system comprises a master device and a plurality of slave devices, and the plurality of slave devices comprise at least one target slave device; the method comprises the following steps:
the main equipment acquires corresponding task allocation information according to the received compiled and packaged task identifier, divides the compiled and packaged task into a plurality of subtasks according to the task allocation information, and distributes each subtask to corresponding slave equipment according to the task allocation information;
compiling each slave device according to the received subtasks, and sending the binary file obtained by compiling to the target slave device responsible for packaging;
and the target slave equipment packages according to the received binary file to generate a firmware package.
According to the system and the method for automatically compiling and packaging the firmware, the main device divides the compiling and packaging task into a plurality of subtasks according to the acquired task distribution information, then distributes the subtasks to the corresponding slave devices, each slave device compiles according to the received subtasks, sends the binary file obtained by compiling to the target slave device for packaging, and further generates the firmware. According to the system and the method for automatically compiling and packaging the firmware, the compiling and packaging task is divided into a plurality of subtasks and then distributed to the corresponding slave devices, all the slave devices can be processed in parallel, processing time is greatly saved, working efficiency is improved, an engineer does not need to participate in the whole process, labor cost is saved, automatic compiling and packaging are not prone to errors, and the system and the method are accurate and reliable.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below, it is obvious that the drawings in the following description are only some embodiments of the present invention, and for those skilled in the art, other drawings can be obtained according to the structures shown in the drawings without creative efforts.
FIG. 1 is a diagram of a system for firmware auto-compilation packaging, under an embodiment;
FIG. 2 is a diagram of a system for firmware auto-compilation packaging in another embodiment;
FIG. 3 is a diagram of a system for firmware auto-compilation packaging in yet another embodiment;
FIG. 4 is a flow diagram that illustrates a method for firmware auto-compile packaging, under an embodiment.
Detailed Description
In order to make the objects, technical solutions and advantages of the present invention more apparent, the present invention is described in further detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention.
As shown in fig. 1, a system for automatic firmware compilation and packaging is provided, which includes: a master device 10 and a plurality of slave devices 20, including at least one target slave device;
the master device 10 is configured to receive a compiled and packaged task instruction, obtain corresponding task allocation information according to the compiled and packaged task instruction, divide the compiled and packaged task into a plurality of subtasks according to the task allocation information, and distribute each subtask to a corresponding slave device according to the task allocation information.
Each slave device 20 is configured to compile according to the received subtasks, and send the binary file obtained by compiling to the target slave device responsible for packaging.
And the target slave equipment is used for packaging according to the received binary file to generate a firmware package.
The system environment and the compiling platform used by the master device (master)10 and each slave device (slave) 20 may be different from each other, but the principle is the same. The master device 10 is connected with each slave device 20, and is used for distributing the compiling and packaging tasks to a plurality of slave devices, and the plurality of slave devices can be compiled in parallel, which is beneficial to improving the efficiency of compiling and packaging.
The master device 10, which may be understood as the whole brain of the framework, is generally only one, primarily responsible for the monitoring and distribution of tasks. The task allocation information includes distribution rules of the task, i.e. how the compiled and packaged task should be decomposed and then distributed to which slave device to execute. For example, if the window version of firmware is packaged, the task is distributed to slave device a, slave device 1, slave device 2, and slave device 3, where slave device a is the target slave device and is responsible for packaging. If the Linux version of firmware is packaged, the tasks are distributed to slave B, slave 2, slave 3, and slave 4, slave B being the target slave. After all slave devices compile the binary file, the binary file is sent to the corresponding target slave device, for example, the slave device a or the slave device B, and the binary file is uploaded to the slave device a if the firmware package is a window version firmware package, and is uploaded to the slave device B if the firmware package is a Linux version firmware package. It should be noted that the target slave device responsible for packaging may also perform the compiling work of the subtasks at the same time. I.e. one can be selected from the slave devices responsible for compilation as the target slave device for packaging.
In one embodiment, different slave devices may be responsible for different types of compilation, such as slave device 1 for engineering compilation of windows environment, slave device 2 for engineering compilation of Fedora8 environment, slave device 3 for engineering compilation of Ubuntu environment, and slave device 4 for engineering compilation of Linux environment.
The task allocation information may be actively acquired by the master device 10 or passively received. For example, the task allocation information and the compiled and packaged task identifier may be stored in a designated location in advance, and after receiving the compiled and packaged task instruction, the main device 10 reads the corresponding task allocation information according to the compiled and packaged task identifier. In another embodiment, when sending the compiled and packaged task instruction to the host device, the task allocation information may be sent together, that is, the task allocation information is included in the compiled and packaged task instruction.
The slave device 20 is configured to perform compilation according to the received subtasks, and select one of the plurality of slave devices as a target slave device, where the target slave device is responsible for packaging, that is, packaging the compiled binary file. Specifically, the slave device 20 downloads the corresponding source code according to the source code address to be compiled, and then compiles according to the downloaded source code.
In one embodiment, the compiling and packaging task is started through a human-computer interaction interface, and when compiling and packaging are needed, an execution instruction of the compiling and packaging task is received through the human-computer interaction interface. For example, an engineer may select a task to be packaged on the interface, so that the master device may distribute the task to the slave devices after receiving the task. The manner of initiating the compile package task may be various, for example, the instructions may be received through a built client or browser.
According to the system for automatically compiling and packaging the firmware, the main device divides the compiling and packaging task into a plurality of subtasks according to the obtained task allocation information, then allocates the subtasks to the corresponding slave devices, each slave device compiles according to the received subtasks, sends the binary file obtained by compiling to the target slave device to be packaged, and further generates the firmware. According to the system and the method for automatically compiling and packaging the firmware, the compiling and packaging task is divided into a plurality of subtasks and then distributed to the corresponding slave devices, all the slave devices can process in parallel, processing time is greatly saved, working efficiency is improved, an engineer does not need to participate in the whole process, labor cost is saved, automatic compiling and packaging are achieved, and the system and the method are accurate and reliable.
In one embodiment, the task allocation information includes: the subtask that each slave device needs to execute, the source code address corresponding to the subtask, and the target slave device identifier responsible for packaging; the master device is further configured to send a subtask instruction to the corresponding slave device, where the subtask instruction includes: the source code address corresponding to the subtask and the target slave device identifier in charge of packaging; the slave device is further configured to download a corresponding source code according to the received source code address, perform compilation according to the source code to generate a binary file, and send the binary file to a target slave device corresponding to the target slave device identifier.
The source code address is used for indicating the storage position of the source code, so that each slave device can download the corresponding source code according to the source code address and compile the source code. The target slave device identifier is used for uniquely identifying one target slave device, the target slave device is used for taking charge of a packaging task, and after the source code is compiled into the binary file, each slave device needs to send the binary file to the target slave device for packaging to generate the firmware package. And after the target slave equipment receives the binary files compiled by all the slave equipment, packaging the binary files by adopting a packaging script to generate a firmware package.
In one embodiment, the subtask instruction further includes: a compilation type of the subtask; and the slave equipment is also used for calling a corresponding script compiler according to the compiling type to compile the source code and generate the binary file.
Wherein each slave device can perform multiple types of compilation tasks. So in order for the slave device to know what type of compilation task the current subtask needs to perform, the compilation type of the subtask needs to be included in the task instruction. For example, the slave device 1 is responsible for executing engineering compilation of the windows environment, and specifically includes: the method comprises the following steps of compiling multiple types of files including Xilinx SDK engineering, Keil engineering, QT engineering, VS engineering, Cross works engineering and the like, acquiring a specific compiling type such as the Xilinx SDK engineering when executing the compiling, and then calling a script compiling program corresponding to the compiling type to compile downloaded source codes to generate a binary file, wherein the compiling program exists in a script form.
As shown in fig. 2, in an embodiment, the firmware auto-packaging compilation system further includes: a version management system 30, configured to store the source code, where the subtask instruction further includes: a source code identification; and the slave equipment is also used for downloading corresponding source codes from the version management system according to the source code addresses corresponding to the subtasks and the source code identifiers.
The version management system is used for storing source codes, and due to continuous upgrading of versions, multiple source codes may be included in the same source code address. The source code identification is used to uniquely identify a source code. When the slave device downloads the source code from the version management system, not only the source code address but also the source code identification are required to determine the source code to be downloaded.
In one embodiment, when no source code identification is present in the subtask instruction, the latest version of the source code in the default source code address is the target source code to be downloaded.
In one embodiment, each slave device is further configured to send the source code address and the source code identification to the target slave device responsible for packaging; and the target slave equipment is also used for storing the source code address, the source code identifier and the generated name of the firmware in an associated manner to obtain an associated information file.
In order to facilitate subsequent tracing, each slave device sends the acquired source code address and source code identifier to the target slave device, then the target slave device packages the binary file to generate a firmware package, and then associates and stores the source code address, the source code identifier and the firmware name acquired from each slave device to generate an associated information file, so that subsequent tracing to the source code is facilitated.
As shown in fig. 3, in an embodiment, the firmware auto-packaging compiling system further includes: a file management system 40; the target slave device is further configured to upload the association information file corresponding to the firmware to the file management system for storage.
The file management system is used for storing the firmware which is finally compiled, packaged and output and storing a corresponding associated information file. The file management system can be implemented by using FTP or Samba.
In an embodiment, the target slave device is further configured to calculate a hash value corresponding to the firmware by using a hash algorithm according to the generated firmware, and perform association storage on the source code address, the source code identifier, the generated name of the firmware, and the corresponding hash value to obtain an association information file.
The associated information file stores the corresponding relation among the source code address, the source code identification and the name of the firmware. And correspondingly storing the hash value corresponding to the firmware as the associated information. The firmware hash value is a hash value calculated by a hash algorithm (for example, MD5) on the generated firmware, and the hash value has uniqueness, and the calculation of the firmware hash value is related to the size of the firmware, the content included in the firmware, and the like. In another embodiment, associating the stored information may further include: compiling and packaging time, personnel information corresponding to compiling and packaging, module information corresponding to firmware, address information of the firmware in the file management system and the like. And the related information is stored in an associated manner, so that subsequent searching and tracing are facilitated.
In one embodiment, the master device is further configured to send a source code address and a source code identifier corresponding to each slave device to the target slave device; and the target slave equipment is also used for storing the source code address, the source code identifier and the generated name of the firmware in an associated manner to obtain an associated information file.
The master device knows the source address and the source code identification corresponding to each slave device, so that the master device directly sends the source address and the source code identification corresponding to each slave device to the target slave device, and other slave devices do not need to send the source address and the source code identification independently. Similarly, the source code address, the source code identifier and the generated firmware name are stored in an associated manner, so that an associated information file is obtained.
In one embodiment, the task allocation information includes: the method comprises the following steps that subtasks needing to be executed by each slave device, source code addresses corresponding to the subtasks and version types of the subtasks are determined; and the slave equipment is also used for downloading a corresponding source code according to the received source code address, compiling according to the source code to generate a binary file, and sending the binary file to target slave equipment corresponding to the version type of the subtask.
Target slave devices corresponding to different version types can be preset, so that when the compiling and packaging task is executed, the target slave device identification corresponding to the slave device does not need to be told every time. The slave device can determine the corresponding target slave device according to the version type of the received subtask. For example, the target slave device a is responsible for the window version firmware packaging work, the target slave device B is responsible for the Linux version firmware packaging work, and when the version type of the subtask is known, the target slave device can be determined.
As shown in fig. 4, in an embodiment, a method for firmware automatic compiling and packaging is proposed, which is applied to a system for firmware automatic compiling and packaging, where the system includes a master device and a plurality of slave devices, and the plurality of slave devices includes at least one target slave device; the method comprises the following steps:
step 404, compiling each slave device according to the received subtasks, and sending the binary file obtained by compiling to the target slave device responsible for packaging;
in step 406, the target slave device packages the received binary file to generate a firmware package.
According to the method for automatically compiling and packaging the firmware, the main device divides a compiling and packaging task into a plurality of subtasks according to the obtained task allocation information, then allocates the subtasks to the corresponding slave devices, each slave device compiles according to the received subtasks, sends the binary files obtained by compiling to the target slave devices for packaging, and further generates the firmware. According to the system and the method for automatically compiling and packaging the firmware, an engineer is not required to participate in the whole process, so that the labor cost is saved, the time is saved, the working efficiency is improved, the automatic compiling and packaging are not easy to make mistakes, and the system and the method are accurate and reliable.
In one embodiment, the task allocation information includes: the subtask that each slave device needs to execute, the source code address corresponding to the subtask, and the target slave device identifier responsible for packaging;
the distributing each subtask to a corresponding slave device according to the task allocation information includes: the master device sends a subtask instruction to the corresponding slave device, wherein the subtask instruction comprises: the source code address corresponding to the subtask and the target slave device identifier in charge of packaging;
the compiling of each slave device is carried out according to the received subtasks, and the binary file obtained by compiling is sent to the target slave device responsible for packaging, and the method comprises the following steps: and the slave equipment downloads corresponding source codes according to the received source code addresses, compiles according to the source codes to generate a binary file, and sends the binary file to the target slave equipment corresponding to the target slave equipment identifier.
In one embodiment, the subtask instruction further includes: a compilation type of the subtask; compiling according to the source code to generate a binary file, comprising: and the slave equipment is also used for calling a corresponding script compiler according to the compiling type to compile the source code and generate the binary file.
In one embodiment, the system further comprises: the version management system is used for storing source codes, and the subtask instruction further comprises: a source code identification;
the slave device downloads corresponding source codes according to the received source code addresses, and the method comprises the following steps: and the slave equipment downloads corresponding source codes from the version management system according to the source code addresses corresponding to the subtasks and the source code identifiers.
In an embodiment, the method for automatically compiling and packaging firmware further includes: each slave device is further configured to send the source code address and the source code identification to the target slave device responsible for packaging; and the target slave equipment is also used for storing the source code address, the source code identifier and the generated name of the firmware in an associated manner to obtain an associated information file.
In one embodiment, the system further comprises: a file management system; the above firmware automatic compiling and packaging method further comprises: and the target slave equipment uploads the associated information file corresponding to the firmware to the file management system for storage.
In an embodiment, the method for automatically compiling and packaging firmware further includes: and the target slave device calculates a hash value corresponding to the firmware by adopting a hash algorithm according to the generated firmware, and stores the source code address, the source code identifier, the generated firmware name and the hash value in an associated manner to obtain an associated information file.
In an embodiment, the method for automatically compiling and packaging firmware further includes: the master device sends the source code address and the source code identification corresponding to each slave device to the target slave device; and the target slave equipment stores the source code address, the source code identifier and the generated name of the firmware in an associated manner to obtain an associated information file.
In one embodiment, the task allocation information includes: the method comprises the following steps that subtasks needing to be executed by each slave device, source code addresses corresponding to the subtasks and version types of the subtasks are determined;
the compiling of each slave device is carried out according to the received subtasks, and the binary file obtained by compiling is sent to the target slave device responsible for packaging, and the method comprises the following steps: and the slave equipment downloads a corresponding source code according to the received source code address, compiles according to the source code to generate a binary file, and sends the binary file to the target slave equipment corresponding to the version type of the subtask.
It will be understood by those skilled in the art that all or part of the processes of the methods of the embodiments described above can be implemented by a computer program, which can be stored in a non-volatile computer-readable storage medium, and can include the processes of the embodiments of the methods described above when the program is executed. Any reference to memory, storage, database, or other medium used in the embodiments provided herein may include non-volatile and/or volatile memory, among others. Non-volatile memory can include read-only memory (ROM), Programmable ROM (PROM), Electrically Programmable ROM (EPROM), Electrically Erasable Programmable ROM (EEPROM), or flash memory. Volatile memory can include Random Access Memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in a variety of forms such as Static RAM (SRAM), Dynamic RAM (DRAM), Synchronous DRAM (SDRAM), Double Data Rate SDRAM (DDRSDRAM), Enhanced SDRAM (ESDRAM), Synchronous Link DRAM (SLDRAM), Rambus Direct RAM (RDRAM), direct bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM).
The technical features of the above embodiments can be arbitrarily combined, and for the sake of brevity, all possible combinations of the technical features in the above embodiments are not described, but should be considered as the scope of the present specification as long as there is no contradiction between the combinations of the technical features.
The above-mentioned embodiments only express several embodiments of the present application, and the description thereof is more specific and detailed, but not construed as limiting the scope of the present application. It should be noted that, for a person skilled in the art, several variations and modifications can be made without departing from the concept of the present application, which falls within the scope of protection of the present application. Therefore, the protection scope of the present patent shall be subject to the appended claims.
Claims (10)
1. A system for firmware auto-compilation packaging, the system comprising: the device comprises a master device and a plurality of slave devices, wherein at least one target slave device is included in the plurality of slave devices;
the main device is used for receiving a compiling and packaging task instruction, acquiring corresponding task allocation information according to the compiling and packaging task instruction, dividing the compiling and packaging task into a plurality of subtasks according to the task allocation information, and distributing each subtask to corresponding slave devices according to the task allocation information;
each slave device is used for compiling according to the received subtasks and sending the binary file obtained by compiling to the target slave device responsible for packaging;
and the target slave equipment is used for packaging according to the received binary file to generate a firmware package.
2. The system of claim 1, wherein the task assignment information comprises: the subtask that each slave device needs to execute, the source code address corresponding to the subtask, and the target slave device identifier responsible for packaging;
the master device is further configured to send a subtask instruction to the corresponding slave device, where the subtask instruction includes: the source code address corresponding to the subtask and the target slave device identifier in charge of packaging;
the slave device is further configured to download a corresponding source code according to the received source code address, perform compilation according to the source code to generate a binary file, and send the binary file to a target slave device corresponding to the target slave device identifier.
3. The system of claim 2, wherein the subtask instructions further comprise: a compilation type of the subtask;
and the slave equipment is also used for calling a corresponding script compiler according to the compiling type to compile the source code and generate the binary file.
4. The system of claim 2, further comprising: the version management system is used for storing source codes, and the subtask instruction further comprises: a source code identification;
and the slave equipment is also used for downloading corresponding source codes from the version management system according to the source code addresses corresponding to the subtasks and the source code identifiers.
5. The system of claim 4, wherein each slave device is further configured to send the source code address and the source code identification to the target slave device responsible for packaging;
and the target slave equipment is also used for storing the source code address, the source code identifier and the generated name of the firmware in an associated manner to obtain an associated information file.
6. The system of claim 5, further comprising: a file management system;
the target slave device is further configured to upload the association information file corresponding to the firmware to the file management system for storage.
7. The system according to claim 6, wherein the target slave device is further configured to calculate a hash value corresponding to the firmware by using a hash algorithm according to the generated firmware, and store the source code address, the source code identifier, the generated name of the firmware, and the hash value in an associated manner to obtain an associated information file.
8. The system of claim 4, wherein the master device is further configured to send a source code address and a source code identifier corresponding to each slave device to the target slave device;
and the target slave equipment is also used for storing the source code address, the source code identifier and the generated name of the firmware in an associated manner to obtain an associated information file.
9. The system of claim 1, wherein the task assignment information comprises: the method comprises the following steps that subtasks needing to be executed by each slave device, source code addresses corresponding to the subtasks and version types of the subtasks are determined;
and the slave equipment is also used for downloading a corresponding source code according to the received source code address, compiling according to the source code to generate a binary file, and sending the binary file to target slave equipment corresponding to the version type of the subtask.
10. The method for automatically compiling and packaging the firmware is applied to a system for automatically compiling and packaging the firmware, and the system comprises a master device and a plurality of slave devices, wherein the plurality of slave devices comprise at least one target slave device; the method comprises the following steps:
the main equipment receives a compiling and packaging task instruction, acquires corresponding task allocation information according to the compiling and packaging task instruction, divides the compiling and packaging task into a plurality of subtasks according to the task allocation information, and distributes each subtask to corresponding slave equipment according to the task allocation information;
compiling each slave device according to the received subtasks, and sending the binary file obtained by compiling to the target slave device responsible for packaging;
and the target slave equipment packages according to the received binary file to generate a firmware package.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011238410.1A CN113254020A (en) | 2020-11-09 | 2020-11-09 | System and method for automatically compiling and packaging firmware |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011238410.1A CN113254020A (en) | 2020-11-09 | 2020-11-09 | System and method for automatically compiling and packaging firmware |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN113254020A true CN113254020A (en) | 2021-08-13 |
Family
ID=77180689
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011238410.1A Pending CN113254020A (en) | 2020-11-09 | 2020-11-09 | System and method for automatically compiling and packaging firmware |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN113254020A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117075958A (en) * | 2023-10-16 | 2023-11-17 | 广东优力普物联科技有限公司 | Firmware generation method suitable for multiple models, storage medium and electronic equipment |
-
2020
- 2020-11-09 CN CN202011238410.1A patent/CN113254020A/en active Pending
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117075958A (en) * | 2023-10-16 | 2023-11-17 | 广东优力普物联科技有限公司 | Firmware generation method suitable for multiple models, storage medium and electronic equipment |
| CN117075958B (en) * | 2023-10-16 | 2024-01-23 | 广东优力普物联科技有限公司 | Firmware generation method suitable for multiple models, storage medium and electronic equipment |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109032631B (en) | Application program patch package obtaining method and device, computer equipment and storage medium | |
| CN112148329B (en) | Code version automatic updating method and device, computer equipment and storage medium | |
| CN114296871A (en) | Container-based continuous integration method, device and system, working node and medium | |
| CN112965720B (en) | Component compiling method, device, equipment and computer readable storage medium | |
| CN111078229A (en) | Application processing method and device, storage medium and electronic equipment | |
| CN112380130A (en) | Application testing method and device based on call dependency relationship | |
| KR101771289B1 (en) | Apparatus for Program Management of Programmable Logic Controller | |
| CN112631600A (en) | Software construction method and system based on Flutter | |
| CN114610318A (en) | Android application packaging method, device, equipment and storage medium | |
| CN110990051B (en) | Maintenance method, device, medium and equipment for software package dependency relationship | |
| CN113254020A (en) | System and method for automatically compiling and packaging firmware | |
| CN111190584A (en) | EHIS-DB system version release method and device, computer equipment and storage medium | |
| CN114385196A (en) | Software deployment method and device combining RPA and AI | |
| CN115904384A (en) | Configuration method, device and equipment for application program release and storage medium | |
| CN110806891A (en) | Method and device for generating software version of embedded equipment | |
| CN105335185A (en) | Processing method and device of SRPM (Source RedHat Package Manager) package | |
| CN106547519B (en) | Information processing method and system | |
| CN114564385A (en) | Software testing method and device, computer equipment and storage medium | |
| CN114647455A (en) | Method and device for realizing compatibility of operating system and network card and computer equipment | |
| CN110795100A (en) | Branch merging method and device | |
| CN107229506B (en) | Virtual machine migration method and device | |
| CN112486822A (en) | Software testing device, method, computer equipment and storage medium | |
| CN108573142B (en) | Method and device for realizing hook | |
| CN116911406B (en) | Wind control model deployment method and device, computer equipment and storage medium | |
| CN113326048B (en) | Floating point number calculation precision processing method, system, medium and device |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |