LoongArch platform-oriented industrial monitoring Qt development platform construction method

Abstract

The application relates to the technical field of industrial automation, in particular to a LoongArch platform-oriented industrial monitoring Qt development platform construction method, which comprises the following steps: on a host development platform, obtaining platform parameters and application parameters corresponding to a target industrial monitoring scene; based on the platform parameters, constructing a Qt project structure compatible with the target LoongArch platform according to a LoongArch platform construction rule; based on the application parameters, integrating an interface module, a data acquisition module and an alarm processing module corresponding to an industrial monitoring application in the Qt project structure; according to the platform parameters, configuring a Qt compilation environment and cross-compilation parameters matched with the target LoongArch platform; based on the compilation environment, compiling the Qt project structure to generate a Qt application program suitable for running on the target LoongArch platform; further comprising the following steps: deploying the Qt application program to the target LoongArch platform.

Description

Technical Field

[0001] This invention relates to the field of industrial automation technology, specifically to a method for building an industrial monitoring Qt development platform for the LoongArch platform. Background Technology

[0002] As industrial automation systems increasingly demand visualization and intelligent operation and maintenance, more and more industrial monitoring terminals need to have graphical user interfaces (GUIs) to enable functions such as real-time data display, abnormal alarm prompts, and interactive control of equipment.

[0003] However, in industrial applications based on the LoongArch platform, the Qt framework still faces adaptation difficulties in areas such as cross-compilation, dynamic linking, and ABI compatibility due to its relatively immature software ecosystem. Furthermore, existing Qt development tools are primarily geared towards general desktop applications and lack support for functions such as multi-sensor integration, alarm logic configuration, and driver binding in industrial scenarios, making it difficult to meet the rapid development needs of industrial monitoring applications on the LoongArch platform. Summary of the Invention

[0004] In a first aspect, the present invention provides a method for building an industrial monitoring Qt development platform for the LoongArch platform, comprising the following steps:

[0005] Obtain the platform parameters and application parameters corresponding to the target industrial monitoring scenario. The platform parameters include the target LoongArch platform information, and the application parameters include the industrial monitoring scenario and the sensor configuration requirements under this industrial monitoring scenario.

[0006] On the host development platform, a Qt application is generated based on the platform parameters and the application parameters, and then the Qt application is deployed to the target LoongArch platform. The Qt application is generated through the following steps:

[0007] Based on the platform parameters, and in accordance with the LoongArch platform construction rules, a Qt project structure compatible with the target LoongArch platform is constructed.

[0008] Based on the application parameters, an interface module, a data acquisition module, and an alarm processing module corresponding to the industrial monitoring application are integrated into the Qt engineering structure.

[0009] Configure the Qt compilation environment and cross-compilation parameters that match the target LoongArch platform according to the platform parameters;

[0010] The Qt project structure is compiled based on the aforementioned compilation environment to generate a Qt application suitable for running on the target LoongArch platform.

[0011] In some embodiments, within the Qt development environment of the host development platform, the step of constructing a Qt project structure compatible with the target LoongArch platform based on the platform parameters and according to the LoongArch platform construction rules includes the following steps:

[0012] Create an initial Qt project structure;

[0013] A LoongArch plugin is provided, which is integrated into the Qt development environment to perform project build control related to the LoongArch platform;

[0014] The LoongArch plugin parses the platform parameters to obtain the architecture feature information corresponding to the target LoongArch platform;

[0015] Based on the architectural features of the target LoongArch platform, the build rules that match the target LoongArch platform are called from the LoongArch plugin;

[0016] Based on the aforementioned construction rules, the configuration of the initial Qt project structure is reconstructed to generate a Qt project structure compatible with the target LoongArch platform.

[0017] In some embodiments, the LoongArch plugin has a pre-defined mapping relationship between architectural feature information and build rules, and the LoongArch plugin executes the call to the build rules in the following manner:

[0018] Based on the architectural feature information corresponding to the target LoongArch platform, at least two interrelated construction rules are obtained;

[0019] The constraint and conflict relationships between the at least two interrelated construction rules are analyzed, and the priority of each construction rule in the at least two interrelated construction rules is determined.

[0020] Based on the parsing results and priority results, the initial Qt project structure is collaboratively reconstructed so that the generated Qt project structure can simultaneously satisfy the operational constraints corresponding to at least two interrelated construction rules.

[0021] In some embodiments, determining the priority of each of the at least two interrelated build rules includes the following steps:

[0022] Under the target industrial monitoring scenario, obtain the operation requirements parameters of the Qt application, which include at least response timeliness, operation reliability and resource utilization.

[0023] The runtime requirement parameters are mapped to weight factors of the corresponding construction rules, and the priority of each construction rule among the at least two construction rules is determined based on the priority calculation model and the correlation matrix between the weight factors and each construction rule.

[0024] In some embodiments, any one of the construction rules includes at least ABI compatibility rules, module linking rules, resource organization rules, and driver interface encapsulation rules.

[0025] In some embodiments, the host development platform is a computer system based on x86 architecture or ARM architecture.

[0026] In some embodiments, the Qt development environment within the host development platform is Qt Creator, and the LoongArch plugin is embedded in Qt Creator as a plugin module.

[0027] In some embodiments, the platform parameters include the instruction set architecture information, processor model, operating system version, and supported ABI interface types of the target LoongArch platform.

[0028] The application parameters include the industrial monitoring scenario type, sensor type and quantity, required data refresh cycle, and alarm strategy configuration items.

[0029] Secondly, the present invention also provides a computer-readable storage medium having a computer program stored thereon, wherein when the computer program is executed by a processor, it implements a method for constructing an industrial monitoring Qt development platform for the LoongArch platform.

[0030] Thirdly, the present invention also provides an industrial monitoring Qt development platform construction system for the LoongArch platform, including a processor and a memory, wherein the memory stores a computer program, and when the computer program is executed by the processor, it performs the following functions:

[0031] Obtain the platform parameters and application parameters corresponding to the target industrial monitoring scenario;

[0032] Based on the platform parameters, and in accordance with the LoongArch platform construction rules, a Qt project structure compatible with the target LoongArch platform is constructed.

[0033] Based on the application parameters, an interface module, a data acquisition module, and an alarm processing module corresponding to the industrial monitoring application are integrated into the Qt engineering structure.

[0034] Configure the Qt compilation environment and cross-compilation parameters that match the target LoongArch platform according to the platform parameters;

[0035] The Qt project structure is compiled based on the aforementioned compilation environment to generate a Qt application suitable for running on the target LoongArch platform.

[0036] The industrial monitoring Qt development platform construction method, computer-readable storage medium, and system for the LoongArch platform provided by this invention have the following benefits:

[0037] This invention integrates the LoongArch plugin into the host development platform to automatically parse platform parameters such as the processor model, operating system version, and ABI interface of the target platform, and matches the build rules accordingly. This eliminates the tedious operation of developers manually configuring the compilation environment, linking parameters, and compatibility strategies, effectively improving build efficiency and system stability.

[0038] Furthermore, the present invention can automatically retrieve the build rules that match the target LoongArch platform based on the platform parameters, and restructure the structure based on the initial Qt project structure, thereby generating a project configuration with complete runtime compatibility;

[0039] Furthermore, this invention introduces a dynamic calculation mechanism for the priority of construction rules based on the operational requirements of industrial monitoring scenarios. By analyzing the target application's requirements for response timeliness, operational reliability, and resource utilization, corresponding weight factors are generated and the execution priority of construction rules is adjusted accordingly. This ensures that the generated Qt project structure not only meets the requirements for multi-rule adaptation but also aligns with actual response efficiency, operational load, and stability requirements. Attached Figure Description

[0040] From the following description of embodiments in conjunction with the accompanying drawings, aspects, features, and advantages of the present invention will become clearer and more readily understood, in which:

[0041] Figure 1 A flowchart illustrating a method for constructing an industrial monitoring Qt development platform for the LoongArch platform, as proposed in an embodiment of the present invention;

[0042] Figure 2 This is a schematic diagram of the Qt application generation process proposed in one embodiment of the present invention;

[0043] Figure 3 This is a schematic diagram of a Qt project structure generation process proposed in one embodiment of the present invention;

[0044] Figure 4This is a schematic diagram of a construction rule invocation process proposed in one embodiment of the present invention;

[0045] Figure 5 This is a schematic diagram of the priority determination process proposed in one embodiment of the present invention;

[0046] Figure 6 This is a schematic diagram of the construction process structure of an industrial monitoring Qt development platform for the LoongArch platform proposed in an embodiment of the present invention. Detailed Implementation

[0047] To facilitate understanding of the present invention by those skilled in the art, several embodiments are now described in detail with reference to the accompanying drawings. It should be understood that the embodiments are for illustrative purposes only and not for limiting the scope of protection of the present invention; the scope of protection of the present invention is defined by the claims, and includes equivalent schemes and equivalent transformations of the claims.

[0048] As mentioned above, existing Qt development tools are difficult to adapt to the LoongArch platform and lack integrated support for industrial monitoring scenarios. This invention provides a method for building an industrial monitoring Qt development platform for the LoongArch platform, aiming to simplify the development process of Qt project structures through a plug-in-driven automatic construction mechanism and a parameterized module integration strategy.

[0049] In one embodiment, on a host development platform, via such as Figure 1 The method shown is to build an industrial monitoring Qt development platform for the LoongArch platform, generate a Qt application, and then deploy the Qt application to the target LoongArch platform.

[0050] It should be noted that the host development platform mentioned in this embodiment refers to the development environment used to execute the Qt application building process of this invention, which undertakes functions such as platform parameter parsing, Qt structure generation, build rule matching, cross-compilation configuration, and application generation.

[0051] In some embodiments, the host development platform may be a computer system based on x86 architecture or ARM architecture, i.e., an operating system such as Windows or Linux that has the conditions to run Qt development tools and build plugins.

[0052] Furthermore, within the Qt development environment hosted on the aforementioned development platform, a Qt application is generated using the aforementioned build method. This build method specifically includes, for example: Figure 1 The steps shown are as follows:

[0053] S01. Obtain the platform parameters and application parameters corresponding to the target industrial monitoring scenario.

[0054] In this embodiment, the Qt development environment refers to an integrated development environment (IDE) used to create, edit, build, and debug Qt applications, which has functions such as interface design, code editing, compilation and debugging, and plugin management.

[0055] In some embodiments, the Qt development environment is Qt Creator, and it runs on any of the aforementioned host development platforms.

[0056] Furthermore, the platform parameters are used to guide the subsequent construction logic of the Qt project structure and the configuration of cross-compilation parameters, thereby ensuring that the generated Qt application can run correctly on the target LoongArch platform.

[0057] Specifically, the platform parameters include, but are not limited to, the processor model (e.g., 3A5000, 2K1000, etc.) of the target LoongArch platform, the operating system type and version (e.g., Loongnix 20.04, UOS), the supported ABI interface types (e.g., LP64D, LP64F), and the dynamic link library types and versions supported by the operating system.

[0058] Furthermore, the application parameters are used to determine the types and configuration methods of the interface modules, data acquisition modules, and alarm logic modules that need to be integrated into the Qt engineering structure, so as to ensure that the generated Qt application can be compatible with the target LoongArch platform and meet the functional requirements of the target industrial monitoring scenario.

[0059] Specifically, the application parameters include the type of the target industrial monitoring scenario (such as environmental monitoring, power equipment monitoring, chemical safety monitoring, etc.) and the sensor configuration requirements to be integrated in the scenario, such as sensor type (temperature and humidity, combustible gas, pressure difference, flame, noise, etc.), number of sensors, communication interface type (such as I2C, SPI, RS485), sampling period, alarm trigger threshold and association strategy, etc.

[0060] It should be noted that there are no restrictions on how platform parameters and application parameters are obtained; you can choose flexibly according to actual development needs and system configuration.

[0061] In some embodiments, platform parameters and application parameters can be interactively filled in by the user through a graphical interface, enabling personalized input of target platform characteristics and industrial monitoring scenario configurations.

[0062] In other embodiments, the platform parameters and application parameters can be quickly imported and reused by automatically reading preset configuration template files (such as json and yaml formats) through integrated plugins, or by extracting relevant parameters from historical project information.

[0063] S02. Generate a Qt application based on the platform parameters and the application parameters.

[0064] In this embodiment, generating a Qt application based on the platform parameters and the application parameters includes, for example: Figure 2 The steps shown are as follows:

[0065] S021. Based on the platform parameters, and in accordance with the LoongArch platform construction rules, construct a Qt project structure compatible with the target LoongArch platform.

[0066] Furthermore, in step S021, the information of the target LoongArch platform (such as processor architecture, operating system version, supported ABI types, system library dependencies, and other platform parameters) is parsed, and combined with preset build rules (including ABI compatibility strategy, module linking strategy, resource path structure, driver interface encapsulation rules, etc.), the Qt project structure is automatically created and configured in the Qt development environment of the host development platform.

[0067] Specifically, the Qt project structure includes project files (pro or pri files), source code directory, resource directory, plugin loading configuration file, etc., to ensure that the generated project can be adapted to the target LoongArch platform's runtime environment after being built.

[0068] S022. Based on the application parameters, integrate the interface module, data acquisition module, and alarm processing module corresponding to the industrial monitoring application into the Qt engineering structure.

[0069] Furthermore, in step S022, based on the acquired application parameters (such as the type of monitoring scenario, the type and number of required sensors, the data refresh cycle, the alarm triggering conditions, etc.), the functional modules corresponding to the target industrial monitoring application are automatically integrated into the completed Qt project structure.

[0070] Specifically, the interface modules include, but are not limited to, elements such as temperature and humidity data display panels, gas concentration status indicator lights, flame detection icons, and alarm pop-up interfaces. These elements can be visually designed and laid out using the Qt Designer tool and dynamically bound to the data acquisition logic.

[0071] Specifically, the data acquisition module includes communication logic that supports interfaces such as I2C, SPI, RS232, and RS485, for periodically acquiring sensor data such as temperature, humidity, gas, pressure difference, and flame, and supports configuration of sampling frequency, data buffering, and anomaly filtering.

[0072] Specifically, the alarm processing module judges the collected data based on the threshold strategy set by the application parameters, and triggers alarm responses such as buzzer control, interface pop-up, log reporting or relay linkage, supporting multi-level alarm configuration and visual display of alarm levels.

[0073] Furthermore, the module integration in step S022 can be completed through the template component library, plugin interface or automatic script in the Qt development environment. The module code and configuration are automatically generated or loaded according to the application parameters, which improves the integration efficiency and enhances the adaptability and reusability of the module.

[0074] S023. Based on the platform parameters, configure the Qt compilation environment and cross-compilation parameters that match the target LoongArch platform.

[0075] Furthermore, step S023 is used to ensure that the Qt project can be correctly built into an executable file that can run on the LoongArch platform on the host platform.

[0076] Specifically, based on platform parameters such as the target platform's ABI type, library path, and compilation toolchain version, the Qt cross-compilation environment is automatically configured. The configuration includes, but is not limited to:

[0077] Specify the mkspec configuration (e.g., linux-loongarch-g++), set the cross-compilation toolchain path (e.g., loongarch64-linux-gnu-g++), and configure the Qt prefix path, plugin path, and library file path, etc.

[0078] The above configuration process can be completed automatically through Qt plugins or build wizards, reducing manual intervention, lowering the risk of configuration errors, and thus improving the stability and success rate of the build process.

[0079] S024. Compile the Qt project structure based on the compilation environment to generate a Qt application suitable for running on the target LoongArch platform.

[0080] After completing the above configuration, step S024 calls the integrated build tools (such as qmake+make or CMake+Ninja) in the Qt development environment to compile the Qt project structure and generate a Qt application that can run on the target LoongArch platform.

[0081] Furthermore, the application is typically an ELF file or an executable file without an extension, and includes the main program executable file, dynamic link plugins, graphics resource files, configuration files, and necessary dependency libraries to ensure full runtime capability on the target platform.

[0082] Furthermore, after compilation, the generated executable program can be deployed to the target LoongArch platform via scp, ftp, SD card, or other file transfer methods. On this platform, it can be used to perform runtime verification, functional testing, and system integration operations, thereby enabling the rapid development and deployment of industrial monitoring Qt applications.

[0083] To more efficiently construct a Qt project structure compatible with the target LoongArch platform, in some embodiments, step S021 is further performed as follows: Figure 3 The steps shown demonstrate how to build a Qt project structure compatible with the target LoongArch platform:

[0084] S0211. Create an initial Qt project structure.

[0085] First, create an initial Qt project structure in the Qt development environment. This structure includes basic elements such as build configuration files (e.g., pro or CMakeLists.txt), source code directories, and resource directories, providing a project framework to support subsequent module integration and build processes.

[0086] S0212, Provide a LoongArch plugin.

[0087] Furthermore, the LoongArch plugin is integrated into the Qt development environment (such as Qt Creator) to perform project build control related to the LoongArch platform, including automatically identifying the platform architecture, selecting mkspec configuration, adapting the ABI interface, and setting the cross-compilation toolchain and related path parameters, so as to realize the rapid adaptation of Qt projects to the target platform.

[0088] S0213. The platform parameters are parsed using the LoongArch plugin to obtain the architecture feature information corresponding to the target LoongArch platform.

[0089] Furthermore, in the Qt development environment, the loaded LoongArch plugin is used to parse several key fields contained in the platform parameters, such as the instruction set architecture type, processor model, operating system kernel version, ABI interface type, and supported system library paths and version information of the target LoongArch platform.

[0090] Specifically, in some implementations, the LoongArch plugin can receive user input through a graphical parameter input interface; in some specific embodiments, the LoongArch plugin can automatically read preset configuration templates (such as json, yaml, etc.) to complete parameter import and parsing.

[0091] The LoongArch plugin transforms platform parameters into structured platform feature information that can be used for subsequent build rule calls, and serves as the input for engineering adaptation and build decisions, thereby achieving accurate adaptation and support of the engineering structure to the target LoongArch platform.

[0092] S0214. Based on the architecture feature information corresponding to the target LoongArch platform, call the build rules that match the target LoongArch platform from the LoongArch plugin.

[0093] Furthermore, the LoongArch plugin has a pre-defined mapping relationship between architecture feature information and build rules. Specifically, after parsing the platform parameters, the LoongArch plugin retrieves and calls matching build rules from its pre-defined build rule library based on the extracted architecture feature information (including but not limited to instruction set architecture type, ABI interface type, cross-compilation toolchain type, system library version, etc.).

[0094] In some embodiments, the LoongArch plugin uses a mapping table between architectural feature information and building rules to achieve automatic matching and invocation; in other embodiments, users can also select and confirm rules in a graphical interface.

[0095] Furthermore, based on the aforementioned mapping relationship, the LoongArch plugin, through, as... Figure 4 The following method is used to execute the call to the build rule:

[0096] S02141. Based on the architectural feature information corresponding to the target LoongArch platform, obtain at least two interrelated construction rules.

[0097] The LoongArch plugin performs feature matching operations in its internal build rule base based on the architectural characteristics of the target LoongArch platform (such as platform instruction set architecture type, ABI interface type, toolchain version, supported dynamic link libraries and paths, etc.) to retrieve multiple build rules corresponding to the current platform configuration.

[0098] If the target LoongArch platform uses the LP64D ABI architecture and GCC 12 toolchain, and the system limits the versions of Qt plugins and library directories, the plugins can be matched with: ABI compatibility rules (such as floating-point support configuration), plugin path rules, resource organization rules, and driver encapsulation rules.

[0099] S02142. Analyze the constraint and conflict relationships between the at least two interrelated construction rules, and determine the priority of each construction rule among the at least two interrelated construction rules.

[0100] It should be noted that there may be interdependencies (such as depending on the same toolchain configuration) or overlapping effects (such as modifying the linking strategy at the same time) between any two related build rules.

[0101] Furthermore, the LoongArch plugin first analyzes the relationships between the selected build rules, identifies the dependencies (such as a rule needing to be based on the configuration result of another rule to take effect) and configuration conflicts (such as two rules specifying inconsistent paths or parameters), in order to construct a logical relationship graph between the rules.

[0102] Furthermore, the LoongArch plugin comprehensively evaluates the execution priority of each build rule based on platform adaptation requirements and key indicators in application parameters (such as response efficiency, stability, and resource consumption), ensuring that the Qt project structure meets both platform and scenario requirements.

[0103] In some embodiments, determining the priority of each of the at least two interrelated construction rules includes, for example: Figure 5 The steps shown are as follows:

[0104] S021421. Obtain the runtime requirements parameters of the Qt application under the target industrial monitoring scenario.

[0105] In these embodiments, in order to achieve dynamic priority sorting of engineering construction rules, the LoongArch plugin first extracts operational requirement indicators closely related to industrial monitoring scenarios from application parameters; furthermore, these operational requirement parameters are usually entered by the user in the project configuration interface, or automatically loaded by the plugin from preset monitoring scenario templates.

[0106] In some embodiments of the present invention, the operational requirements parameters include, but are not limited to, response timeliness, operational reliability, and resource utilization, which are used to guide the priority calculation of the construction rules.

[0107] Response timeliness measures the real-time responsiveness of a Qt application to external events such as changes in sensor data and user interactions. For example, in applications involving gas leak monitoring, data acquisition, judgment, and alarm response must be completed within milliseconds; therefore, build rules related to high real-time processing should be prioritized.

[0108] Operational reliability is used to evaluate the stability and fault tolerance of Qt applications during long-term continuous operation on a target platform. For example, monitoring equipment deployed in industrial sites may be in harsh environments such as high temperature and high humidity, and needs to run continuously for weeks or even longer. Therefore, stability building rules with capabilities such as memory leak protection and watchdog mechanisms should be given priority.

[0109] Resource utilization is used to control the computational resource consumption of Qt applications on the target LoongArch platform, including but not limited to metrics such as CPU utilization and memory usage. In scenarios with limited processor performance or where the system runs multiple tasks in parallel, lightweight build rules should be prioritized to ensure stable system operation, such as strategies like streamlining modules and compressing graphics resources.

[0110] S021422. Map the running requirement parameters to the weight factors of the corresponding construction rules, and based on the priority calculation model, determine the priority of each construction rule among the at least two construction rules according to the correlation matrix between the weight factors and each construction rule.

[0111] In this embodiment, the LoongArch plugin has a built-in priority calculation model to support mapping runtime requirement parameters to weight factor vectors of different build rules, and to calculate the comprehensive priority of the build rules in combination with a preset correlation matrix.

[0112] It should be noted that the priority calculation model can be implemented using a weighted scoring function (such as a weighted linear model, a fuzzy logic scoring model, etc.) to quantify the importance ranking of each construction rule.

[0113] Furthermore, the correlation matrix described in this embodiment refers to a two-dimensional matrix whose element values ​​are the degree of fit between the runtime requirement parameters and the construction rules.

[0114] Specifically, this matrix has rows for runtime requirement parameters and columns for construction rules. Each element in the matrix is ​​used to quantify the correlation strength or fit between the corresponding parameter and the construction rule.

[0115] In this implementation, the association matrix is ​​used to quantify the degree of fit between the operational requirements parameters and the construction rules; the matrix element values ​​can be obtained through empirical settings, construction history, or model training, and are usually weight values ​​between 0 and 1, representing the association strength.

[0116] For example, when the runtime requirements parameters include response timeliness, operational reliability, and resource utilization, and the build rules include four items: ABI compatibility, module linking, resource organization, and driver encapsulation, a 3×4 association matrix can be constructed. The LoongArch plugin converts the weights of the runtime requirements parameters (such as 0.5, 0.3, 0.2) into vectors, performs matrix multiplication with the association matrix, calculates the overall priority of each build rule, and executes them in order of priority.

[0117] This embodiment achieves dynamic sorting and automatic selection of build rules driven by runtime requirements through a priority calculation model and adaptation association, which helps to improve the accuracy and efficiency of build adaptation.

[0118] S0215. Based on the construction rules, reconstruct the configuration of the initial Qt project structure to generate a Qt project structure compatible with the target LoongArch platform.

[0119] In this embodiment, the process of reconstructing the Qt project structure refers to making targeted modifications and enhancements to key configuration files, build parameters, module references, path mappings, and plugin loading mechanisms in the project based on the initial Qt project structure and according to the build rules and their execution order determined in the previous steps, so as to ensure that the generated Qt project structure can correctly adapt to the system characteristics and operating requirements of the target LoongArch platform.

[0120] In some embodiments, step S025 further includes: collaboratively reconstructing the initial Qt project structure based on the parsing results and priority results, so that the generated Qt project structure can simultaneously satisfy the operational constraints corresponding to the at least two interrelated construction rules.

[0121] Furthermore, after resolving the dependency constraints and conflict relationships between build rules and determining the execution order of each rule based on the priority calculation model, the LoongArch plugin executes the configuration modification operations corresponding to the build rules in sequence according to priority, and performs coordinated adjustments and incremental updates to key configuration items in the initial Qt project structure (such as compiler instruction set, mkspec template, plugin loading path, module compilation options, driver interface binding strategy, etc.).

[0122] Specifically, this collaborative refactoring process can be completed automatically through the build rule execution engine embedded in the plugin, ensuring compatibility, execution order, and correctness of dependencies between different rules.

[0123] In one embodiment of the present invention, a computer-readable storage medium is provided, on which a computer program is stored. When executed by a processor, the computer program is used to implement the method for building an industrial monitoring Qt development platform for the LoongArch platform provided by the present invention, including steps such as obtaining platform parameters and application parameters, building the Qt project structure, integrating functional modules, configuring the compilation environment, and generating and deploying applications.

[0124] Specifically, the computer-readable storage medium may include, but is not limited to: hard disk, solid-state drive (SSD), optical disk, USB flash drive, SD card, ROM, RAM, EPROM, EEPROM and other non-transitory computer-readable media that can be used to store computer programs.

[0125] It should be noted that the program code stored in the above-mentioned medium can be loaded and run in the host development platform to drive the plug-in modules and build toolchain in the Qt development environment, thereby completing the Qt application development process for the LoongArch platform, and has good portability, executability and automation control capabilities.

[0126] In one embodiment of the present invention, an industrial monitoring Qt development platform construction system for the LoongArch platform is provided, which is implemented in the form of a computer device.

[0127] Furthermore, such as Figure 6 As shown, it includes a processor and a memory, wherein the memory is used to store computer programs and the processor is used to execute the computer programs, thereby implementing the Qt development platform construction method of the present invention.

[0128] Specifically, the processor can be a general-purpose processor or a special-purpose processor, and the memory can be RAM, a hard disk, or other non-transitory storage media, used to store program code, configuration files, and intermediate build data. When the processor executes a computer program stored in the memory, the system is configured to perform the following functions:

[0129] First, the system acquires the platform parameters and application parameters corresponding to the target industrial monitoring scenario. The platform parameters are used to characterize the architectural features of the target LoongArch platform, and the application parameters are used to characterize the target industrial monitoring scenario and its sensor configuration requirements, providing basic input data for subsequent engineering construction.

[0130] Secondly, based on the platform parameters and in accordance with the preset LoongArch platform construction rules, the system automatically constructs a Qt project structure compatible with the target LoongArch platform in the Qt development environment to ensure that the project meets the operational constraints of the target platform at the architectural level.

[0131] Furthermore, based on the application parameters, the system automatically integrates the interface module, data acquisition module, and alarm processing module corresponding to the industrial monitoring application into the Qt project structure, so that the generated Qt project meets the actual application requirements of the target industrial monitoring scenario at the functional level.

[0132] Subsequently, the system automatically configures the Qt compilation environment and cross-compilation parameters that match the target LoongArch platform based on the platform parameters, including the compilation toolchain, ABI type, and library path configuration, to ensure that the Qt project is correctly compiled into an application that runs on the target platform.

[0133] Finally, after completing the compilation environment configuration, the system compiles the Qt project structure to generate a Qt application suitable for running on the target LoongArch platform, thereby realizing a complete automated process from project building to application generation.

[0134] Through the above system structure and functional configuration, the present invention can complete the construction process of industrial monitoring Qt application for the LoongArch platform in a systematic and automated manner, ensuring that the technical solution has a clear implementation path and good feasibility.

[0135] In the above embodiments, the descriptions of different embodiments have different emphases; technical features not detailed or recorded in a certain embodiment can be understood and implemented by referring to the corresponding records of other embodiments. Unless otherwise expressly stated to the contrary: technical features in each embodiment can be substituted or combined with each other without technical conflict; the order of method steps can be adjusted without affecting the function; the device / module / unit can be implemented by hardware, software or a combination thereof, and can be centralized or distributed; parameters, values ​​or ranges include reasonable errors and equivalent values, and the terms "about", "greater than / less than", "between", and range endpoints are all covered without affecting the technical effect; ordinal numbers such as "first / second" are only used for distinction and do not limit the quantity, priority or structural relationship; the reference numerals and names in the specification and drawings are only illustrative and do not limit the structural form, size ratio or installation position; improvements, substitutions or equivalent solutions that are not explicitly stated but can be obtained by those skilled in the art without creative effort should all be included in the protection scope of this invention.

Claims

1. A method for constructing an industrial monitoring Qt development platform for the LoongArch platform, characterized in that, Includes the following steps: Obtain the platform parameters and application parameters corresponding to the target industrial monitoring scenario. The platform parameters include the target LoongArch platform information, and the application parameters include the industrial monitoring scenario and the sensor configuration requirements under this industrial monitoring scenario. On the host development platform, a Qt application is generated based on the platform parameters and the application parameters, and then the Qt application is deployed to the target LoongArch platform. The Qt application is generated through the following steps: Based on the platform parameters, and in accordance with the LoongArch platform construction rules, a Qt project structure compatible with the target LoongArch platform is constructed. Based on the application parameters, an interface module, a data acquisition module, and an alarm processing module corresponding to the industrial monitoring application are integrated into the Qt engineering structure. Configure the Qt compilation environment and cross-compilation parameters that match the target LoongArch platform according to the platform parameters; The Qt project structure is compiled based on the compilation environment to generate a Qt application suitable for running on the target LoongArch platform; Within the Qt development environment of the host development platform, the step of constructing a Qt project structure compatible with the target LoongArch platform based on the platform parameters and according to the LoongArch platform construction rules includes the following steps: Create an initial Qt project structure; A LoongArch plugin is provided, which is integrated into the Qt development environment to perform project build control related to the LoongArch platform; The LoongArch plugin parses the platform parameters to obtain the architecture feature information corresponding to the target LoongArch platform; Based on the architectural features of the target LoongArch platform, the build rules that match the target LoongArch platform are called from the LoongArch plugin; Based on the aforementioned construction rules, the configuration of the initial Qt project structure is reconstructed to generate a Qt project structure compatible with the target LoongArch platform.

2. The method for constructing an industrial monitoring Qt development platform for the LoongArch platform according to claim 1, characterized in that, The LoongArch plugin has a pre-defined mapping relationship between architectural feature information and build rules. The LoongArch plugin executes the call to the build rules in the following manner: Based on the architectural feature information corresponding to the target LoongArch platform, at least two interrelated construction rules are obtained; The constraint and conflict relationships between the at least two interrelated construction rules are analyzed, and the priority of each construction rule in the at least two interrelated construction rules is determined. Based on the parsing results and priority results, the initial Qt project structure is collaboratively reconstructed so that the generated Qt project structure can simultaneously satisfy the operational constraints corresponding to at least two interrelated construction rules.

3. The method for constructing an industrial monitoring Qt development platform for the LoongArch platform according to claim 2, characterized in that, Determining the priority of each of the at least two interrelated construction rules includes the following steps: Under the target industrial monitoring scenario, obtain the operation requirements parameters of the Qt application, which include at least response timeliness, operation reliability and resource utilization. The runtime requirement parameters are mapped to weight factors of the corresponding construction rules, and based on the priority calculation model, the priority of each construction rule among the at least two interrelated construction rules is determined according to the correlation matrix between the weight factors and each construction rule.

4. The method for constructing an industrial monitoring Qt development platform for the LoongArch platform according to any one of claims 2 to 3, characterized in that, Each of the aforementioned construction rules includes at least ABI compatibility rules, module linking rules, resource organization rules, and driver interface encapsulation rules.

5. The method for constructing an industrial monitoring Qt development platform for the LoongArch platform according to any one of claims 1 to 4, characterized in that, The host development platform is a computer system based on x86 or ARM architecture.

6. The method for constructing an industrial monitoring Qt development platform for the LoongArch platform according to any one of claims 1 to 4, characterized in that, The Qt development environment within the host development platform is Qt Creator, and the LoongArch plugin is embedded in Qt Creator as a plugin module.

7. The method for constructing an industrial monitoring Qt development platform for the LoongArch platform according to any one of claims 1 to 4, characterized in that: The platform parameters include the instruction set architecture information, processor model, operating system version, and supported ABI interface types of the target LoongArch platform. The application parameters include the industrial monitoring scenario type, sensor type and quantity, required data refresh cycle, and alarm strategy configuration items.

8. A computer-readable storage medium, characterized in that, It stores a computer program, which, when executed by a processor, implements the method for constructing an industrial monitoring Qt development platform for the LoongArch platform as described in any one of claims 1 to 7.

9. A system for building an industrial monitoring Qt development platform for the LoongArch platform, the system implementing the method for building an industrial monitoring Qt development platform for the LoongArch platform as described in claim 1, characterized in that, It includes a processor and a memory, wherein the memory stores a computer program, and when the computer program is executed by the processor, it performs the following functions: Obtain the platform parameters and application parameters corresponding to the target industrial monitoring scenario; Based on the platform parameters, and in accordance with the LoongArch platform construction rules, a Qt project structure compatible with the target LoongArch platform is constructed. Based on the application parameters, an interface module, a data acquisition module, and an alarm processing module corresponding to the industrial monitoring application are integrated into the Qt engineering structure. Configure the Qt compilation environment and cross-compilation parameters that match the target LoongArch platform according to the platform parameters; The Qt project structure is compiled based on the aforementioned compilation environment to generate a Qt application suitable for running on the target LoongArch platform.

Images