EIT windowless desktop construction method and EIT device

Abstract

This application provides a method for building an EIT windowless desktop, including: an ARM Linux device obtaining a support library from a library on which Qt depends by obtaining instructions; the ARM Linux device synchronizing the support library to an X86 Linux device; the X86 Linux device editing a cross-compiler to obtain a Qt build kit so that the Qt build kit has the dependencies required by a preset windowless rendering plug-in; the X86 Linux device installing the support library on which the Qt framework depends so that users can develop EIT-compatible application software based on the Qt framework; the X86 Linux device compiling the application software and the preset windowless rendering component using a cross-compiler to obtain an executable program for the application software; and the ARM Linux device deploying the Qt build kit and the executable program on the ARM Linux device. This application can reduce memory usage and enable the EIT device to have good interactive effects.

Description

Technical Field

[0001] The present application relates to the medical field, and in particular to an EIT windowless desktop construction method and EIT equipment. Background Art

[0002] Traditional embedded desktop applications rely on the window manager and desktop environment provided by the operating system. They control the appearance and position of windows and provide users with methods to operate these window programs. They often take up a large amount of memory, through which users can operate the entire desktop environment. On embedded customized devices, the memory usage needs to be as small as possible, and users are not allowed to operate any programs except the current customized software.

[0003] Embedded devices have limited resources. Even modern embedded device CPU cores are far inferior to those of PCs. Traditional embedded applications render on the CPU, further straining limited CPU resources. This is particularly noticeable when implementing animation effects, causing them to freeze or even render the entire software unresponsive. Some modern embedded devices incorporate graphics processing units (GPUs). This invention utilizes GPUs to improve and optimize these issues.

[0004] In terms of engineering, the mainstream development language for embedded platforms is C / C++. Due to the process-oriented nature of C, some tools that can only be developed in C are not conducive to engineering. Some tools with fewer users have relatively inactive technical communities, which is not conducive to the exchange and resolution of technical problems. Summary of the Invention

[0005] In view of this, it is necessary to provide a method for constructing an EIT windowless desktop with good interactive effect and an EIT device.

[0006] In a first aspect, an embodiment of the present application provides a method for constructing an EIT windowless desktop, the method comprising the following steps: an ARM linux device obtains a corresponding support library from a library on which Qt depends through a preset acquisition instruction, the ARM linux device being installed with the library on which Qt depends; the ARM linux device synchronizing the support library to an X86 linux device in communication with the ARM linux device, the X86 linux device being installed with a cross-compiler for enabling software developed by the X86 linux device to be executed in the ARM linux device; the X86 linux device editing the cross-compiler in response to a user operation to obtain a Qt build kit so that the Qt build kit has the dependencies required by a preset windowless rendering plug-in, the windowless rendering plug-in being used to implement windowless operation of a program; the X86 linux device installing the support library on which the Qt framework depends in response to a user operation so that the user can develop EIT-supported application software based on the Qt framework; the X86 linux device compiling the application software and the preset windowless rendering component through the cross-compiler to obtain an executable program of the application software; the ARM The Linux device deploys the Qt construction kit and the executable program on the ARM Linux device in response to the user operation.

[0007] In a second aspect, embodiments of the present application provide an EIT device, comprising a computer-readable storage medium and a processor. The computer-readable storage medium is configured to store a Qt building kit and an executable program, the Qt building kit and the executable program being obtained using the aforementioned method for constructing an EIT windowless desktop. The processor utilizes the Qt building kit to execute the executable program to implement windowless display on a display screen of the EIT device.

[0008] The above-mentioned EIT windowless desktop construction method uses a preset windowless rendering component to remove the dependence on the actual window, thereby solving the problem of high memory usage. By installing the preset windowless rendering component on the EIT, the preset windowless rendering component sends instructions to instruct the GPU to render, thereby alleviating the problem of excessive CPU computing resource usage.

[0009] The above-mentioned EIT device can realize a windowless desktop on the display screen of the EIT device by running the executable program using the Qt construction kit. BRIEF DESCRIPTION OF THE DRAWINGS

[0010] In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the following briefly introduces the drawings required for use in the embodiments or the description of the prior art. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on the structures shown in these drawings without paying any creative work.

[0011] Figure 1 This is a flowchart of a method for constructing an EIT windowless desktop provided in an embodiment of the present application.

[0012] Figure 2 This is a first sub-flowchart of the method for constructing an EIT windowless desktop provided in an embodiment of the present application.

[0013] Figure 3 This is a second sub-flowchart of the method for constructing an EIT windowless desktop provided in an embodiment of the present application.

[0014] Figure 4 This is the third sub-flowchart of the method for constructing the EIT windowless desktop provided in an embodiment of the present application.

[0015] Figure 5 Schematic diagram of the internal structure of the EIT device provided in an embodiment of the present application.

[0016] The realization of the objectives, functional features and advantages of this application will be further explained in conjunction with embodiments and with reference to the accompanying drawings. DETAILED DESCRIPTION

[0017] In order to make the purpose, technical solutions and advantages of this application more clear, the present application is further described in detail below with reference to the accompanying drawings and examples. It should be understood that the specific embodiments described herein are only used to explain this application and are not intended to limit this application. Based on the embodiments in this application, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of this application.

[0018] The terms "first," "second," "third," "fourth," and the like (if any) in the specification and claims of this application and in the accompanying drawings are used to distinguish similar program objects and are not necessarily used to describe a particular order or precedence. It should be understood that the terms used in this manner are interchangeable where appropriate. In other words, the described embodiments are implemented according to an order other than that illustrated or described herein. In addition, the terms "including" and "having," and any variations thereof, may also encompass other content. For example, a process, method, system, product, or apparatus comprising a series of steps or units need not be limited to only those steps or units explicitly listed, but may include other steps or units that are not explicitly listed or that are inherent to these processes, methods, products, or apparatus.

[0019] It should be noted that the descriptions of "first", "second", etc. in this application are for descriptive purposes only and should not be understood as indicating or implying their relative importance or implicitly indicating the number of the indicated technical features. Therefore, the features defined as "first" or "second" may explicitly or implicitly include one or more of the features. In addition, the technical solutions between the various embodiments can be combined with each other, but this must be based on the fact that ordinary technicians in this field can implement them. When the combination of technical solutions is contradictory or cannot be implemented, it should be deemed that such a combination of technical solutions does not exist and is not within the scope of protection required by this application.

[0020] Please refer to Figure 1 , which is a flow chart of a method for constructing an EIT windowless desktop provided by an embodiment of the present application. The method for constructing an EIT windowless desktop specifically includes the following steps S102-S112.

[0021] In step S102, the ARM Linux device obtains the corresponding support library from the library on which Qt depends through a preset acquisition instruction. The ARM Linux device has the library on which Qt depends installed. It is understandable that the user enters the library directory on which Qt depends on the ARM Linux device through the sudoapt-getinstall'.*libxcb.*'libxrender-dev libxi-devlibfontconfig1-dev libudev-dev instruction on the ARM Linux device, and then soft-links the OpenGL ES library through the sudoln-s libGLESv2_nvidia.so.2 libGLESv2.so instructions and the sudoln-slibEGL_nvidia.so.0libEGL.so instructions to obtain the corresponding support library.

[0022] In step S104, the ARM Linux device synchronizes the support library with an X86 Linux device that is communicatively connected to the ARM Linux device. The X86 Linux device is installed with a cross-compiler that enables software developed on the X86 Linux device to be executed on the ARM Linux device. It is understood that after the user obtains the support library from the ARM Linux device, the user establishes a communication connection between the ARM Linux device and the X86 Linux device so that they are in the same local area network. This facilitates subsequent synchronization of the support library on the ARM Linux device with the X86 Linux device via instructions. After the user establishes the same local area network with the ARM Linux device, the user uses a synchronization instruction to synchronize the support library on the ARM Linux device with the X86 Linux device that is communicatively connected to the ARM Linux device. In this embodiment, the synchronization instruction uses the rsync -e ssh -avzxxx instruction.

[0023] In step S106, the X86 Linux device edits the cross-compiler in response to the user operation to obtain the Qt construction kit so that the Qt construction kit has the dependencies required for the preset windowless rendering plug-in, and the windowless rendering plug-in is used to realize the windowless operation of the program. It can be understood that the user creates a folder on the X86 Linux device for receiving the support library synchronized from the ARMlinux, and the user creates the script file and path file of the support library under the folder of the support library. The user sets the rules for the support library in the script file and describes the dependencies of the rendering plug-in. The path is used to store the ARM support library and header files. The user executes the script to obtain the compilation rules and uses the cross-compiler to build the Qt construction kit. The specific method is described below. In this embodiment, the preset windowless rendering plug-in is an EGLFS plug-in.

[0024] In step S108, the X86 Linux device installs the support libraries that the Qt framework relies on in response to the user's operation, allowing the user to develop EIT-compatible application software based on the Qt framework. It is understood that the user adds the support libraries that the Qt framework relies on to the development environment, allowing the developer to complete the development of EIT-compatible application software under the Qt framework, so that the developed application software for the EIT device can run normally under the Qt framework.

[0025] In step S110, the X86 Linux device compiles the application software and the preset windowless rendering component using the cross-compiler to obtain an executable program for the application software. It is understood that the developer uses the cross-compiler on the X86 Linux device to compile the Qt build kit obtained in step S106 with the application software developed under the Qt framework for the EIT device to obtain the executable program for the application software for the EIT device. In other words, the cross-compiler compiles the EGLFS plug-in in the Qt build kit with the application developed under the Qt framework, thereby obtaining the executable program for the application software for the EIT device, where the Qt framework includes the Quick framework.

[0026] In step S112, the ARM Linux device deploys the Qt Building Kit and the executable program on the ARM Linux device in response to the user operation. It is understood that the user deploys the Qt Building Kit and the executable program created on the X86 Linux device on the ARM Linux device. The ARM Linux device implements a windowless management desktop on the EIT based on the received Qt Building Kit and the executable program.

[0027] In the above embodiment, the ARM Linux device can be a Jetson Nano device used in the EIT product, and the corresponding X86 Linux device is a development machine. By using the EGLFS plug-in to remove the actual window system, the problem of high memory usage is solved. The EGLFS plug-in is installed on the EIT and sends instructions to the GPU for rendering, thereby alleviating the problem of excessive CPU computing resource usage.

[0028] Please refer to Figure 2 , which is the first sub-flowchart of the method for constructing the EIT windowless desktop provided by the embodiment of the present application. Step S106 specifically includes the following steps S202-S212.

[0029] In step S202, the X86 Linux device simulates the ARM Linux device to create a folder. It can be understood that the user creates a folder on the X86 Linux device, and the folder is used to store files such as support libraries that are subsequently synchronized from the ARM Linux device.

[0030] In step S204, the X86 Linux device creates a directory file in the folder in response to the user operation, wherein the directory file defines the root directory of the simulation. It is understandable that the user creates a directory file in the folder on the X86 Linux device, and the directory file is used to store the results of subsequent Qt source code compilation.

[0031] In step S206, the X86 Linux device modifies the qmake.conf file in response to the user operation to define the dependencies required for the preset windowless rendering plug-in. The dependencies include dependency libraries required for compilation, GPU dependency libraries, and Qt dependency libraries. It is understood that the user creates a folder on the X86 Linux device to store the support libraries and the rules defining the preset windowless rendering plug-in, and modifies the path information in the qmake.conf file in the Qt source code directory to retain the path information for the required support libraries and the dependencies required to define the preset windowless rendering plug-in.

[0032] In step S208, the X86 Linux device executes the qmake.conf file to generate a qmakefile. It is understood that the user executes the modified qmake.conf file, which contains the support library and the rules defining the preset windowless rendering plug-in, using the command sudo . / autoconfig to generate the qmakefile. The qmakefile is used to store the parameter information required by the support library and the preset windowless rendering plug-in.

[0033] In step S210, the X86 Linux device compiles the Qt source code to obtain a compilation result. It is understandable that the compilation instruction compiles the qmakefile file, the compilation file for storing the support library and defining the rules of the preset windowless rendering plug-in, and the qmake.conf file storing the path information together to obtain the compilation result of the Qt source code.

[0034] In step S212, the X86 Linux device installs the compilation results into the simulated root directory defined in the directory file to form the Qt build kit. It is understood that the X86 Linux device stores the compilation results obtained in step S210 in the directory file in step S204. The X86 Linux device combines the compiled Qt source code with the user-specified compiler tool to form the Qt build kit, and the user-specified compiler tool is used to compile the Qt source code.

[0035] Please refer to Figure 3, which is the second sub-flowchart of the method for constructing the EIT windowless desktop provided by the embodiment of the present application. After step S112, the following steps S302-S304 are specifically included.

[0036] In step S302, the ARM Linux device deploys the Qt Building Kit to the system path of the ARM Linux device in response to the user operation. It is understood that the user deploys the Qt Building Kit deployed on the X86 Linux device to the system path of the ARM Linux device, so that the Qt Building Kit can be called regardless of the file location of the software program applied to the EIT.

[0037] In step S304, the ARM Linux device configures the environment variables of the libraries in the Qt Build Kit according to the environment variable configuration instructions so that the libraries in the Qt Build Kit are effective on the ARM Linux device. It is understandable that after the user deploys the Qt Build Kit to the ARM Linux device, it is necessary to configure the environment variables of the Qt Build Kit's runtime environment, particularly the environment variables of the preset windowless rendering plug-in in the Qt Build Kit. Once the user has configured the environment variables of the Qt Build Kit's runtime environment, the Qt Build Kit can run normally on the ARM Linux device.

[0038] Please refer to Figure 4 , which is the third sub-flowchart of the method for constructing the EIT windowless desktop provided by the embodiment of the present application. Step S104 specifically includes the following steps S402-S404.

[0039] Step S402: The X86 Linux device verifies whether the cross compiler is installed. It is understandable that when synchronizing the support library on the ARM Linux device, the user needs to check whether the cross compiler is installed on the X86 Linux device to prevent malfunctions during operation after synchronizing the support library on the ARM Linux device to the X86 Linux device.

[0040] Step S404: When the cross-compiler is not installed on the X86 Linux device, the X86 Linux device installs the cross-compiler according to the installation instruction. It is understandable that after the user verifies on the X86 Linux device that the cross-compiler is not installed, the user can install the cross-compiler by following the installation instruction or by downloading it from the official website. The installation instruction is sudo apt-get install gcc-aarch64-linux-gnu.

[0041] Please refer to Figure 5 , which is a schematic diagram of the internal structure of an EIT device provided in an embodiment of the present application. The EIT device 10 includes a computer-readable storage medium 11, a processor 12, and a bus 13. The computer-readable storage medium 11 is used to store the Qt building kit and executable programs and includes at least one type of readable storage medium, including flash memory, a hard disk, a multimedia card, a card-type memory (e.g., SD or DX memory), a magnetic storage device, a magnetic disk, an optical disk, and the like. In some embodiments, the computer-readable storage medium 11 may be an internal storage unit of the EIT device 10, such as the hard disk of the EIT device 10. In other embodiments, the computer-readable storage medium 11 may also be an external storage device of the EIT device 10, such as a plug-in hard disk, a Smart Media Card (SMC), a Secure Digital (SD) card, a flash memory card, and the like. Furthermore, the computer-readable storage medium 11 may include both internal storage units of the EIT device 10 and external storage devices. The computer-readable storage medium 11 can be used not only to store application software installed in the EIT device 10 and various data, but also to temporarily store data that has been output or is to be output.

[0042] The bus 13 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, Figure 5 Only one thick line is used in the diagram, but this does not mean that there is only one bus or one type of bus.

[0043] Furthermore, the EIT device 10 may include a display component 14. The display component 14 may be a light-emitting diode (LED) display, a liquid crystal display (LCD), a touch-sensitive liquid crystal display (LCD), or an organic light-emitting diode (OLED) touchscreen. The display component 14 may also be appropriately referred to as a display device or a display unit, and is used to display information processed in the EIT device 10 and to display a visual user interface.

[0044] Furthermore, the EIT device 10 may further include a communication component 15. The communication component 15 may optionally include a wired communication component and / or a wireless communication component, such as a WI-FI communication component, a Bluetooth communication component, etc., and is generally used to establish a communication connection between the EIT device 10 and other intelligent control devices.

[0045] In some embodiments, the processor 12 can be a central processing unit (CPU), a controller, a microcontroller, a microprocessor, or other data processing chip, and is configured to execute program code or process data stored in the computer-readable storage medium 11. The processor 12 utilizes the Qt building kit to run the executable program. Specifically, the processor 12 executes the processing program to control the EIT device 10 to implement the method for building an EIT windowless desktop.

[0046] Understandably, Figure 5 Only the EIT device 10 having components 11-15 and a method for constructing an EIT windowless desktop is shown. It can be understood by those skilled in the art that Figure 5 The illustrated structure does not limit the EIT device 10 , and the EIT device 10 may include fewer or more components than shown, or may combine certain components, or arrange the components differently.

[0047] Obviously, those skilled in the art may make various modifications and variations to this application without departing from the spirit and scope of this application. Thus, if such modifications and variations fall within the scope of the claims of this application and their equivalents, this application is intended to include such modifications and variations.

[0048] The above examples are merely preferred embodiments of the present application and are not intended to limit the scope of the present application. Therefore, equivalent changes made according to the claims of the present application are still within the scope of the present application.

Claims

1. A method for constructing an EIT windowless desktop, wherein the EIT is installed with an ARM Linux device and includes a GPU, characterized in that: The method for constructing the EIT windowless desktop includes: The ARM Linux device obtains the corresponding support library from the library on which Qt depends through a preset acquisition instruction, and the ARM Linux device is installed with the library on which Qt depends; The ARM Linux device synchronizes the support library to an X86 Linux device that is communicatively connected to the ARM Linux device, wherein the X86 Linux device is installed with a cross compiler for enabling software developed by the X86 Linux device to be executed in the ARM Linux device; The X86 Linux device edits the cross-compiler in response to a user operation to obtain a Qt build kit so that the Qt build kit has dependencies required by a preset windowless rendering plug-in, wherein the windowless rendering plug-in is used to implement windowless operation of the program; The X86 Linux device installs the support library that the Qt framework relies on in response to the user operation so that the user can develop EIT supporting application software based on the Qt framework; The X86 Linux device compiles the application software and the preset windowless rendering component through the cross compiler to obtain an executable program of the application software; The ARM Linux device deploys the Qt construction kit and the executable program on the ARM Linux device in response to a user operation.

2. The method for constructing an EIT windowless desktop according to claim 1, wherein: The preset acquisition instructions include the sudoapt-getinstall'.*libxcb.*'libxrender-devlibxi-devlibfontconfig1-devlibudev-dev instruction, the sudoln-slibGLESv2_nvidia.so.2libGLESv2.so instruction, and the sudoln-slibEGL_nvidia.so.0libEGL.so instruction. The ARM Linux device obtains the corresponding support library from the library that Qt depends on through the preset instructions, including: The ARM Linux device enters the library directory on which Qt of the ARM Linux device depends through the sudoapt-getinstall'.*libxcb.*'libxrender-devlibxi-devlibfontconfig1-devlibudev-dev instruction; The ARM Linux device soft-links the opengles library through the sudoln-slibGLESv2_nvidia.so.2libGLESv2.so instruction and the sudoln-slibEGL_nvidia.so.0libEGL.so instruction to obtain the corresponding support library.

3. The method for constructing an EIT windowless desktop according to claim 1, wherein: The ARM linux device synchronizes the support library to the X86 linux device that is communicatively connected to the ARM linux device, including: synchronizing the support library to the X86 linux device that is communicatively connected to the ARM linux device through a preset synchronization instruction, wherein the preset instruction includes an rsync-essh-avzxxx instruction.

4. The method for constructing an EIT windowless desktop according to claim 1, wherein: The X86 Linux device includes a qmake.conf file in a Qt source code directory. The X86 Linux device edits the cross-compiler in response to a user operation to obtain a Qt build kit so that the Qt build kit has a preset windowless rendering plug-in. The required dependencies include: The X86 Linux device simulates the ARM Linux device to create a folder; The X86 Linux device creates a directory file in the folder in response to a user operation, wherein the directory file defines a simulated root directory; The X86 Linux device modifies the qmake.conf file in response to a user operation to define dependencies required by a preset windowless rendering plug-in, wherein the dependencies include dependency libraries required for compilation, GPU dependency libraries, and Qt dependency libraries; The X86 Linux device executes the qmake.conf file to obtain a qmakefile file; The X86 Linux device compiles the Qt source code to obtain a compilation result; The X86 Linux device installs the compilation result into the simulation root directory defined by the directory file to form the Qt construction kit.

5. The method for constructing an EIT windowless desktop according to claim 1, wherein: The preset windowless rendering plug-in is an EGLFS plug-in, and the Qt framework includes a Quick framework.

6. The method for constructing an EIT windowless desktop according to claim 1, wherein: The ARM Linux device is the Jetson nano device used in EIT products, and the X86 Linux device is a development machine.

7. The method for constructing an EIT windowless desktop according to claim 1, wherein: The method further comprises: The ARM Linux device deploys the Qt build kit to the system path of the ARM Linux device in response to the user operation; The ARM Linux device configures the environment variables of the library in the Qt construction kit according to the environment variable configuration instruction so that the library in the Qt construction kit is effective on the ARM Linux device.

8. The method for constructing an EIT windowless desktop according to claim 1, wherein: Before the ARM Linux device synchronizes the support library to the X86 Linux device that is communicatively connected to the ARM Linux device, the following steps are specifically included: The ARM Linux device establishes a communication connection with the X86 Linux device so as to be in the same local area network.

9. The method for constructing an EIT windowless desktop according to claim 1, wherein: Before the ARM Linux device synchronizes the support library to the X86 Linux device that is communicatively connected to the ARM Linux device, the method further specifically includes: The X86 Linux device verifies whether the cross compiler is installed; When the X86 Linux device does not have the cross compiler installed, the X86 Linux device installs the cross compiler according to an installation instruction.

10. An EIT device, characterized in that: The EIT equipment specifically includes: A computer-readable storage medium for storing a Qt construction kit and an executable program, wherein the Qt construction kit and the executable program are generated according to the method for constructing the EIT windowless desktop according to any one of claims 1 to 9; and The processor uses the Qt construction kit to run the executable program to achieve windowless display on the EIT device display screen.

Images