Control method and system of industrial software based on communication mechanism

Abstract

This invention discloses a control method and system for industrial software based on a communication mechanism. The invention relates to the technical field of industrial software. Different versions of plugins communicate and interact along this mechanism. Multiple corresponding data chains are constructed based on the dependency relationship. Each data chain is loaded into the same assembly resolver, and the corresponding loading requests for each data chain are intercepted. The search path is dynamically reconstructed based on the specific configuration information of the current plugin. Each plugin locates its required DLL files, simplifying plugin integration. Security checks are performed on the plugins used by the industrial software, and the reliability of the plugins is determined during the check. Simultaneously, the access permissions of the plugins used by the industrial software are marked, and the running status is traced based on the industrial software's running logs, improving the security control of the industrial software and ensuring the stability and communication performance of multiple integrated plugins.

Description

Technical Field

[0001] This invention relates to the technical field of industrial software, and in particular to a control method and system for industrial software based on a communication mechanism. Background Technology

[0002] In the current field of industrial automation control software technology, with the increasing demand for intelligent manufacturing, software systems often need to integrate a large number of third-party functional components (such as vision algorithm libraries, intelligent inference models, communication drivers, etc.) to achieve complex production control. However, existing industrial software architectures generally suffer from the following technical bottlenecks when integrating and managing these external plug-ins:

[0003] Existing technologies typically employ simple folder overwriting or global assembly loading methods. Since different versions of plugins often depend on specific versions of dynamic link library (DLL) files, when industrial software attempts to integrate multiple plugins, version overwriting or loading conflicts are very likely to occur, which cannot simplify plugin integration and affects the stability of integrating multiple plugins in industrial software. Summary of the Invention

[0004] The purpose of this invention is to overcome the shortcomings of the prior art. This invention provides a control method and system for industrial software based on a communication mechanism.

[0005] This invention provides a control method for industrial software based on a communication mechanism, comprising:

[0006] The industrial database corresponding to the industrial software is marked, and the corresponding data architecture is determined by detecting the industrial database. The corresponding plugins are configured for the data architecture. Different versions of the plugins coexist in the industrial software and communicate with each other along the communication mechanism.

[0007] The dependencies of each plugin are marked, and multiple data chains are constructed based on these dependencies. Each data chain is loaded into the same assembly resolver, and the corresponding loading request for each data chain is intercepted. The search path is dynamically reconstructed in combination with the specific configuration information of the current plugin, so that each plugin can locate the DLL file it needs.

[0008] The application scenarios of the industrial software are marked, the corresponding data types are determined based on the analysis of the application scenarios, the corresponding data transmission areas and data transmission methods are configured for the data types, and the load of the main process is dynamically optimized.

[0009] Security checks are performed on the plugins used by the industrial software, and the reliability of the plugins is determined during the check. At the same time, the access permissions of the plugins used by the industrial software are marked, and the running status is traced based on the running logs of the industrial software to present the running status of the industrial software in real time.

[0010] This invention provides a control system for industrial software based on a communication mechanism, which is applied to the aforementioned control method for industrial software based on a communication mechanism. The control system includes:

[0011] The communication and interaction module is used to mark the industrial database corresponding to the industrial software, determine the corresponding data architecture by detecting the industrial database, configure the corresponding plugins for the data architecture, and allow different versions of plugins to coexist in the industrial software and communicate and interact along the communication mechanism.

[0012] The data chain module is used to mark the dependencies of each plugin, build multiple corresponding data chains based on the dependencies, load each data chain into the same assembly resolver, intercept the corresponding loading request for each data chain, and dynamically reconstruct the search path in combination with the specific configuration information of the current plugin, so that each plugin can locate the DLL file it needs;

[0013] The dynamic optimization module is used to mark the application scenarios of the industrial software, determine the corresponding data type based on the analysis of the application scenario, configure the corresponding data transmission area and corresponding data transmission method for the data type, and dynamically optimize the load of the main process.

[0014] The runtime status module is used to perform security checks on the plugins used by the industrial software, determine the reliability of the plugins during the check, mark the access permissions of the plugins used by the industrial software, and trace the runtime status based on the runtime logs of the industrial software to present the runtime status of the industrial software in real time.

[0015] Compared with the prior art, the beneficial effects of the present invention are:

[0016] (1) Mark the industrial database corresponding to the industrial software, and determine the corresponding data architecture by detecting the industrial database. Configure the corresponding plugins for the data architecture. Different versions of plugins coexist in the industrial software and communicate with each other along the communication mechanism. Mark the dependencies of each plugin, build multiple data chains according to the dependencies, load each data chain into the same assembly resolver, intercept the corresponding loading requests for each data chain, and dynamically reconstruct the search path in combination with the specific configuration information of the current plugin, so that each plugin can locate the DLL file it needs. This fully utilizes the communication mechanism and performs multiple controls on each plugin and the industrial software to ensure that each plugin resolves the DLL conflict problem and simplifies plugin integration.

[0017] (2) Mark the application scenario of the industrial software, determine the corresponding data type according to the analysis of the application scenario, configure the corresponding data transmission area and corresponding data transmission method for the data type, and dynamically optimize the load of the main process; perform security checks on the plugins used by the industrial software, and determine the reliability performance of the plugins during the check process. At the same time, mark the access permissions of the plugins used by the industrial software, and trace the running status based on the running log of the industrial software to present the running status of the industrial software in real time. This realizes the dynamic optimization of the load of the main process, meets the real-time control requirements, introduces the access permissions of the plugins used by the industrial software, improves the security control of the industrial software, and ensures the stability and communication performance of multiple plugins integrated in the industrial software. Attached Figure Description

[0018] Figure 1 This is a flowchart illustrating the control method for industrial software based on a communication mechanism in an embodiment of the present invention.

[0019] Figure 2 This is a flowchart illustrating step S11 in the control method of industrial software based on a communication mechanism according to an embodiment of the present invention.

[0020] Figure 3 This is a flowchart illustrating step S12 in the control method for industrial software based on a communication mechanism according to an embodiment of the present invention.

[0021] Figure 4 This is a flowchart illustrating step S13 in the control method for industrial software based on a communication mechanism according to an embodiment of the present invention.

[0022] Figure 5 This is a flowchart illustrating step S14 in the control method for industrial software based on a communication mechanism according to an embodiment of the present invention.

[0023] Figure 6 This is a schematic diagram of the structural composition of the industrial software control system based on the communication mechanism in an embodiment of the present invention. Detailed Implementation

[0024] The technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention.

[0025] Please see Figures 1 to 6 A control method for industrial software based on a communication mechanism, applied to industrial software scenarios; the control method for industrial software based on a communication mechanism includes:

[0026] Step S11: Mark the industrial database corresponding to the industrial software, determine the corresponding data architecture by detecting the industrial database, configure the corresponding plugin for the data architecture, different versions of the plugin coexist in the industrial software, and communicate and interact along the communication mechanism.

[0027] Step S12: Mark the dependencies of each plugin, construct multiple corresponding data chains based on the dependencies, load each data chain into the same assembly resolver, intercept the corresponding loading request for each data chain, and dynamically reconstruct the search path in combination with the specific configuration information of the current plugin, so that each plugin can locate the DLL file it needs;

[0028] Step S13: Mark the application scenario of the industrial software, determine the corresponding data type based on the analysis of the application scenario, configure the corresponding data transmission area and corresponding data transmission method for the data type, and dynamically optimize the load of the main process.

[0029] Step S14: Perform a security check on the plugins used by the industrial software, determine the reliability of the plugins during the check, mark the access permissions of the plugins used by the industrial software, and trace the running status based on the running logs of the industrial software to present the running status of the industrial software in real time.

[0030] refer to Figure 2 In step S11, the specific steps are as follows:

[0031] S111: Real-time monitoring of industrial software, and determination of the corresponding industrial database along the detection of the industrial software, which stores multiple key information in the industrial production process; dynamic detection of the industrial database, and determination of multiple sub-data architectures during the detection process, determination of the corresponding data architecture based on the fusion of multiple sub-data architectures, and marking of multiple functional requirements corresponding to the data architecture.

[0032] S112: Match the corresponding plugins by tracing the various functional requirements, mark multiple plugins of different versions, load multiple plugins into the same industrial software, and combine the communication mechanism to realize the communication interaction of multiple plugins.

[0033] In the embodiments of this application, industrial software is monitored in real time, and the corresponding industrial database is determined along the detection of the industrial software. The industrial database stores multiple key information in the industrial production process. The industrial database is dynamically detected, and multiple sub-data architectures are determined during the detection process. The corresponding data architecture is determined based on the fusion of multiple sub-data architectures, and multiple functional requirements corresponding to the data architecture are marked. The overall consideration of the fusion of multiple sub-data architectures is taken into account, and the accuracy of the corresponding data architecture is guaranteed.

[0034] At this point, the industrial software is monitored in real time to locate its corresponding industrial database. This database, as the core carrier, stores key information in the industrial production process (such as process parameters, equipment status, energy consumption data, etc.). The industrial database is dynamically monitored to identify multiple sub-data architectures. By merging these sub-data architectures, a globally unified data architecture is constructed. Based on this merged data architecture, multiple functional requirements of the system are marked and determined, providing a basis for subsequent plug-in matching.

[0035] Specifically, industrial software is an industrial automation software used to control production line equipment. Its industrial database stores information such as equipment status, production data, and product quality. Through system log analysis and performance monitoring, the software's operating status can be understood, such as whether the equipment is operating normally and whether the production efficiency meets the standards. At the same time, through database fingerprinting, the type and version of the database used by the industrial software can be identified, such as SQL Server 2019.

[0036] Database triggers are introduced to monitor changes in equipment status tables, such as equipment fault information and production data updates. The data tables in the industrial database are divided into different sub-data architectures, such as equipment status sub-data architecture, production data sub-data architecture, and product quality sub-data architecture. These sub-data architectures are then integrated into a complete data architecture, for example, using an ER model to describe the relationship between equipment, production data, and product quality. Based on the data architecture analysis results, the functional requirements of the industrial software are identified, such as equipment monitoring, production data analysis, and product quality control.

[0037] Furthermore, by tracing back along the various functional requirements, corresponding plugins are matched to mark multiple plugins of different versions, multiple plugins are loaded into the same industrial software, and the communication mechanism is combined to realize the communication interaction of multiple plugins.

[0038] At this point, based on the functional requirements defined in S111, the corresponding plugins are traced and matched. Considering the complexity of the industrial environment, the system supports marking and loading multiple plugins of different versions into the same industrial software to solve compatibility issues. In this process, a master-slave process isolation architecture is adopted: the master process is responsible for process orchestration and UI display, while the slave process (host process) is responsible for executing specific operator plugins. Through this physical sandbox isolation mechanism, the coexistence and independent operation of different versions of plugins are realized. At the same time, combined with an efficient communication mechanism, the kernel object synchronization mechanism is used to ensure deterministic handshake between the master and slave processes, realizing communication and interaction between multiple plugins, which not only ensures functional scalability but also ensures system stability.

[0039] Specifically, industrial software implements the following functions: Equipment monitoring: Real-time monitoring of the operating status of production line equipment, such as temperature, pressure, speed, etc.; Production data analysis: Analyzing production data, such as output, quality, efficiency, etc., and displaying it visually; Product quality control: Inspecting and controlling product quality, such as identifying defective products through a visual inspection system.

[0040] Search and match plugins in the plugin repository that can achieve the above functions. For example: Equipment monitoring plugin: responsible for collecting equipment data and displaying it in real time; Data analysis plugin: responsible for analyzing production data and generating reports and charts; Visual inspection plugin: responsible for visual inspection of products and identifying defective products. Simultaneously, select different versions of plugins according to different application scenarios. For example: Equipment monitoring plugin v1.0: supports basic data collection and display functions; Equipment monitoring plugin v2.0: supports more advanced functions, such as alarms and trend analysis; Load plugin: Load the matching plugins into the industrial software. For example: Load Equipment monitoring plugin v2.0 into the industrial software to implement equipment monitoring functions; Load data analysis plugin v1.0 into the industrial software to implement production data analysis functions; Load visual inspection plugin v1.5 into the industrial software to implement product quality control functions.

[0041] Establish a communication mechanism between plugins. For example, the equipment monitoring plugin sends the collected equipment data to the message queue; the data analysis plugin reads the equipment data from the message queue and performs data analysis; the visual inspection plugin sends the detected defective product information to the message queue; and the industrial software reads the defective product information from the message queue and performs quality control.

[0042] refer to Figure 3 In step S12, the specific steps are as follows:

[0043] S121: Dynamically match each plugin and determine the corresponding relationship information during the matching process. Determine the dependency relationship of each plugin based on the dynamic identification of the relationship information. Iterate on the dependency relationship and determine multiple data nodes during the iteration process. Merge multiple data nodes with multiple factors and output the corresponding data chain. Load each data chain along different data channels to the same assembly parser.

[0044] S122: In this assembly resolver, the loading requests corresponding to each data chain are obtained, and multiple sub-loading items are determined based on the parsing of the loading requests. At the same time, the specific configuration information of the current plugin is obtained, and the multiple sub-loading items and the specific configuration information of the current plugin are matched by multiple factors. The corresponding search path is reconstructed, and the search is performed along the search path to match the corresponding DLL file, so that each plugin matches the corresponding DLL file.

[0045] In the embodiments of this application, each plugin is dynamically matched, and the corresponding relationship information is determined during the matching process. The dependency relationship of each plugin is determined based on the dynamic identification of the relationship information. In the dependency relationship, the dependency relationship is iterated, and multiple data nodes are determined during the iteration process. The multiple data nodes are fused by multiple factors, and the corresponding data chain is output. Each data chain is loaded into the same assembly parser along different data channels. This approach is compatible with the overall consideration of dynamic identification of relationship information and ensures the accuracy of the dependency relationship of each plugin.

[0046] At this point, the metadata of the plugin assembly is read using reflection to obtain the name, version number, and public key token of the external assembly it references; the configuration manifest (such as XML or JSON format) of the plugin is parsed to identify its explicitly declared dependencies and runtime environment requirements; the interface types implemented by the plugin are analyzed to determine its service contract relationship with the main program or other plugins, forming a preliminary relationship mapping table.

[0047] The implicit reference relationships are transformed into explicit dependency graphs, clearly defining the complete dependency tree required for plugin operation; it not only identifies libraries directly referenced by plugins (direct dependencies), but also recursively identifies other libraries referenced by these libraries (indirect dependencies), constructing a complete dependency closure; based on version constraints in the relationship information (such as greater than a certain version, exact match to a certain version), it dynamically calculates the compatible version range; during the identification process, it compares the version requirements of different plugins for the same dependency library, and marks potential version conflict points in advance.

[0048] The dependency graph is iteratively traversed using either Breadth-First Search (BFS) or Depth-First Search (DFS) algorithms. During the iteration process, each accessed dependency library (such as a specific DLL file, configuration file, or resource file) is defined as a data node. Attribute information is attached to each data node, including file hash value, storage path candidate, loading priority, etc., to ensure the uniqueness and traceability of the node.

[0049] Based on the dependency hierarchy between nodes, a topological sort is performed to ensure that dependent nodes precede dependent nodes, avoiding deadlocks caused by circular dependencies. The optimal loading order of nodes is calculated by comprehensively considering factors such as node version compatibility, file access latency, and network location. The sorted node sequence is encapsulated into a data chain object, with each chain corresponding to a plugin's complete dependency loading path and including a fallback mechanism to handle loading failures. Simultaneously, a custom assembly resolver is registered in the application domain to take over the system's default loading logic. Although all plugins share the same resolver instance, the resolver internally maintains an independent context data channel for each plugin, achieving logical isolation. When the resolver receives a loading request, it matches the corresponding data chain based on the request source, dynamically reconstructs the search path, and loads the correct DLL file from a specified location (such as the plugin's private directory), rather than the global assembly cache.

[0050] Specifically, suppose industrial software integrates a "vision inspection plugin A" and a "motion control plugin B", and the two have conflicting dependencies on the image processing library OpenCV; when the system loads "vision inspection plugin A", it discovers through reflection that it depends on OpenCV.dll (version 4.5.0); when loading "motion control plugin B", it discovers that it depends on OpenCV.dll (version 3.4.0); the system automatically identifies the different versions of the same library that the two depend on.

[0051] The system iterates through the dependency trees of the two plugins. During the iteration, OpenCV.dll (v4.5.0) and OpenCV.dll (v3.4.0) are marked as independent data nodes Node_A1 and Node_B1, respectively, and the underlying mathematical library nodes that they depend on are also identified.

[0052] Based on topological sorting rules, the system generates a data chain Chain_A for plugin A: [Basic Mathematics Library Node > OpenCVv4.5.0 Node > Plugin A Main Program]; and generates a data chain Chain_B for plugin B: [Basic Mathematics Library Node > OpenCVv3.4.0 Node > Plugin B Main Program]. In this process, file path factors are incorporated to ensure that the physical paths of the two versions of the DLL are distinguished.

[0053] The core framework of the industrial software launches a custom assembly resolver. When plugin A runs and attempts to call an OpenCV function, the resolver intercepts the loading request and loads the v4.5.0 version of the DLL along the private path pointed to by Chain_A. Similarly, when plugin B runs, the resolver loads the v3.4.0 version of the DLL along Chain_B. This process occurs in parallel within the same software process, successfully solving the problem of coexistence and communication between different versions of plugins in industrial software.

[0054] Furthermore, the assembly resolver obtains the loading requests corresponding to each data chain and determines multiple sub-loading items based on the parsing of these loading requests. Simultaneously, it obtains the specific configuration information of the current plugin, performs multi-factor matching between the multiple sub-loading items and the current plugin's specific configuration information, reconstructs the corresponding search path, searches along this path, and matches the corresponding DLL files. This ensures that each plugin matches the corresponding DLL file, taking into account the overall considerations of loading request parsing and guaranteeing the accuracy of the multiple sub-loading items. At the same time, it fully utilizes this communication mechanism and implements multiple controls over each plugin and the industrial software to ensure that each plugin resolves DLL conflict issues and simplifies plugin integration.

[0055] At this point, in the custom assembly resolver, it subscribes to assembly loading events (such as the AssemblyResolve event) of the application domain. When the Common Language Runtime (CLR) attempts to locate the assembly but fails, this event is triggered, and the resolver takes over control. After capturing the event, the resolver identifies the context of the current request, determines which plugin's execution flow triggered it, and maps it to the corresponding "data chain" generated in step S121. It extracts key parameters from the loading request, including the requested assembly name, version number, culture, and public key token, to provide a basis for subsequent matching.

[0056] Based on the dependency graph in the data chain, the main program assembly of the current request is broken down into its referenced sub-modules or resource files, forming a list of "sub-loaded items"; based on the tightness of the dependency relationship, the decomposed sub-loaded items are prioritized to ensure that the base library is loaded before the application logic library.

[0057] Read the dependency mapping table from the plugin's configuration file (such as plugin.json or app.config), such as the explicit declaration of "LibAv1.0>LibBv2.0"; obtain the environment parameters of the plugin runtime, such as the specified private runtime directory, specific CPU architecture preferences, etc.; read the plugin's isolation level identifier (such as whether it runs in an independent sandbox) to determine whether to force the general version in the Global Assembly Cache (GAC) to be ignored.

[0058] The version requirements of the sub-loaded project, the plugin's private configuration, and system environment constraints are used as multiple factors for weighted matching calculations; for example, the plugin's private configuration has a higher weight than the system default configuration. Based on the matching results, the physical file path is dynamically concatenated; for example, the base path is set to the Dependencies / v1.0 / folder under the plugin's private directory, instead of the system directory. The refactored search path includes the primary path and alternative paths; if no file is found under the primary path, the alternative paths are probed sequentially according to compatibility rules to ensure the robustness of loading.

[0059] Based on the reconstructed search path, the target DLL file is located in the file system. After the DLL file is matched, its metadata (such as version number and public key tag) is verified to be strictly consistent with the loading request to prevent loading errors or tampered files. The contents of the successfully matched DLL file are loaded into memory and bound to the current plugin's runtime context, thus completing the entire loading process. At this point, even if different plugins load DLLs with the same name but different versions, they will exist independently in memory and will not interfere with each other.

[0060] Specifically, when "Visual Inspection Plugin A" runs, it triggers a request to load the "Image Processing Library". The custom assembly resolver intercepts this request, identifies that the request originates from Plugin A, and retrieves the data chain corresponding to Plugin A. The resolver analyzes the request and finds that Plugin A not only needs the main library ImageProc.dll, but also the dependent submodules Filter.dll and Codec.dll, and establishes these as sub-load items.

[0061] The system reads the configuration file of plugin A and finds that it explicitly declares that "the image processing library version 4.0 must be used to support GPU acceleration". The parser combines the requirements (image processing library) and configuration information (version 4.0) of the sub-loaded project and performs multi-factor matching. The system reconstructs the search path from the global path to the private directory of plugin A: / Plugins / VisionA / Libs / v4.0 / . At the same time, for "motion control plugin B", its path is reconstructed to / Plugins / MotionB / Libs / v2.0 / .

[0062] The parser followed the reconstructed path and successfully located and loaded the v4.0 version of ImageProc.dll under / Plugins / VisionA / Libs / v4.0 / . At this point, plugin A uses the v4.0 version library, while plugin B uses the v2.0 version library. The two run stably in the same industrial software process without interfering with each other, completely resolving the crash problem caused by version conflicts.

[0063] refer to Figure 4 In step S13, the specific steps are as follows:

[0064] S131: Collect the scene nodes of the industrial software, detect the scene nodes to determine multiple data scene factors, determine the corresponding application scene based on the multiple data scene factors, dynamically analyze the application scene along multiple dimensions, and output the corresponding data types in sequence.

[0065] S132: In this data type, multiple key data information are marked, and the corresponding data transmission combination is determined based on the tracing of each key data information. This data transmission combination covers the corresponding data transmission area and the corresponding data transmission method.

[0066] S133: Mark the current working state of the main process, determine the corresponding key usage content based on the usage history of the industrial software, monitor the load of the main process, and trigger load optimization of the main process based on the key usage content to maintain the efficient working state of the main process.

[0067] In the embodiments of this application, scene nodes of the industrial software are collected and detected to determine multiple data scene factors. Based on the multiple data scene factors, the corresponding application scenario is determined. The application scenario is dynamically analyzed along multiple dimensions, and the corresponding data types are output sequentially. This approach is compatible with the overall consideration of scene node detection and ensures the accuracy of multiple data scene factors.

[0068] At this point, lightweight probes are deployed on the critical execution paths of industrial software (such as data acquisition entry points, algorithm call interfaces, and output control terminals) to capture node trigger signals in real time; the connected physical device nodes, such as industrial cameras, PLC controllers, and sensor arrays, are identified through the driver interface to obtain scene features at the hardware level; and operating system-level interrupt requests (IRQs) and application-level events are monitored to perceive key action nodes such as "trigger acquisition" and "alarm response" in real time.

[0069] Analyze the timing frequency and real-time requirements of node triggers to determine whether the data stream is a "burst of high concurrency" or a "continuous low-frequency stream"; predict the data volume generated by the node to distinguish between small batches of structured data (such as temperature readings) and massive amounts of unstructured data (such as high-definition image streams); read the service quality requirements of the node, such as whether packet loss is allowed and whether strict order guarantees are required, to determine the fault tolerance factors of the data scenario.

[0070] Factors such as timing, capacity, and reliability are used to construct feature vectors, which are then input into the scene classification model to calculate the matching degree between the vectors and known scene templates (such as "real-time video surveillance", "historical data archiving", and "closed-loop control"). Using the expert system rule base (e.g., "data volume > 1GB / second and latency < 10ms" > "real-time image processing scene"), specific application scene labels are inferred. Combining the scene information of the preceding nodes, algorithms such as Hidden Markov Models are used to predict the most likely application scene.

[0071] The identified application scenarios are broken down into fine-grained parts to clarify their specific constraints in different technical dimensions, introducing bandwidth, storage, and other dimensions. In the bandwidth dimension, the current network or bus bandwidth utilization is dynamically evaluated to analyze the bandwidth requirements of the scenario for the transmission channel. In the computing load dimension, the computing power requirements of the scenario for CPU and GPU are analyzed to determine whether there are computing power bottlenecks. In the storage dimension, the data persistence requirements are analyzed to determine whether memory-level swapping or disk-level storage is required.

[0072] Depending on the parsing dimension, output structured data types (such as JSON, Modbus register values) or unstructured data types (such as Bitmap image streams, Raw bitstreams); attach header metadata to the data type, including encoding format, compression algorithm suggestions, checksum type, etc., to form a complete data description object; and tagged the output data type with priority labels (such as "high real-time" or "normal priority") for subsequent transmission scheduling.

[0073] Furthermore, in this data type, multiple key data information are marked, and the corresponding data transmission combination is determined based on the tracing of each key data information. This data transmission combination covers the corresponding data transmission area and the corresponding data transmission method, and is compatible with the overall consideration of tracing each key data information, ensuring the accuracy of the corresponding data transmission combination.

[0074] At this point, using reflection mechanisms or protocol parsing libraries, the data header definition is extracted from the data type output by S131, and basic attributes such as data length, checksum, and timestamp are identified; the data content is scanned and its sensitivity level is marked (such as "memory visible only" or "disk storage allowed"), providing a basis for subsequent selection of secure transmission channels; for big data objects, "control instructions" and "payload entities" are explicitly marked; for example, the size, format, and storage pointer of image data are marked as lightweight metadata, and the image pixel matrix is ​​marked as heavyweight entity data.

[0075] Establish a mapping rule base between feature vectors and transmission strategies; for example, if tracing back reveals that data information contains "microsecond-level latency requirements" and "data volume in the GB range", then automatically match the combination of "shared memory + metadata control flow"; decide the transmission zone type based on the data's lifecycle and visibility; for cross-process high-frequency interactive data, define it as a "shared memory mapping region (MMF)"; for cross-network boundary data, define it as a "Socket buffer"; determine the transmission method based on data serialization requirements; for structured instructions, use highly reliable gRPC or TCP streaming transmission; for unstructured big data, use zero-copy pointer passing or DMA direct memory access.

[0076] For inter-process communication scenarios, a named or anonymous shared memory-mapped file is created through operating system kernel calls, and a circular buffer is opened as a dedicated channel for data transmission. When creating the transmission area, read and write permission locks are set to ensure data consistency between the main process and the slave process (host process) during concurrent access, and to prevent dirty reads or write conflicts.

[0077] It adopts a dual-channel parallel mechanism; it uses lightweight RPC frameworks such as gRPC to transmit control signaling (such as data ready notification and memory offset address), and uses memory pointers to directly manipulate data entities, avoiding serialization overhead; it implements a direct access mechanism of "write-read mapping"; the data sender directly writes data in the shared transmission area, and the receiver reads directly through address mapping, without generating additional memory copy operations in the middle.

[0078] Specifically, the "visual inspection plugin" in industrial software needs to transmit the acquired high-definition product images (unstructured data type) to the main process for analysis; the system parses the image data type and marks key information: data volume (approximately 200MB / frame), refresh rate (60fps), real-time requirements (latency <5ms); at the same time, it marks the image's metadata information, such as: image width, height, and pixel format.

[0079] The system traced key information and found that if traditional Socket transmission was used, the serialization and copying of 200MB of data would cause the CPU to be fully loaded and the latency to be extremely high. Therefore, the system calculated the optimal transmission combination as "shared memory transmission area" + "gRPC signaling control". At the same time, the system opened a shared memory transmission area named VisionDataZone_A in memory. The vision inspection plugin (from the process) acts as the producer and directly writes the image data captured by the camera into this area without having to go through multiple switches between kernel mode and user mode.

[0080] The transmission method adopts a "separation of control flow and data flow"; when the image data is ready, the plugin only sends a lightweight data ready notification to the main process via gRPC, which includes the offset and length of the image in shared memory; after receiving the notification, the main process directly maps the corresponding position of VisionDataZone_A and reads the image data for algorithm analysis; this process achieves microsecond-level transmission latency, meeting the real-time control requirements of industrial software for high-speed inspection of the production line.

[0081] Therefore, the current working state of the main process is marked, and several key usage contents are determined in combination with the usage history of the industrial software. At the same time, the load of the main process is monitored, and load optimization of the main process is triggered in combination with several key usage contents to maintain the efficient working state of the main process. This is compatible with the overall consideration of the usage history of industrial software and ensures the accuracy of the corresponding key usage contents.

[0082] At this point, using operating system APIs or performance monitoring libraries, the CPU utilization, peak memory consumption, thread pool queue length, and handle count of the main process can be collected in real time; the message processing delay of the main process's UI thread or control loop can be monitored, and it can be marked whether there is message backlog or response timeout; it can be identified whether the main process is in a blocked state such as waiting for I / O or waiting for lock release, and the specific blocking source can be marked.

[0083] Analyze the operation log stream of industrial software to extract user operation sequences (such as "start detection" and "generate report") within a specific time window and identify high-frequency operation patterns; associate specific function module calls with historical resource consumption records to build a "function-load" mapping table; for example, identify that the "batch data export" operation will trigger high I / O load; trace historical execution paths to determine which plug-in combinations caused resource contention in past operations and mark them as "critical usage content".

[0084] Set multi-dimensional load thresholds (e.g., CPU > 80%, memory fragmentation rate > 30%) and compare the current load metrics with the thresholds in real time; use the sliding window algorithm to calculate the load's upward slope to determine whether the load is stable, rapidly increasing, or about to explode; monitor resource contention between the main process and slave processes (plugin hosts) to determine if there is any preemption of CPU time slices or memory bandwidth; simultaneously, when monitoring shows excessively high load and the critical usage is a non-real-time task (e.g., log archiving), automatically reduce its thread priority or suspend it; combine the communication mechanism of step S13 to dynamically adjust the heartbeat frequency or data polling interval of the main process and slave processes; reduce the frequency during idle periods to save CPU, and maintain the necessary communication frequency during high loads; for high-frequency data transmission, trigger a "batch processing" mechanism to merge multiple small data packets for transmission, or activate a backpressure mechanism to limit the data sending rate of slave processes and prevent the main process buffer from overflowing.

[0085] After load optimization is triggered, the resource quota of slave processes is further limited by job objects to ensure the resource supply of the main process; memory reclamation is induced during low load intervals to release unreferenced resources and prevent unexpected GC pauses during critical control phases; the effect of optimization is continuously monitored, and if the load does not decrease, a deeper optimization strategy (such as uninstalling non-core plugins) is triggered until the main process returns to an efficient working state.

[0086] Specifically, the system detected that the main process's current CPU usage was 75%, and there were more than 50 pending messages in the UI thread's message queue, marked as "busy". Combined with usage history analysis, it was found that the current period was "month-end report generation". Historical records showed that this operation would trigger a large-scale database query, consuming a lot of I / O resources. Real-time monitoring showed that the main process's memory bandwidth usage had reached the warning threshold, and the "visual inspection plugin" child process was performing high-intensity intelligent inference, which was competing for CPU resources.

[0087] The system determined that "report generation" was a secondary critical task, automatically reducing its thread priority from "normal" to "low" and limiting its database connection count. At the same time, it triggered communication flow control, instructing the "visual inspection plugin" to change the upload frequency of result data from per frame to batch transmission once every 5 frames, reducing gRPC communication overhead. After optimization, the CPU utilization of the main process dropped back to 45%, and the UI response latency was reduced from 500ms to less than 50ms, ensuring the smoothness of operators' real-time monitoring and control commands for the production line.

[0088] refer to Figure 5 In step S14, the specific steps are as follows:

[0089] S141: Mark the plugins used by the industrial software and trigger the security check of the plugins synchronously as the working software is used. In the security check of the plugins, mark multiple detection results of the plugins, determine multiple reliable information corresponding to the multiple detection results, and determine the reliability performance of the plugins in combination with the usage status of the industrial software.

[0090] S142: Perform permission control on the plugins used by the industrial software, and determine the corresponding access permissions in the control process. If the access permissions are open, mark the operation log of the industrial software, and trace the operation status according to the operation log of the industrial software to determine multiple status information. Based on the fusion of multiple status information factors, the operation status of the industrial software is presented in real time.

[0091] In the embodiments of this application, the plug-ins used by the industrial software are marked, and the security checks of the plug-ins are triggered synchronously as the working software is used. In the security checks of the plug-ins, multiple detection results of the plug-ins are marked, and multiple reliable information corresponding to the multiple detection results are determined. The reliability performance of the plug-ins is determined in combination with the usage status of the industrial software, which takes into account the overall consideration of multiple detection results and ensures the accuracy of the corresponding multiple reliable information.

[0092] At this time, when the plugin calls sensitive APIs (such as file read / write and network communication), a security check routine is triggered through Hook technology; in line with the control rhythm of the main process, security detection probes are sent to the plugin child processes periodically, and memory integrity checks are triggered synchronously; when the plugin attempts to access the industrial database or control command flow, the security review process of the sandbox isolation boundary is automatically activated.

[0093] The system checks for buffer overflows, dangling pointer accesses, or unmanaged memory out-of-bounds errors in the plugin, marking the result as "Memory Safety." It compares the currently loaded DLL file with its original signature to detect DLL hijacking or injection attacks, marking the result as "Dependency Integrity." It monitors the plugin's system call sequence to determine if there is any abnormal behavior (such as unauthorized port scanning), marking the result as "Behavior Compliance." Simultaneously, based on a weighted algorithm, it scores the detection results across different dimensions, outputting reliability labels such as "High Trust," "Medium Trust," and "Dangerous." If the detection results are abnormal, it parses the specific abnormal code segment or instruction address to generate fault location information. Combining multiple detection results, it analyzes the plugin's performance degradation or stability decline trend, outputting predictive reliability information.

[0094] The plugin reliability information is correlated with the current operating status of the industrial software, such as "in production", "standby", and "debugging". In the "in production" state, if a plugin has potential risks, its reliability performance is determined to be unsatisfactory, triggering a circuit breaker or isolation mechanism. In the "debugging" state, the fault tolerance threshold can be appropriately relaxed. The final plugin reliability performance rating is output to guide the main process on whether to continue distributing tasks or start a backup plugin.

[0095] Furthermore, access control is implemented for the plugins used by the industrial software, and corresponding access permissions are determined during the control process. If the access permission is open, the operation log of the industrial software is marked, and the operation status is traced based on the operation log to determine multiple status information. The operation status of the industrial software is presented in real time based on the fusion of multiple status information and multiple factors. This approach is compatible with the overall consideration of access control for the plugins used by the industrial software, ensuring the accuracy of the corresponding access permissions. At the same time, the introduction of access permissions for the plugins used by the industrial software improves the security control of the industrial software and ensures the stability and communication performance of multiple plugins integrated in the industrial software.

[0096] At this point, based on the master-slave process isolation architecture, a clear resource access control list (ACL) is configured for each host process, restricting plugins to accessing only specific memory regions, file paths, or network ports; an interception gateway is deployed at the interaction layer between the plugin and the operating system or the master process to intercept and audit sensitive API calls (such as modifying the system time or formatting the disk); access tokens with time limits and scope restrictions are issued to legitimate plugins, and requests without tokens or with expired tokens are rejected.

[0097] Parse the configuration list of the current plugin, extract its declared permission requirements (such as "read-only database" and "allow camera capture"), and compare them with the system's preset security policy; when the plugin attempts to access resources, the system calculates its permission matrix to determine whether the current operation is within the authorized scope; output the permission judgment result, marked as "allow", "deny" or "requires auditing".

[0098] When access permissions are approved (open state), a logging routine is triggered; the operation time, plugin ID, resource type, operation type (read / write), and execution result are written to the industrial software's runtime log library in a structured data format (such as JSON); data points are embedded in key business logic nodes to capture the data flow and control command transmission process, and to mark runtime snapshots of key nodes.

[0099] The system utilizes a streaming computing engine to consume runtime logs in real time and reassembles the behavior chain of plugins according to time sequence. By tracking the associated IDs (such as SessionID or TransactionID) in the logs, it connects the complete causal chain of the main process issuing instructions, plugin execution, and result return. When a logical breakpoint or delay anomaly is detected, it quickly locates the specific log segment and traces the plugin behavior or data input that caused the anomaly.

[0100] The system extracts features such as throughput, error rate, resource utilization, and business completion from the traceability link; it categorizes scattered status information into system-level status, plug-in-level status, and business-level status; simultaneously, it employs weighted fusion or DS evidence theory to fuse status information from different dimensions, eliminating false alarms caused by fluctuations in a single indicator; it utilizes dashboard technology to render the fused status data in real time, presenting it in the form of topology diagrams, trend curves, or alarm lists; and it pushes the fused real-time status to the UI of the industrial software via technologies such as WebSocket, achieving millisecond-level status updates.

[0101] Please see Figure 6 , Figure 6 This is a schematic diagram of the structural composition of a control system for industrial software based on a communication mechanism according to an embodiment of the present invention; the control system for industrial software based on a communication mechanism is applied to the above-mentioned control method for industrial software based on a communication mechanism; the control system for industrial software based on a communication mechanism includes:

[0102] The communication interaction module 21 is used to mark the industrial database corresponding to the industrial software, determine the corresponding data architecture by detecting the industrial database, configure the corresponding plugins for the data architecture, allow different versions of plugins to coexist in the industrial software, and communicate and interact along the communication mechanism.

[0103] The data chain module 22 is used to mark the dependencies of each plugin, construct multiple corresponding data chains based on the dependencies, load each data chain into the same assembly resolver, intercept the corresponding loading request for each data chain, and dynamically reconstruct the search path in combination with the specific configuration information of the current plugin, so that each plugin can locate the DLL file it needs;

[0104] The dynamic optimization module 23 is used to mark the application scenario of the industrial software, determine the corresponding data type based on the analysis of the application scenario, configure the corresponding data transmission area and corresponding data transmission method for the data type, and dynamically optimize the load of the main process.

[0105] The running status module 24 is used to perform security checks on the plugins used by the industrial software, determine the reliability performance of the plugins during the check, mark the access permissions of the plugins used by the industrial software, and trace the running status based on the running logs of the industrial software to present the running status of the industrial software in real time.

[0106] The technical features of the above embodiments can be combined arbitrarily. For the sake of brevity, not all combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

Claims

1. A control method for industrial software based on a communication mechanism, characterized in that, include: The process involves: marking the industrial database corresponding to the industrial software; determining the corresponding data architecture by detecting the industrial database; configuring corresponding plugins for the data architecture; allowing different versions of plugins to coexist within the industrial software and communicate with each other through a communication mechanism; real-time monitoring of the industrial software; determining the corresponding industrial database by detecting the industrial software, which stores multiple key information in the industrial production process; dynamically detecting the industrial database and determining multiple sub-data architectures during the detection process; determining the corresponding data architecture based on the fusion of multiple sub-data architectures; marking multiple functional requirements corresponding to the data architecture; matching corresponding plugins by tracing each functional requirement to mark multiple plugins of different versions; loading multiple plugins into the same industrial software; and using the communication mechanism to achieve communication and interaction among multiple plugins. The dependencies of each plugin are marked, and multiple data chains are constructed based on these dependencies. Each data chain is loaded into the same assembly resolver, and the corresponding loading requests for each data chain are intercepted. The search path is dynamically reconstructed in conjunction with the specific configuration information of the current plugin, so that each plugin can locate the DLL file it needs. This includes: dynamically matching each plugin and determining the corresponding relationship information during the matching process; determining the dependencies of each plugin based on the dynamic identification of the relationship information; iterating over the dependency relationship and determining multiple data nodes during the iteration process; integrating multiple data nodes through multiple factors and outputting the corresponding data chain; and loading each data chain along different data channels into the same assembly resolver. The application scenarios of the industrial software are marked, the corresponding data types are determined based on the analysis of the application scenarios, the corresponding data transmission areas and data transmission methods are configured for the data types, and the load of the main process is dynamically optimized. Security checks are performed on the plugins used by the industrial software, and the reliability of the plugins is determined during the check. At the same time, the access permissions of the plugins used by the industrial software are marked, and the running status is traced based on the running logs of the industrial software to present the running status of the industrial software in real time.

2. The control method for industrial software based on a communication mechanism according to claim 1, characterized in that, The process involves marking the dependencies of each plugin, constructing multiple corresponding data chains based on these dependencies, loading each data chain into the same assembly resolver, intercepting the corresponding loading requests for each data chain, and dynamically reconstructing the search path based on the specific configuration information of the current plugin. This ensures that each plugin locates the DLL file it needs. The process also includes: In this assembly resolver, the loading requests corresponding to each data chain are obtained, and multiple sub-loading items are determined based on the parsing of the loading requests. At the same time, the specific configuration information of the current plugin is obtained, and the multiple sub-loading items and the specific configuration information of the current plugin are matched by multiple factors. The corresponding search path is reconstructed, and the search is performed along the search path to match the corresponding DLL file, so that each plugin matches the corresponding DLL file.

3. The control method for industrial software based on a communication mechanism according to claim 1, characterized in that, The application scenario of the industrial software is marked, and the corresponding data type is determined based on the analysis of the application scenario. A corresponding data transmission area and data transmission method are configured for this data type, and the load of the main process is dynamically optimized, including: The scene nodes of the industrial software are collected and detected to determine multiple data scene factors. Based on the multiple data scene factors, the corresponding application scenario is determined. The application scenario is dynamically analyzed along multiple dimensions and the corresponding data types are output sequentially. In this data type, multiple key data information are marked, and the corresponding data transmission combination is determined by tracing each key data information. This data transmission combination covers the corresponding data transmission area and the corresponding data transmission method.

4. The control method for industrial software based on a communication mechanism according to claim 3, characterized in that, The process of marking the application scenarios of the industrial software, determining the corresponding data type based on the analysis of the application scenarios, configuring corresponding data transmission areas and data transmission methods for the data type, and dynamically optimizing the load of the main process also includes: The current working state of the main process is marked, and several key usage contents are determined based on the usage history of the industrial software. At the same time, the load of the main process is monitored, and load optimization of the main process is triggered based on the multiple key usage contents to maintain the efficient working state of the main process.

5. The control method for industrial software based on a communication mechanism according to claim 1, characterized in that, The process includes performing security checks on the plugins used by the industrial software, determining the reliability of the plugins during the checks, marking the access permissions of the plugins used by the industrial software, and tracing the operational status based on the industrial software's operation logs to present the operational status of the industrial software in real time. The plugins used by the industrial software are marked, and the security checks of the plugins are triggered synchronously as the software is used. During the security checks of the plugins, multiple detection results of the plugins are marked, and multiple reliable information corresponding to the multiple detection results are determined. The reliability performance of the plugins is determined in combination with the usage status of the industrial software.

6. The control method for industrial software based on a communication mechanism according to claim 5, characterized in that, The process of performing security checks on the plugins used by the industrial software, determining the reliability of the plugins during the checks, marking the access permissions of the plugins used by the industrial software, and tracing the operational status based on the industrial software's operation logs to present the operational status of the industrial software in real time, also includes: Access control is implemented for the plugins used by the industrial software, and corresponding access permissions are determined during the control process. If the access permission is open, the operation log of the industrial software is marked, and the operation status is traced according to the operation log to determine multiple status information. The operation status of the industrial software is presented in real time based on the fusion of multiple status information and multiple factors.

7. A control system for industrial software based on a communication mechanism, characterized in that, The control system of the industrial software based on the communication mechanism is applied to the control method of the industrial software based on the communication mechanism as described in any one of claims 1-6; the control system of the industrial software based on the communication mechanism includes: The communication and interaction module is used to mark the industrial database corresponding to the industrial software, determine the corresponding data architecture by detecting the industrial database, configure the corresponding plugins for the data architecture, and allow different versions of plugins to coexist in the industrial software and communicate and interact along the communication mechanism. The data chain module is used to mark the dependencies of each plugin, build multiple corresponding data chains based on the dependencies, load each data chain into the same assembly resolver, intercept the corresponding loading request for each data chain, and dynamically reconstruct the search path in combination with the specific configuration information of the current plugin, so that each plugin can locate the DLL file it needs; The dynamic optimization module is used to mark the application scenarios of the industrial software, determine the corresponding data type based on the analysis of the application scenario, configure the corresponding data transmission area and corresponding data transmission method for the data type, and dynamically optimize the load of the main process. The runtime status module is used to perform security checks on the plugins used by the industrial software, determine the reliability of the plugins during the check, mark the access permissions of the plugins used by the industrial software, and trace the runtime status based on the runtime logs of the industrial software to present the runtime status of the industrial software in real time.

Images