Embedded operating system software configuration method and device

Abstract

The invention relates to an embedded operating system software configuration method and device. The method comprises the following steps: receiving a running environment required by a to-be-used embedded application scene selected by a user; a corresponding operation environment software package is obtained from a scene-oriented operation environment application set based on the selected operation environment, and the scene-oriented operation environment application set comprises a plurality of operation environment software packages; receiving a hardware platform which is selected by a user and is adaptive to the corresponding running environment software package; acquiring a corresponding kernel compiling configuration file based on the selected hardware platform; generating a system mirror image file according to the corresponding running environment software package and the corresponding kernel compiling configuration file; and installing the system mirror image file to a target machine. According to the method, the software set required by the system can be configured at the host end, and the system mirror image file is generated according to the configuration, so that the problem that embedded scene development and use are too tedious and time-consuming in the prior art is solved.

Description

Technical Field

[0001] The present application relates to computer embedded system configuration technology, and in particular to an embedded operating system software configuration method and device, computing equipment and storage medium. Background Art

[0002] Existing operating systems are mainly divided into two categories. The first category is standard distribution systems such as Ubuntu and CentOS, and the second category is embedded version systems such as Buildroot and Yocto.

[0003] The first type of operating system users choose to install a software set. They can configure the software set in the following three ways:

[0004] You can install the software set by selecting the ISO type (desktop version, server version, edge controller version) before installing the operating system;

[0005] You can select the software set (server, development tools, desktop environment) to be installed on the wizard page provided during the operating system installation process;

[0006] After the operating system is installed and running, you can use package management tools (yum, apt, etc.) to install the software;

[0007] The second type of operating system users need to select the system software set by editing the system software configuration before building the system (buildroot is configured through the menuconfig menu, and yocto is configured through editing files).

[0008] In the use scenarios of embedded operating systems, the software sets to be used for different fields and scenarios are all different. For example, when adapting and porting an application for an AI scenario, the dependent software set cannot be determined when the embedded operating system is installed. When using the first type of technology, after the embedded operating system is installed, the dependent software must be installed one by one using a package management tool to finally reach a usable state. The process of making the final usable state into an ISO installation image is cumbersome, and the embedded scenario may not be able to connect to the software source through the network. When using the second type, the software build system must be repeatedly added to gradually confirm that the dependent software has been fully added. The entire process is time-consuming and cumbersome. Existing technologies cannot quickly produce an operating system image for a specific user scenario and specific purpose. Summary of the invention

[0009] In view of the above problems in the prior art, the present application provides an embedded operating system software configuration method and apparatus, a computing device and a storage medium to solve the problem that embedded scenario development and use are too cumbersome and time-consuming.

[0010] To achieve the above-mentioned purpose, the first aspect of the present application provides an embedded operating system software configuration method, comprising:

[0011] Receive the operating environment required by the embedded application scenario to be used selected by the user;

[0012] Based on the selected operating environment, obtaining a corresponding operating environment software package from a scenario-oriented operating environment application set, wherein the scenario-oriented operating environment application set includes a plurality of operating environment software packages;

[0013] Receiving a hardware platform selected by a user that is compatible with the corresponding operating environment software package;

[0014] Acquire a corresponding kernel compilation configuration file based on the selected hardware platform;

[0015] Generate a system image file according to the corresponding operating environment software package and the corresponding kernel compilation configuration file;

[0016] Install the system image file to the target machine.

[0017] From the above, the present application can build a scenario-oriented operating environment application set in advance. After the user selects the operating environment and hardware platform required for the embedded application scenario, the corresponding operating environment software package can be directly and quickly obtained from the scenario-oriented operating environment application set. In this way, there is no need to use package management tools to install dependent software one by one, nor is there a need to repeatedly add software build systems to gradually confirm that the dependent software has been added completely, thereby solving the problem of embedded scenario development being too cumbersome and time-consuming.

[0018] As a possible implementation of the first aspect, the scenario-oriented operating environment application set is constructed as follows:

[0019] Determine the first operating environment of the application scenario;

[0020] Determine at least one first APP package on which the first operating environment depends;

[0021] Determine at least one first RPM package on which the first APP package depends;

[0022] Obtain the first RPM package and install it in the folder of the first APP package;

[0023] Install the first APP package after installation into the folder of the first operating environment;

[0024] Packing and compressing the folder of the first operating environment to form an operating environment software package;

[0025] A plurality of operating environment software packages are integrated to form the scenario-oriented operating environment application set.

[0026] As a possible implementation of the first aspect, generating a system image file according to the corresponding operating environment software package and the corresponding kernel compilation configuration file includes:

[0027] Use an image packaging tool to build a root file system according to the corresponding operating environment software package;

[0028] The kernel compilation configuration file and the root file system are packaged using an image packaging tool to generate a system image file.

[0029] As a possible implementation of the first aspect, the following also includes:

[0030] After selecting the hardware platform, the format of the system image file is selected.

[0031] As a possible implementation manner of the first aspect, the format of the system image file is an ISO installation image file or a burning image file.

[0032] To achieve the above-mentioned purpose, the second aspect of the present application provides an embedded operating system software configuration device, comprising:

[0033] A selection module is used to receive the operating environment required by the embedded application scenario to be used selected by the user;

[0034] An operating environment software package acquisition module, used to acquire a corresponding operating environment software package from a scenario-oriented operating environment application set based on the operating environment, wherein the scenario-oriented operating environment application set includes a plurality of operating environment software packages;

[0035] The selection module is also used to: receive a hardware platform selected by a user that is compatible with the corresponding operating environment software package;

[0036] A kernel compilation configuration file acquisition module is used to acquire a corresponding kernel compilation configuration file based on the hardware platform;

[0037] A system image file generation module, used to generate a system image file according to the corresponding operating environment software package and the corresponding kernel compilation configuration file;

[0038] The system image file installation module is used to install the system image file into the target machine.

[0039] As a possible implementation of the first aspect, the method further includes: an operating environment application set construction module, configured to construct the scenario-oriented operating environment application set in the following manner:

[0040] Determine the first operating environment of the application scenario;

[0041] Determine at least one first APP package on which the first operating environment depends;

[0042] Determine at least one first RPM package on which the first APP package depends;

[0043] Obtain the first RPM package and install it in the folder of the first APP package;

[0044] Install the first APP package after installation into the folder of the first operating environment;

[0045] Packing and compressing the folder of the first operating environment to form an operating environment software package;

[0046] A plurality of operating environment software packages are integrated to form the scenario-oriented operating environment application set.

[0047] As a possible implementation of the first aspect, the system image file generation module is specifically used to:

[0048] Use an image packaging tool to build a root file system according to the corresponding operating environment software package;

[0049] The kernel compilation configuration file and the root file system are packaged using an image packaging tool to generate a system image file.

[0050] A third aspect of the present application provides a computing device, including:

[0051] processor, and

[0052] A memory having program instructions stored thereon, wherein when the program instructions are executed by the processor, the processor executes any of the methods described in the first aspect above.

[0053] A fourth aspect of the present application provides a computer-readable storage medium having program instructions stored thereon, wherein when the program instructions are executed by a computer, the computer implements any of the methods described in the first aspect. BRIEF DESCRIPTION OF THE DRAWINGS

[0054] Figure 1 It is a flowchart of an embodiment of an embedded operating system software configuration method provided by an embodiment of the present application;

[0055] Figure 2 This is a schematic diagram of an operating environment selection and operating environment software package generation interface provided in an embodiment of the present application;

[0056] Figure 3 A schematic diagram of a hardware platform selection and system image file generation interface provided in an embodiment of the present application;

[0057] Figure 4 A flowchart for constructing a scenario-oriented operating environment application set provided in an embodiment of the present application;

[0058] Figure 5 A schematic diagram of a scenario-oriented operating environment application set provided in an embodiment of the present application;

[0059] Figure 6 A schematic diagram of a process of unpacking an ISO format image file and installing it to a corresponding hard disk provided in an embodiment of the present application;

[0060] Figure 7 A schematic diagram of a process of burning an image directly to the hard disk EMMC provided in an embodiment of the present application;

[0061] Figure 8 A schematic diagram of the QT operating environment flow for building the Tianqi EC_A3568J platform provided in the embodiment of the present application;

[0062] Fig. 9 A schematic diagram of a process for making an AI+ control operating environment image for the FT D2000 platform provided in an embodiment of the present application;

[0063] Fig.10 A structural schematic diagram of an embedded operating system software configuration device provided in an embodiment of the present application;

[0064] Fig.11 It is a structural schematic diagram of a computing device provided in an embodiment of the present application.

[0065] It should be understood that the size and shape of each block diagram in the above structural diagram are for reference only and should not constitute an exclusive interpretation of the embodiment of the present invention. The relative position and inclusion relationship between the blocks presented in the structural diagram are only schematic representations of the structural association between the blocks, and do not limit the physical connection method of the embodiment of the present invention. DETAILED DESCRIPTION

[0066] The technical solution provided by the present application is further described below with reference to the accompanying drawings and examples. It should be understood that the system structure and business scenarios provided in the examples of the present application are mainly to illustrate the possible implementation methods of the technical solution of the present application and should not be interpreted as the only limitation on the technical solution of the present application. It is known to those of ordinary skill in the art that with the evolution of the system structure and the emergence of new business scenarios, the technical solution provided by the present application is also applicable to similar technical problems.

[0067] It should be understood that the embedded operating system software configuration solution provided in the embodiments of the present application includes an embedded operating system software configuration method and device. Since the principles of solving the problems in these technical solutions are the same or similar, some repetitions may not be repeated in the introduction of the following specific embodiments, but it should be regarded as that these specific embodiments have been referenced to each other and can be combined with each other.

[0068] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as those commonly understood by those skilled in the art of the present application. In case of any inconsistency, the meaning described in this specification or the meaning derived from the contents recorded in this specification shall prevail. In addition, the terms used herein are only for the purpose of describing the embodiments of the present application and are not intended to limit the present application.

[0069] [Implementation example of embedded operating system software configuration method]

[0070] The present application provides an embedded operating system software configuration method, in which a user can configure the software set required by the system on a system configuration generation tool on the host side, and generate a system image file based on the configuration, thereby solving the problem that the existing technology is too cumbersome and time-consuming to develop and use for embedded scenarios.

[0071] Specifically, Figure 1 As shown, the method includes:

[0072] S110: receiving the operating environment required by the embedded application scenario to be used selected by the user;

[0073] S120: acquiring a corresponding operating environment software package from a scenario-oriented operating environment application set based on the selected operating environment, wherein the scenario-oriented operating environment application set includes a plurality of operating environment software packages;

[0074] S130: receiving a hardware platform selected by a user that is compatible with the corresponding operating environment software package;

[0075] S140: Obtaining a corresponding kernel compilation configuration file based on the selected hardware platform;

[0076] S150: Generate a system image file according to the corresponding operating environment software package and the corresponding kernel compilation configuration file;

[0077] S160: Install the system image file to the target machine.

[0078] In specific implementation, this application provides a selection page for the operating environment and hardware platform through a configuration menu, such as Figure 2 The following is the operating environment selection interface: Figure 3 Included is a page for selecting a hardware platform.

[0079] Before executing S120, it is necessary to first construct a scenario-oriented operating environment application set. Figure 4 As shown, the scenario-oriented operating environment application set is constructed as follows:

[0080] S410: Determine a first operating environment for the application scenario;

[0081] S420: Determine at least one first APP package on which the first operating environment depends;

[0082] S430: Determine at least one first RPM package on which the first APP package depends;

[0083] S440: Obtain the first RPM package and install it in the folder of the first APP package;

[0084] S450: Installing the first APP package after installation into a folder of the first operating environment;

[0085] S460: Pack and compress the folder of the first operating environment to form an operating environment software package;

[0086] S470: Integrate multiple operating environment software packages to form the scenario-oriented operating environment application set.

[0087] Among them, the operating environment software package is pre-compiled.

[0088] Specifically, the operating environment software package is a hierarchical structure in the management system, which is common in Linux systems. An example of the hierarchical structure is as follows:

[0089] 1.RPM (Red Hat Package Manager) package

[0090] RPM is a package management tool for Linux that can be used to install, update, and remove software packages. Each RPM package is an independent software package that contains one or more files (such as binary files, configuration files, etc.) and information about the software package (such as name, version number, dependencies, etc.). The RPM package is the smallest unit of the software package.

[0091] For example, an RPM package named libcurl might contain the curl library binary and associated header files.

[0092] 2. App package

[0093] An App package is a collection of software packages with specific functions. An App may contain one or more RPM packages, which together constitute a fully functional application.

[0094] (1) The composition of the App package is shown in Table 1:

[0095] Table 1

[0096] Install.App Installing the Shell Script App.info App package information license App License Information data / App package data

[0097] (2) App package data content: Install one or more RPMs into the data directory of the specified App package and record the RPM package information into App.info.

[0098] (3) App package format: App.info, data / , and install script are compressed to form a software package XXX.App.

[0099] For example, an App named web-server might include the httpd (Apache web server) RPM package and other RPM packages that depend on it, such as mod_ssl (SSL support module) and libcurl (library for processing URLs).

[0100] 3. Run (operating environment) package

[0101] A Run package is a collection of software that meets the needs of specific scenarios, collectively referred to as a set of operating environments. A set of operating environments consists of one or more apps, which together provide a complete set of functions.

[0102] (1) The composition of the Run package is shown in Table 2:

[0103] Table 2

[0104] Install.app Installing the Shell Script Run.info Run package information license Run License Information data / Run package data

[0105] (2) Run package data content: Install one or more App packages into the data directory of the specified Run package and record the App package information into Run.info.

[0106] (3) Compress Run.info, data / , and the install script to form the software package XXX.Run.

[0107] For example, a runtime environment named web-app-environment may contain the web-server App and other Apps such as database-server and cache-server.

[0108] Example description:

[0109] Suppose you want to build a simple web application server environment, which requires Apache web server, MySQL database server, and PHP interpreter. These components can be organized as follows:

[0110] RPM Cladding:

[0111] httpd: RPM package of Apache web server.

[0112] mysql-server: RPM package for the MySQL database server.

[0113] php: RPM package for the PHP interpreter.

[0114] mod_ssl: RPM package for SSL support module for Apache.

[0115] libcurl: RPM package of a library for processing URLs.

[0116] App layer:

[0117] The web-server App includes the httpd and mod_ssl RPM packages.

[0118] The database-server App includes the mysql-server RPM package.

[0119] php-app App contains the php RPM package.

[0120] Operating environment layer:

[0121] The web-app-environment runtime environment includes web-server, database-server, and php-appApps.

[0122] Organizing the packages in this way makes the entire system more modular and easier to manage. This structure is especially important in embedded scenarios because it helps ensure that all necessary packages are properly packaged into the ISO installation image and can be installed and configured even without a network connection.

[0123] Through the organization of the above software packages, it can be known that the formation process of the operating environment software package (Run package) - that is, the specific implementation process of S410 to S470 is as follows:

[0124] 1. Determine the requirements

[0125] Scenario analysis: First, clarify the operating environment to be built for the application scenario, such as the operating environment of graphical interface applications, multimedia playback, game development, etc.

[0126] Functional definition: Determine what functions are needed in the operating environment and list the corresponding APP packages.

[0127] 2. Collect APP packages

[0128] Select APP package: According to the operating environment requirements, select the appropriate APP package, such as SMPlayer.app, Wayland.app, openGL.app, QT 5.15.2.app, etc.

[0129] Verify compatibility: Ensure that the selected APP packages are compatible with each other and will not cause conflicts.

[0130] 3. Include RPM package

[0131] Analyze dependencies: For each selected APP package, analyze the RPM packages it contains and their dependencies.

[0132] Resolving dependencies: If some RPM packages are missing or the versions do not match, you need to find the appropriate RPM packages from the software source repository to meet the dependency requirements.

[0133] 4. Integration and testing

[0134] Integrate APP packages: Integrate and install the RPM packages contained in each APP package into each APP package, and then integrate and install the selected multiple APP packages together to form a unified runtime environment Run package.

[0135] Functional testing: Perform functional testing on the integrated operating environment to ensure that all components can work properly.

[0136] Performance testing: Test the overall performance of the operating environment, including startup speed, resource usage, etc.

[0137] 5. Packaging

[0138] Build a Run package: Use an appropriate packaging and compression tool (such as rpmbuild) to create a Run package, which includes all APP packages and their dependent RPM packages.

[0139] Integrate multiple Run packages into a scenario-oriented runtime environment application set that users can quickly select and configure. Figure 5 shown.

[0140] Then, when executing S120, you can Figure 5The operating environment application shown in the figure centrally obtains the operating environment software package corresponding to the operating environment required by the embedded application scenario to be used, and forms an operating system software set configuration file userdef_os.cfg. A configuration userdef_os1.cfg is a software list. The generated configuration is to generate a software list according to the user's selection. Figure 2 As shown, for example, for the display control scenario, you can select the QT5.15 operating environment software package and the hybrid key operating environment software package to form the configuration file userdef_os1.cfg. For the AI+ control scenario, you can select the AI ​​operating environment (Huawei Atlas300i) software package and the hybrid key operating environment software package to form the configuration file userdef_os2.cfg. For the display station scenario, you can select the LXQT lightweight desktop operating environment software package to form the configuration file userdef_os3.cfg.

[0141] In specific implementation, when executing S130, Figure 3 Select the hardware platform you need on the hardware platform selection interface included in the software package. The basis for selecting the hardware platform is compatibility with the selected operating environment software package. Different hardware platforms may have different architectures, such as x86_64 (common PC architecture), aarch64 (Arm 64-bit architecture), ppc64le (PowerPC 64-bit Little Endian architecture), etc. These different architectures have specific binary formats and instruction sets, so the software package must be compiled for a specific hardware platform to run properly.

[0142] After the user selects the hardware platform, the host side will execute S140, that is, based on the architecture and characteristics of the hardware platform selected by the user, select or compile a kernel compilation configuration file compatible with the hardware platform, and the kernel compilation configuration file is a pre-compiled file.

[0143] In some embodiments, it also includes:

[0144] After selecting the hardware platform, the format of the system image file is selected.

[0145] In some embodiments, the system image file is in a format of an ISO installation image file or a burning image file.

[0146] In specific implementation, after selecting the hardware platform to be adapted, there will be an additional system image file format option under "Hardware Platform Selection": ISO installation image file or burning image file. If the FT E2000 platform supports both, then two configurations (FT E2000 iso and FT E2000 img) can be generated. However, some hardware platforms can only use burning images.

[0147] In some embodiments, generating a system image file according to the corresponding operating environment software package and the corresponding kernel compilation configuration file includes:

[0148] Use an image packaging tool to build a root file system according to the corresponding operating environment software package;

[0149] The kernel compilation configuration file and the root file system are packaged using an image packaging tool to generate a system image file.

[0150] Specifically, the user configures the operating environment software package userdef_os.cfg, selects the configuration file compiled by the Linux kernel as the hardware platform, and then executes S150 to obtain the system image file, such as Figure 3 shown.

[0151] (1) Use the image packaging tool to generate a complete root file system (rootfs file system) based on the software list configured in userdef_os.cfg; this root file system contains everything required for the Linux kernel to run, including but not limited to:

[0152] User space programs (such as shells, editors, etc.)

[0153] System library files

[0154] Startup Script

[0155] Configuration Files

[0156] Other necessary files and directories

[0157] (2) Use the image packaging tool to package the root file system image file (rootfs) output in (1) and the configuration file compiled by the Linux kernel to generate an iso installation image (or a burning image, which is generally in the ARM embedded platform solidification system guide emmc format).

[0158] ISO installation image: If the target is a PC or server platform, an ISO file may be created from which the user can boot the installation system via a CD or USB flash drive.

[0159] Burning image: If it is for an embedded device (such as an ARM platform), a burning image file will be created, which is usually used to burn directly to a storage medium (such as an SD card or eMMC). This image file may also include a boot loader.

[0160] Finally, this packaged image file can be used as an installation medium, or burned directly to the storage medium of the embedded device for startup and operation.

[0161] Compared with tools such as buildroot and yocto, which take several hours or half a day to compile to generate an image, this application uses an image packaging tool to package the compiled runtime environment software package and kernel compilation configuration files, which can eliminate the compilation time and shorten the final image file generation time to within a few minutes.

[0162] In specific implementation, when executing S160, the installation process is different according to the format of the generated system image file. The system installation process of this application only partitions the hard disk, copies the system, and verifies it.

[0163] When the generated image file is an ISO format image file, unpack the ISO format image file through a USB flash drive and install it to the corresponding hard disk. The process is as follows: Figure 6 shown.

[0164] When the generated image file is a burn image file, the burn image is directly burned to the hard disk EMMC. The process is as follows Figure 7 shown.

[0165] This installation process is a common installation process in this field and is not described in detail in this application.

[0166] In summary, the present application can build a scenario-oriented operating environment application set in advance. After the user selects the operating environment and hardware platform required for the embedded application scenario, the corresponding operating environment software package can be directly and quickly obtained from the scenario-oriented operating environment application set. In this way, there is no need to use package management tools to install dependent software one by one, nor is there a need to repeatedly add software build systems to gradually confirm that the dependent software has been added completely, thereby solving the problem of embedded scenario development being too cumbersome and time-consuming.

[0167] This application provides two specific embodiments of building an XX operating environment for an XX platform.

[0168] First embodiment: Build the QT operating environment process of the Tianqi EC_A3568J platform, the specific process is shown in Figure 8:

[0169] a. Use the system configuration generation tool to select "QT 5.15 operating environment", obtain the operating environment software package corresponding to the "QT 5.15 operating environment", use the system configuration generation tool to select the hardware platform "Apocalypse EC_A3568J" that is compatible with the "QT 5.15 operating environment", obtain the kernel compilation configuration file of the hardware platform "Apocalypse EC_A3568J", and generate the system image QT 5.15_for_EC_A3568J.img according to the operating environment software package corresponding to the "QT5.15 operating environment" and the kernel compilation configuration file of "Apocalypse EC_A3568J";

[0170] b. Burn the QT 5.15_for_EC_A3568J.img image to the Tianqi EC_A3568J target board through the manufacturer's curing tool, and restart the device to enter the QT operating environment.

[0171] Second embodiment: the process of making an AI+ control operating environment image for the FT D2000 platform, the specific process is shown in Figure 9:

[0172] a. Use the system configuration generation tool to select "AI operating environment (Huawei Atlas300i)", "Hybrid key operating environment", obtain the operating environment software package corresponding to the "AI operating environment (Huawei Atlas300i)", "Hybrid key operating environment", use the system configuration generation tool to select the hardware platform "FT D2000 PC" compatible with the "AI operating environment (Huawei Atlas300i)", "Hybrid key operating environment", obtain the kernel compilation configuration file of the hardware platform "FT D2000 PC", and generate the system image AI_XXX_for_FTD2000.iso according to the operating environment software package corresponding to the "AI operating environment (Huawei Atlas300i)", "Hybrid key operating environment" and the kernel compilation configuration file of "FT D2000PC";

[0173] b. Use AI_XXX_for_FTD2000.iso image to install the system to the FTD2000 PC machine. After the installation is complete, restart the device to enter the AI+ control environment;

[0174] [Embodiment of the embedded operating system software configuration device of the present application]

[0175] like Fig.10 As shown, the embodiment of the present application provides an embedded operating system software configuration device, which can be used to implement the embedded operating system software configuration method in the above embodiment, such as Fig.10 As shown, the embedded operating system software configuration device comprises a selection module 101 , an operating environment software package acquisition module 102 , a kernel configuration file acquisition module 103 , a system image file generation module 104 , and a system image file installation module 105 .

[0176] The selection module 101 is used to receive the operating environment required by the embedded application scenario to be used selected by the user;

[0177] An operating environment software package acquisition module 102 is used to acquire a corresponding operating environment software package from a scenario-oriented operating environment application set based on the operating environment, wherein the scenario-oriented operating environment application set includes a plurality of operating environment software packages;

[0178] The selection module 101 is also used to: receive a hardware platform selected by a user that is compatible with the corresponding operating environment software package;

[0179] A kernel compilation configuration file acquisition module 103 is used to acquire a corresponding kernel compilation configuration file based on the hardware platform;

[0180] A system image file generating module 104, configured to generate a system image file according to the corresponding operating environment software package and the corresponding kernel compilation configuration file;

[0181] The system image file installation module 105 is used to install the system image file to the target machine.

[0182] In some embodiments, it further includes: an operating environment application set construction module, which is used to construct the scenario-oriented operating environment application set in the following manner:

[0183] Determine the first operating environment of the application scenario;

[0184] Determine at least one first APP package on which the first operating environment depends;

[0185] Determine at least one first RPM package on which the first APP package depends;

[0186] Obtain the first RPM package and install it in the folder of the first APP package;

[0187] Install the first APP package after installation into the folder of the first operating environment;

[0188] Packing and compressing the folder of the first operating environment to form an operating environment software package;

[0189] A plurality of operating environment software packages are integrated to form the scenario-oriented operating environment application set.

[0190] In some embodiments, the system image file generation module is specifically used to:

[0191] Use an image packaging tool to build a root file system according to the corresponding operating environment software package;

[0192] The kernel compilation configuration file and the root file system are packaged using an image packaging tool to generate a system image file.

[0193] For details, please refer to the detailed description in the method embodiment, which will not be repeated here.

[0194] [Embodiment of the computing device of the present application]

[0195] Fig.11900 is a schematic structural diagram of a computing device 900 provided in an embodiment of the present application. The computing device can be used as an embedded operating system software configuration device to execute the optional embodiments of the above embedded operating system software configuration method. The computing device can be a terminal or a chip or chip system inside the terminal. Fig.11 As shown, the computing device 900 includes: a processor 910 , a memory 920 , and a communication interface 930 .

[0196] It should be understood that Fig.11 The communication interface 930 in the computing device 900 shown may be used to communicate with other devices, and may specifically include one or more transceiver circuits or interface circuits.

[0197] The processor 910 may be connected to a memory 920. The memory 920 may be used to store the program code and data. Therefore, the memory 920 may be a storage unit inside the processor 910, or an external storage unit independent of the processor 910, or a component including a storage unit inside the processor 910 and an external storage unit independent of the processor 910.

[0198] Optionally, the computing device 900 may further include a bus. The memory 920 and the communication interface 930 may be connected to the processor 910 via the bus. The bus may be a Peripheral Component Interconnect (PCI) bus or an Extended Industry Standard Architecture (EISA) bus. The bus may be divided into an address bus, a data bus, a control bus, etc. For ease of representation, Fig.11 A line without an arrow is used to represent the bus, but this does not mean that there is only one bus or one type of bus.

[0199] It should be understood that in the embodiment of the present application, the processor 910 may adopt a central processing unit (CPU). The processor may also be other general-purpose processors, digital signal processors (DSP), application specific integrated circuits (ASIC), field programmable gate arrays (FPGA) or other programmable logic devices, discrete gates or transistor logic devices, discrete hardware components, etc. A general-purpose processor may be a microprocessor or the processor may also be any conventional processor, etc. Alternatively, the processor 910 may adopt one or more integrated circuits to execute relevant programs to implement the technical solutions provided in the embodiment of the present application.

[0200] The memory 920 may include a read-only memory and a random access memory, and provides instructions and data to the processor 910. A portion of the processor 910 may also include a nonvolatile random access memory. For example, the processor 910 may also store information on the device type.

[0201] When the computing device 900 is running, the processor 910 executes the computer-executable instructions in the memory 920 to perform any operation step of the above method and any optional embodiment thereof.

[0202] It should be understood that the computing device 900 according to the embodiment of the present application can correspond to the corresponding subjects in the methods according to the embodiments of the present application, and the above-mentioned and other operations and / or functions of each module in the computing device 900 are respectively for implementing the corresponding processes of each method of the present embodiment. For the sake of brevity, they will not be repeated here.

[0203] Those of ordinary skill in the art will appreciate that the units and algorithm steps of each example described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the technical solution. Professional and technical personnel can use different methods to implement the described functions for each specific application, but such implementation should not be considered to be beyond the scope of this application.

[0204] Those skilled in the art can clearly understand that, for the convenience and brevity of description, the specific working processes of the systems, devices and units described above can refer to the corresponding processes in the aforementioned method embodiments and will not be repeated here.

[0205] In the several embodiments provided in the present application, it should be understood that the disclosed systems, devices and methods can be implemented in other ways. For example, the device embodiments described above are only schematic. For example, the division of the units is only a logical function division. There may be other division methods in actual implementation, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of devices or units, which can be electrical, mechanical or other forms.

[0206] The units described as separate components may or may not be physically separated, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed on multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.

[0207] In addition, each functional unit in each embodiment of the present application may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit.

[0208] If the functions are implemented in the form of software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present application can be essentially or partly embodied in the form of a software product that contributes to the prior art. The computer software product is stored in a storage medium and includes several instructions for a computer device (which can be a personal computer, a server, or a network device, etc.) to perform all or part of the steps of the methods described in each embodiment of the present application. The aforementioned storage medium includes: various media that can store program codes, such as a USB flash drive, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk.

[0209] An embodiment of the present application also provides a computer-readable storage medium on which a computer program is stored. When the program is executed by a processor, it is used to execute the above method, which includes at least one of the solutions described in the above embodiments.

[0210] The computer storage medium of the embodiment of the present application can adopt any combination of one or more computer-readable media. Computer-readable media can be computer-readable signal media or computer-readable storage media. Computer-readable storage media can be, for example, but not limited to, electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems, devices or devices, or any combination of the above. More specific examples (non-exhaustive lists) of computer-readable storage media include: electrical connections with one or more wires, portable computer disks, hard disks, random access memories (RAM), read-only memories (ROM), erasable programmable read-only memories (EPROM or flash memory), optical fibers, portable compact disk read-only memories (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the above. In this document, computer-readable storage media can be any tangible medium containing or storing programs, which can be used by instruction execution systems, devices or devices or used in combination with them.

[0211] Computer-readable signal media may include data signals propagated in baseband or as part of a carrier wave, which carry computer-readable program code. Such propagated data signals may take a variety of forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the above. Computer-readable signal media may also be any computer-readable medium other than a computer-readable storage medium, which may send, propagate, or transmit a program for use by or in conjunction with an instruction execution system, apparatus, or device.

[0212] The program code embodied on the computer readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.

[0213] Computer program code for performing the operation of the present application can be written in one or more programming languages ​​or a combination thereof, including object-oriented programming languages, such as Java, Smalltalk, C++, and conventional procedural programming languages, such as "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as an independent software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the case of a remote computer, the remote computer can be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or can be connected to an external computer (e.g., using an Internet service provider to connect through the Internet).

[0214] In addition, the words "first, second, third, etc." or module A, module B, module C and other similar terms in the specification and claims are only used to distinguish similar objects and do not represent a specific ordering of the objects. It can be understood that the specific order or sequence can be interchanged where permitted so that the embodiments of the present application described herein can be implemented in an order other than that illustrated or described herein.

[0215] In the above description, the numbers representing the steps, such as S110, S120, etc., do not necessarily mean that the steps will be executed in this manner. If permitted, the order of the steps can be interchanged or they can be executed simultaneously.

[0216] The term "comprising" as used in the description and claims should not be interpreted as being limited to what is listed thereafter; it does not exclude other elements or steps. Therefore, it should be interpreted as specifying the presence of the features, integers, steps or components mentioned, but does not exclude the presence or addition of one or more other features, integers, steps or components and groups thereof. Therefore, the expression "a device comprising means A and B" should not be limited to a device consisting of components A and B only.

[0217] References to "one embodiment" or "an embodiment" in this specification mean that a particular feature, structure, or characteristic described in conjunction with the embodiment is included in at least one embodiment of the present application. Therefore, the phrases "in one embodiment" or "in an embodiment" appearing in various places in this specification do not necessarily refer to the same embodiment, but may refer to the same embodiment. In addition, in one or more embodiments, the particular features, structures, or characteristics can be combined in any appropriate manner, as would be apparent to one of ordinary skill in the art from this disclosure.

[0218] Note that the above are only preferred embodiments of the present application and the technical principles used. Those skilled in the art will understand that the present application is not limited to the specific embodiments described herein, and that various obvious changes, readjustments and substitutions can be made by those skilled in the art without departing from the scope of protection of the present application. Therefore, although the present application is described in more detail through the above embodiments, the present application is not limited to the above embodiments, and may also include more other equivalent embodiments without departing from the concept of the present application, all of which belong to the scope of protection of the present application.

Claims

1. A method for configuring embedded operating system software, characterized in that: include: Receive the operating environment required by the embedded application scenario to be used selected by the user; Based on the selected operating environment, obtaining a corresponding operating environment software package from a scenario-oriented operating environment application set, wherein the scenario-oriented operating environment application set includes a plurality of operating environment software packages; Receiving a hardware platform selected by a user that is compatible with the corresponding operating environment software package; Acquire a corresponding kernel compilation configuration file based on the selected hardware platform; Generate a system image file according to the corresponding operating environment software package and the corresponding kernel compilation configuration file; Install the system image file to the target machine.

2. The method according to claim 1, characterized in that The scenario-oriented operating environment application set is constructed as follows: Determine the first operating environment of the application scenario; Determine at least one first APP package on which the first operating environment depends; Determine at least one first RPM package on which the first APP package depends; Obtain the first RPM package and install it in the folder of the first APP package; Install the first APP package after installation into the folder of the first operating environment; Packing and compressing the folder of the first operating environment to form an operating environment software package; Integrate multiple operating environment software packages to form the scenario-oriented operating environment application set.

3. The method according to claim 1, characterized in that The generating of the system image file according to the corresponding operating environment software package and the corresponding kernel compilation configuration file comprises: Use an image packaging tool to build a root file system according to the corresponding operating environment software package; The kernel compilation configuration file and the root file system are packaged using an image packaging tool to generate a system image file.

4. The method according to claim 1 or 3, characterized in that Also includes: After selecting the hardware platform, the format of the system image file is selected.

5. The method according to claim 4, characterized in that The format of the system image file is an ISO installation image file or a burning image file.

6. An embedded operating system software configuration device, characterized in that: include: A selection module is used to receive the operating environment required by the embedded application scenario to be used selected by the user; An operating environment software package acquisition module, used to acquire a corresponding operating environment software package from a scenario-oriented operating environment application set based on the operating environment, wherein the scenario-oriented operating environment application set includes a plurality of operating environment software packages; The selection module is also used to: receive a hardware platform selected by a user that is compatible with the corresponding operating environment software package; A kernel compilation configuration file acquisition module is used to acquire a corresponding kernel compilation configuration file based on the hardware platform; A system image file generation module, used to generate a system image file according to the corresponding operating environment software package and the corresponding kernel compilation configuration file; The system image file installation module is used to install the system image file into the target machine.

7. The device according to claim 6, characterized in that Also includes: The operating environment application set construction module is used to construct the scenario-oriented operating environment application set in the following manner: Determine the first operating environment of the application scenario; Determine at least one first APP package on which the first operating environment depends; Determine at least one first RPM package on which the first APP package depends; Obtain the first RPM package and install it in the folder of the first APP package; Install the first APP package after installation into the folder of the first operating environment; Packing and compressing the folder of the first operating environment to form an operating environment software package; Integrate multiple operating environment software packages to form the scenario-oriented operating environment application set.

8. The device according to claim 6, characterized in that The system image file generation module is specifically used for: Use an image packaging tool to build a root file system according to the corresponding operating environment software package; The kernel compilation configuration file and the root file system are packaged using an image packaging tool to generate a system image file.

9. A computing device, characterized in that include: processor, and A memory having program instructions stored thereon, wherein when the program instructions are executed by the processor, the processor is caused to execute the method according to any one of claims 1 to 5.

10. A computer-readable storage medium, characterized in that: Program instructions are stored thereon, and when the program instructions are executed by a computer, the computer is caused to execute the method according to any one of claims 1 to 5.

Images