A multi-protocol collaborative scheduling and control method and system for heterogeneous devices
By constructing a device context object and a protocol converter that dynamically matches device driver instances, the problem of protocol differences in heterogeneous device collaborative scheduling is solved, enabling cross-protocol collaborative scheduling and a unified state view, thereby improving the system's scalability and collaborative efficiency.
Patent Information
- Application Number
- CN202611183884.8
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Filing Date
- 2026-08-06
- Publication Date
- 2026-11-17
- Estimated Expiration
- 2046-08-06
AI Technical Summary
Existing technologies make it difficult to achieve collaborative scheduling of heterogeneous devices with differences in communication protocols and inconsistent command formats, resulting in bloated system architecture, high coupling, high deployment costs, poor real-time performance, and difficulties in collaboration.
Construct a device context object, which includes device identifier, protocol type identifier, and real-time operating status. By dynamically matching the downlink converter and uplink parser in the device driver instance, it realizes protocol conversion and status decoding, shields the heterogeneity of the underlying hardware, and supports cross-protocol collaborative scheduling decisions.
It enables collaborative scheduling of heterogeneous devices with inconsistent communication protocols and command formats, improves the scalability and maintainability of the system, eliminates information silos, and optimizes the efficiency of multi-device collaboration.
Smart Images

Figure CN122698640B_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of heterogeneous device collaborative scheduling technology, and more specifically, to a multi-protocol collaborative scheduling control method and system for heterogeneous devices. Background Technology
[0002] With the rapid development of industrial robots, Automated Guided Vehicles (AGVs) and Autonomous Mobile Robots (AMRs) have become indispensable core equipment in today's intelligent manufacturing and automated logistics industries. As production scale gradually expands and technology iterates, companies often need to introduce various brands and types of industrial robots to meet increasingly complex application requirements. However, different brands of robots often use different communication protocols and control command formats, making the collaborative scheduling of multi-brand robots a challenging industry problem.
[0003] There are three main technical solutions for collaborative scheduling of heterogeneous equipment: First, deploying an independent multi-protocol compatible system (Robot Control System, RCS) for each AGV brand, with the upper-level task management system responsible for cross-system coordination. This solution has a bloated system architecture, with each RCS system operating independently, leading to data silos, difficulties in cross-brand collaboration, poor real-time performance, and high deployment costs. Second, integrating the driving logic of multiple brands within a single RCS system through hard-coded conditional statements. This solution violates the open / closed principle, has high coupling, requires modification of core code for each new or modified brand, involves a large amount of regression testing, and cannot support dynamic loading of new brand drivers at runtime. Third, requiring all AGV manufacturers to adhere to a unified communication standard such as VDA5050. This solution faces challenges such as the difficulty of retrofitting existing equipment, limitations of standard protocol functionality in covering manufacturer-specific features, and low manufacturer cooperation, making practical implementation difficult. Therefore, how to achieve collaborative scheduling of heterogeneous equipment under different communication protocols and inconsistent command formats has become a challenge for the industry. Summary of the Invention
[0004] This application provides a multi-protocol collaborative scheduling control method and system for heterogeneous devices, which can realize collaborative scheduling of heterogeneous devices under different communication protocols and inconsistent command formats.
[0005] In a first aspect, this application provides a multi-protocol cooperative scheduling and control method for heterogeneous devices, comprising the following steps: Construct corresponding device context objects for connected heterogeneous devices. The device context objects include at least device identifier, protocol type identifier, and real-time operating status. In response to a standard control command, the protocol type identifier of the target heterogeneous device is obtained from the device context object according to the standard control command, and the target device driver instance corresponding to the target heterogeneous device is dynamically determined from multiple registered device driver instances based on the protocol type identifier, wherein each device driver instance includes a downlink converter and an uplink parser for protocol conversion; The standard control command is converted into a protocol by the downlink converter in the target device driver instance, generating a control message in a device-specific protocol format and sending it to the target heterogeneous device. The uplink status message reported by the target heterogeneous device is received, and the uplink parser decodes the uplink status message into a standard format status object and updates the real-time running status in the corresponding device context object. Based on the real-time operating status in the updated device context objects, cross-protocol collaborative scheduling decisions are made for each heterogeneous device.
[0006] In some embodiments, the device context object further includes a device communication address, device capability information, and a task execution sequence. The device communication address is used to identify the network communication endpoint of the corresponding heterogeneous device. The device capability information is used to describe the action types and load parameters supported by the corresponding heterogeneous device. The task execution sequence is used to record the atomic tasks currently to be executed and assigned to the heterogeneous device.
[0007] In some embodiments, the process of converting the standard control command into a protocol using a downlink converter in the target device driver instance, generating a control message in a device-specific protocol format, and sending it to the target heterogeneous device specifically includes: The downlink converter reads the device communication address from the target device context object and uses the device communication address as the target address of the control message; The message instruction code is determined based on the command type of the standard control command. According to the message encapsulation rules corresponding to the protocol type identifier, the message instruction code and the device communication address are encapsulated into a control message in the device-specific protocol format, and sent to the target heterogeneous device through the corresponding communication link.
[0008] In some embodiments, decoding the uplink status message into a standard format status object via the uplink parser specifically includes: The protocol type identifier of the target heterogeneous device is obtained through the uplink parser, and the device status field is extracted from the uplink status message according to the message parsing rules corresponding to the protocol type identifier. The device status fields are mapped to unified status attributes to generate the standard format status object; wherein, the unified status attributes include device location coordinates, current battery level, operating speed, task execution status, and fault code.
[0009] In some embodiments, making cross-protocol collaborative scheduling decisions for heterogeneous devices based on the updated real-time operating status in each device context object specifically includes: Read the real-time running status from the updated device context objects and build a global device status view; Based on the global device status view, path conflict detection is performed to determine whether multiple heterogeneous devices are about to have a path conflict in the shared area. When a path conflict is detected, conflict resolution paths are planned for each heterogeneous device involved in the conflict, and cross-protocol collaborative scheduling instructions are generated. The cross-protocol collaborative scheduling instruction is decomposed into standard control commands for each target device, and then issued and executed through the corresponding device driver instance.
[0010] In some embodiments, the method further includes: when each device driver instance registers, it declares an adapted protocol type identifier through a service provider interface configuration file, wherein the configuration file records the correspondence between the protocol type identifier and the location of the driver class file.
[0011] In some embodiments, dynamically determining the target device driver instance corresponding to the target heterogeneous device from a plurality of registered device driver instances based on the protocol type identifier specifically includes: Determine from among the registered device driver instances whether a device driver instance matching the protocol type identifier already exists; If it does not exist, the corresponding device driver class is instantiated through reflection, a new device driver instance is created and stored in the instance cache table; Use an existing or newly created device driver instance as the target device driver instance.
[0012] Secondly, this application provides a multi-protocol cooperative scheduling and control system for heterogeneous devices, used to execute a multi-protocol cooperative scheduling and control method for heterogeneous devices. The system includes: The context management module is used to construct corresponding device context objects for accessed heterogeneous devices. The device context object includes at least a device identifier, a protocol type identifier, and a real-time running status. The driver routing module is used to respond to standard control commands, obtain the protocol type identifier of the target heterogeneous device from the device context object according to the standard control commands, and dynamically determine the target device driver instance corresponding to the target heterogeneous device from multiple registered device driver instances based on the protocol type identifier. Each device driver instance includes a downlink converter and an uplink parser for protocol conversion. The protocol conversion module is used to convert the standard control command into a protocol using the downlink converter in the target device driver instance, generate a control message in a device-specific protocol format and send it to the target heterogeneous device, receive the uplink status message reported by the target heterogeneous device, decode the uplink status message into a standard format status object using the uplink parser, and update the real-time running status in the corresponding device context object. The collaborative scheduling module is used to make cross-protocol collaborative scheduling decisions for heterogeneous devices based on the real-time running status in the updated device context objects.
[0013] Thirdly, this application provides a computer device, the computer device including a memory and a processor, the memory storing code, and the processor being configured to acquire the code and execute the above-described multi-protocol cooperative scheduling and control method for heterogeneous devices.
[0014] Fourthly, this application provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the aforementioned multi-protocol cooperative scheduling and control method for heterogeneous devices.
[0015] The technical solutions provided by the embodiments disclosed in this application have the following beneficial effects: The multi-protocol collaborative scheduling and control method and system for heterogeneous devices provided in this application first constructs a corresponding device context object for the accessed heterogeneous devices. The device context object includes at least a device identifier, a protocol type identifier, and a real-time operating status. Second, in response to a standard control command, the protocol type identifier of the target heterogeneous device is obtained from the device context object according to the standard control command. Based on the protocol type identifier, the target device driver instance corresponding to the target heterogeneous device is dynamically determined from multiple registered device driver instances. Each device driver instance includes a downlink converter and an uplink parser for protocol conversion. Then, the standard control command is converted into a protocol by the downlink converter in the target device driver instance, generating a control message in a device-specific protocol format and sending it to the target heterogeneous device. The uplink status message reported by the target heterogeneous device is received, and the uplink parser decodes the uplink status message into a standard format status object and updates the real-time operating status in the corresponding device context object. Finally, based on the updated real-time operating status in each device context object, cross-protocol collaborative scheduling decisions are made for each heterogeneous device.
[0016] Therefore, this application can achieve collaborative scheduling of heterogeneous devices under conditions of different communication protocols and inconsistent command formats. First, by constructing a device context object that includes at least a device identifier, a protocol type identifier, and real-time operating status, the physical differences between heterogeneous devices are transformed into a unified data model. This provides a standardized operation entry point for the upper-layer scheduling logic to shield the underlying hardware heterogeneity, solving the problem that devices of different brands and protocols cannot be described using a unified data structure. Second, by adopting a mechanism that dynamically matches the target driver from multiple registered device driver instances containing downlink converters and uplink parsers based on the protocol type identifier, the protocol adaptation layer and the service scheduling layer are decoupled. This allows adding a new device type to only require extending the driver instance without modifying the core scheduling logic, improving the system's scalability and maintainability. Finally, the downlink converter converts standard control commands into device-specific protocols. The system sends out control messages in a standardized format, and then the uplink parser decodes the uplink status messages reported by the devices into standard-formatted status objects and updates the real-time running status in the device context object. This completes a bidirectional transparent conversion from unified commands to private protocol messages and then to a unified status view, enabling the scheduling layer to interact with all heterogeneous devices with unified semantics and eliminating information silos in multi-protocol coexistence scenarios. Finally, based on the updated real-time running status in each device context object, the system makes cross-protocol collaborative scheduling decisions for each heterogeneous device, enabling the system to perform conflict detection and collaborative path planning on a globally unified status view. This optimizes the efficiency of multi-device collaboration from an overall perspective and avoids the problem of devices being unable to coordinate and avoid each other due to protocol barriers. In summary, the technical solution provided in this application can realize collaborative scheduling of heterogeneous devices under different communication protocols and inconsistent command formats. Attached Figure Description
[0017] Figure 1 This is an overall architecture block diagram of a multi-protocol collaborative scheduling and control method for heterogeneous devices, as shown in some embodiments of this application. Figure 2 This is an exemplary flowchart of a multi-protocol collaborative scheduling and control method for heterogeneous devices, as shown in some embodiments of this application. Figure 3 This is a schematic diagram of the structure of a multi-protocol collaborative scheduling and control system for heterogeneous devices, as shown in some embodiments of this application. Figure 4 This is a schematic diagram of the structure of a computer device that implements a multi-protocol collaborative scheduling and control method for heterogeneous devices, according to some embodiments of this application. Detailed Implementation
[0018] To better understand the technical solution of this application, the technical solution of this application will be described in detail below with reference to the accompanying drawings and specific embodiments.
[0019] refer to Figure 1 This figure is an overall architecture block diagram of a multi-protocol collaborative scheduling and control method for heterogeneous devices according to some embodiments of this application. In this figure, the collaborative scheduling decision relies on the device identifier, protocol type identifier, and real-time operating status stored in the device context object to carry out cross-device collaborative scheduling. After issuing or responding to standard control commands, the corresponding target device driver instance is dynamically selected according to the protocol type identifier through the device driver instance matching link. The downlink converter inside the target device driver instance converts the standard control command into a dedicated protocol message adapted to the device and sends it to the heterogeneous device. The uplink status message returned by the heterogeneous device is then converted into standard format information by the uplink parser, thereby updating the real-time operating status in the device context object, realizing data interoperability and collaborative management between the upper-layer unified standard command and the lower-layer multi-protocol heterogeneous devices.
[0020] refer to Figure 2 The figure is an exemplary flowchart of a multi-protocol collaborative scheduling and control method for heterogeneous devices according to some embodiments of this application. The figure mainly includes the following steps: In step S101, a corresponding device context object is constructed for the accessed heterogeneous device. The device context object includes at least a device identifier, a protocol type identifier, and a real-time operating status.
[0021] Specifically, when a heterogeneous device first accesses the system via a wired or wireless physical link, the system captures the network access announcement message initiated by the device, which includes information such as the device model, serial number, and supported protocol types. This announcement message is a standardized data unit that conforms to a specific link layer frame format and is actively broadcast by the device after power-on or network connection restoration. Next, the device registration function is called to parse the device model and protocol type strings from the payload field of the announcement message. Based on the device model, an XPath query is performed in a pre-set XML format device capability description file to extract the working capability boundaries such as the action types and maximum load parameters supported by the device model. This device capability description file is a structured document provided by the device manufacturer. If no device capability description file matching the device model is found in the pre-set directory, the system reads the basic capability parameters from the device information model defined in the protocol standard according to the device's protocol type identifier, or dynamically obtains the actual supported action instruction set and load range of the device by sending a pre-set probe command frame to the device and parsing its response message. The obtained results are used as the default capability information of the device model and cached in the local capability description file for subsequent reuse. Subsequently, the system assigns a globally unique device identifier to the device based on the UUID generation algorithm. At the same time, the corresponding protocol type identifier constant is searched in the system's global protocol registration mapping table according to the parsed protocol type string. This protocol registration mapping table is a statically initialized hash structure that maintains the mapping relationship between protocol name strings and integer enumeration values. Next, the device communication address is constructed based on the IP address and port number allocated by the network layer, and a set of empty atomic task queues is created as the initial task execution sequence. Finally, the device identifier, protocol type identifier constant, device communication address, device capability information, task execution sequence, and a real-time running status field initially set to idle are encapsulated into a complete device context object according to the device context class definition. This object is then stored in the system's global concurrent hash mapping table with the device identifier as the key, completing the construction and registration of digital twins of heterogeneous devices. This concurrent hash mapping table is a thread-safe container used to maintain the context index of all online devices.
[0022] It should be noted that the device context object in this application includes at least the following information: device identifier, i.e., a unique identifier for heterogeneous devices, used for routing queries and status association; protocol type identifier, used to identify the brand or protocol type to which the heterogeneous device belongs, which is the core key value for the driver routing module to look up driver instances; real-time operating status, including the device's current location coordinates, battery level, operating speed, task execution status, fault codes, and other real-time information, continuously updated by the uplink parser; and device communication address, used to identify the network communication endpoint of the heterogeneous device, such as IP address and port number, message queue information, etc. Subscription topic paths, etc., are read from the device context object as the target address of the message when the downlink converter constructs the control message; device capability information, which describes the action types and load parameters supported by heterogeneous devices, such as maximum load, maximum speed, and supported navigation modes, can be used by the scheduling layer to match capabilities when allocating tasks; task execution sequence, which records the list of atomic tasks currently to be executed and assigned to the device, including the task identifier and task sequence number of each task, is read from the list of atomic tasks to be executed and encapsulated into the message when the downlink converter constructs the control message.
[0023] It should be noted that, in this application, the device context object refers to the data model instance of each heterogeneous device. This data model instance encapsulates the static attributes and dynamic status of the device into a digital twin that can be uniformly scheduled. The static attributes include a globally unique device identifier, a protocol type identifier indicating the communication protocol, a device communication address locating the network endpoint, and device capability information describing the device's functional boundaries. The dynamic status includes the real-time operating status decoded and extracted from the latest uplink status message reported by the device and the task execution sequence recording the current task progress. This digital twin shields the differences in physical interfaces and data formats of the underlying heterogeneous devices, providing the upper-layer scheduling logic with a single standardized entry point for reading and writing operations and monitoring the status of the device.
[0024] It should also be noted that the concurrent hash map in this embodiment refers to a thread-safe key-value pair storage container based on a hash algorithm. By dividing the internal data space into multiple independent segments and using a segmented locking mechanism, it allows multiple threads to simultaneously perform insertion, deletion, or search operations on key-value pairs in different segments without data contention. This provides higher throughput than global synchronization locks in high-concurrency access scenarios. In this scheme, it is used to maintain a one-to-one mapping relationship between device identifiers and device context objects, or between protocol type identifiers and device driver instances. This enables the scheduler to quickly retrieve the context of the target device or match the corresponding driver instance in parallel when responding to multiple standard control commands. Its constant-time lookup performance ensures the real-time nature of collaborative scheduling decisions.
[0025] After constructing the corresponding device context object for the connected heterogeneous devices, the process also includes task allocation and sequence update: When an atomic task for a specific heterogeneous device is generated, the atomic task is encapsulated into a standard control command, and a task identifier and timestamp are appended to the tail of the task execution sequence in the device context object. At the same time, the device context object maintains a task status listener. When the task execution status field in the standard format status object decoded by the uplink parser changes from "running" to "idle" or "faulty", the task status listener triggers a task completion callback, removes the entry corresponding to the task identifier from the head of the task execution sequence, and updates the execution priority weight of the remaining tasks in the sequence to ensure that the task execution sequence always reflects the latest status of the tasks currently pending and assigned by the device.
[0026] In step S102, in response to a standard control command, the protocol type identifier of the target heterogeneous device is obtained from the device context object according to the standard control command, and the target device driver instance corresponding to the target heterogeneous device is dynamically determined from multiple registered device driver instances based on the protocol type identifier, wherein each device driver instance includes a downlink converter and an uplink parser for protocol conversion.
[0027] In some embodiments, obtaining the protocol type identifier of the target heterogeneous device from the device context object in response to a standard control command is achieved through the following steps: In response to a standard control command, obtain the device identifier of the target heterogeneous device in the standard control command; Based on the device identifier, the protocol type identifier of the target heterogeneous device is obtained from the corresponding device context object.
[0028] Specifically, firstly, upon receiving a standard control command, the device identifier of the target heterogeneous device is extracted from the standard control command. This device identifier is a globally unique numeric or string index assigned to the device upon its initial access, used to accurately locate a specific physical device entity in the runtime environment. Secondly, using the device identifier as a key, the corresponding device context object is retrieved from the concurrent hash map table. After obtaining the device context object from the hash map, the protocol type identifier stored within the data structure of the device context object is accessed. This protocol type identifier is a predefined integer enumeration value or a standardized string used to characterize the underlying communication protocol type followed by the target device, such as "Modbus-RTU" or "OPC-UA".
[0029] It should be noted that the protocol type identifier in this application refers to the communication protocol category followed by the underlying layer of the target heterogeneous device at runtime. For example, it can be used to distinguish the Modbus serial link protocol, the OPC unified architecture protocol, or the EtherCAT Ethernet control automation technology protocol in the form of a digital code. When the device registers for network access, the driver adaptation layer identifies and writes this field into the device context object based on the protocol declaration information in the device description file or the network access announcement message. Subsequently, when the upper-layer scheduling logic needs to issue standard control commands, the system can accurately match the downlink converter and uplink parser instances with the corresponding protocol conversion capabilities in the driver instance registry by retrieving this identifier, thereby realizing the automatic mapping from unified scheduling instructions to device private data packets.
[0030] In some embodiments, dynamically determining the target device driver instance corresponding to the target heterogeneous device from a plurality of registered device driver instances based on the protocol type identifier is achieved through the following steps: Determine from among the registered device driver instances whether a device driver instance matching the protocol type identifier already exists; If it does not exist, the corresponding device driver class is instantiated through reflection, a new device driver instance is created and stored in the instance cache table; Use an existing or newly created device driver instance as the target device driver instance.
[0031] Specifically, first, using the protocol type identifier as the key, a hash lookup operation is performed in the instance cache table that maintains the mapping relationship between protocol type identifiers and device driver instances. This instance cache table is a concurrent hash mapping structure implemented using a segmented locking mechanism, used to store activated driver instance objects to avoid the overhead of repeated construction. Second, if the lookup is successful, meaning that a pointer to a driver instance object associated with the protocol type identifier already exists in the cache table, then this object pointer is directly returned as the target device driver instance. This object pointer is a variable referencing the memory address of the driver instance. Then, if the lookup fails, indicating that the driver component adapted to the protocol has not yet been loaded in the current process space, the fully qualified name of the driver class corresponding to the protocol type identifier is read from the pre-configured XML driver registration configuration file. This driver registration configuration file is a structured text that records the mapping relationship between the protocol type identifier string and the fully qualified name of the driver class in key-value pairs. After obtaining the fully qualified name of the driver class, the system calls the Class function in the Java reflection mechanism. The `forName()` method takes the class name as an argument. The class loader searches for and loads the corresponding bytecode file in the classpath, loads the metadata information of the driver class into the method area, and generates a `Class` object. This `Class` object is a meta-object describing the structural information of the driver class. Then, the `newInstance()` method on this `Class` object is called to trigger the execution of the driver class's parameterless constructor, completing the memory allocation and initialization of the driver instance. Inside the constructor, a message encapsulation template and parsing rule table are pre-generated according to the standard specification of the protocol, generating a new device driver instance. This device driver instance is an executable component that encapsulates the protocol's downlink conversion logic and uplink parsing logic. The mapping pair, with the current protocol type identifier as the key and the newly created driver instance object reference as the value, is written to the instance cache table to achieve driver registration and reuse. Finally, the system returns the object reference of the newly created device driver instance as the target device driver instance to the scheduler, completing the dynamic matching process.
[0032] It should be noted that, in this application, the device driver instance refers to an executable component object created for the communication protocol that encapsulates the protocol downlink conversion logic and uplink parsing logic. This component object internally maintains a message encapsulation template for encoding standard control commands into device-specific protocol messages, and a parsing rule table for decoding the raw byte stream reported by the device into standard status objects. As the core execution unit of the protocol adaptation layer, it receives unified instructions issued by the upper-layer scheduler and completes bidirectional data format conversion between the upper-layer physical device and the lower-layer physical device. The instance construction process occurs when the system first encounters a protocol type identifier and there is no corresponding mapping in the instance cache table. The system reads the fully qualified name of the driver class corresponding to the protocol type identifier from the pre-configured driver registration configuration file. Through the Class.forName() method of the Java reflection mechanism, the application class loader is triggered to locate and load the corresponding driver class bytecode file in the classpath to generate a Class meta-object. Then, the newInstance() method is called to execute the parameterless constructor of the driver class. Inside the constructor, the device address field offset constant table, function code and data field length mapping dictionary, CRC16 lookup table pre-calculated check table and other message encapsulation template data are initialized according to the protocol standard specification. At the same time, the parsing rule table containing the data extraction offset and byte order conversion rules corresponding to different function codes such as coil status, holding register, and input register is initialized. After the initialization is completed, the reference of the newly created driver instance object is stored in the instance cache table of the concurrent hash mapping structure for subsequent reuse.
[0033] In step S103, the standard control command is converted into a protocol by the downlink converter in the target device driver instance, generating a control message in a device-specific protocol format and sending it to the target heterogeneous device. The uplink status message reported by the target heterogeneous device is received, and the uplink parser decodes the uplink status message into a standard format status object and updates the real-time running status in the corresponding device context object.
[0034] In some embodiments, the standard control commands are protocol-converted by a downlink converter in the target device driver instance to generate control messages in a device-specific protocol format and sent to the target heterogeneous device, which is achieved through the following steps: The downlink converter reads the device communication address from the target device context object and uses the device communication address as the target address of the control message; The message instruction code is determined based on the command type of the standard control command. According to the message encapsulation rules corresponding to the protocol type identifier, the message instruction code and the device communication address are encapsulated into a control message in the device-specific protocol format, and sent to the target heterogeneous device through the corresponding communication link.
[0035] Specifically, firstly, after the target heterogeneous device driver instance is determined, its internal downlink converter first retrieves the corresponding device context object from the concurrent hash mapping table using the device identifier of the target heterogeneous device as the key, and reads the network communication endpoint identifier composed of IP address and port number from the device communication address attribute of the object. The network communication endpoint identifier is then assigned to the target address field in the control message structure. This target address field is a fixed offset byte segment in the device-specific protocol data frame used to identify the physical node of the receiver. Next, the downlink converter accesses the command type attribute in the standard control command object. This command type attribute is an enumeration value, such as action semantic constants like "MOVE" or "STOP". A key-value lookup operation is performed in the command mapping dictionary. This command mapping dictionary is a hash mapping pre-established according to the protocol specification during the driver instance construction phase, maintaining the correspondence between standard command enumeration values and protocol native function codes. For example, the standard command enumeration value "MOVE" is mapped to the function code 0x06 for writing to holding registers in the Modbus protocol. The found protocol native function code is written as the message instruction code into the function code field in the control message structure.Finally, the downlink converter obtains the message encapsulation rule instance corresponding to the current protocol type identifier. This message encapsulation rule instance is a structured object generated based on the protocol data frame definition during driver instantiation. It contains template parameters such as device address segment offset, function code segment offset, data field start offset, check field offset, and the byte length of each segment. According to the order specified by these template parameters, the target address field value is filled into the device address offset position of the message buffer, and the message command code is filled into the function code offset position. If the standard control command object also carries a command parameter dictionary, such as the movement speed value or target position coordinates, then the floating-point speed value is converted to 4-byte hexadecimal according to the byte order and data type specified by the protocol, for example, using big-endian to convert the floating-point speed value to 4-byte hexadecimal. The byte sequence is converted and sequentially filled into the data field offset position of the message buffer. A CRC16 cyclic redundancy check algorithm is then executed on the already filled device address segment, function code segment, and data field to generate a 2-byte checksum. This cyclic redundancy check algorithm performs XOR and shift iteration operations on all bytes in the current message buffer from the device address offset to the end of the data field with a pre-generated 256-entry CRC lookup table array to generate a 16-bit checksum, which is then filled into the checksum offset position of the message buffer. This completes the assembly of the control message in the complete device-specific protocol format in memory. The downlink converter reads the device communication address from the device context object and creates a TCP connection to the target device's IP address and port number using the Socket API in the Java standard library, or sends UDP packets via DatagramSocket. The complete byte array of the message buffer is written as the payload to the output stream, and a flush operation is performed, completing the transmission of the control message to the target heterogeneous device. This output stream is the data transmission channel between the socket send buffer maintained by the operating system kernel and the physical network interface card.
[0036] It should be noted that, in this application, the control message refers to an ordered byte sequence that is encapsulated by the downlink converter according to the data frame format definition of the device-specific protocol. The target address, operation semantics and execution parameters in the standard control command are encapsulated in a fixed field structure. This byte sequence is transmitted to the target device in the form of a bit stream on the physical link and is parsed layer by layer by its communication stack, thereby driving the device to perform corresponding mechanical actions or state switching. As the only information carrier between the scheduling layer instruction and the physical execution layer, it carries the complete semantics and addressing information of the downlink action.
[0037] In some embodiments, receiving uplink status messages reported by the target heterogeneous device and decoding the uplink status messages into standard format status objects through the uplink parser is achieved through the following steps: The protocol type identifier of the target heterogeneous device is obtained through the uplink parser, and the device status field is extracted from the uplink status message according to the message parsing rules corresponding to the protocol type identifier. The device status fields are mapped to unified status attributes to generate the standard format status object; wherein, the unified status attributes include device location coordinates, current battery level, operating speed, task execution status, and fault code.
[0038] Specifically, firstly, after reading the uplink status message through the Socket input stream on the communication link corresponding to the target heterogeneous device, the Socket input stream refers to a byte-oriented input stream object established based on a TCP socket connection in the Java standard library. The uplink status message is a raw byte array containing device operating status information actively reported by the device. The uplink parser first obtains the protocol type identifier bound to the driver from the member variables of the driver instance, and then selects the corresponding message parsing rule instance from the parsing rule table set pre-initialized during its construction phase based on the protocol type identifier. This message parsing rule instance is a structured metadata object that defines the offset, length, data type, and corresponding status attribute names of each field of the uplink message. For example, for the uplink status message of the Modbus-RTU protocol driver... The parsing rule example specifies that byte offsets 0 to 1 are the device address segment, offset 2 is the function code segment, offset 3 is the data byte count field, offsets 4 to 7 are 4-byte floating-point data segments of position coordinates, offsets 8 to 9 are 2-byte integer data segments of battery level, offsets 10 to 11 are 2-byte integer data segments of operating speed, offset 12 is a 1-byte enumeration data segment of task execution status, offsets 13 to 14 are 2-byte bitmap data segments of fault codes, and offsets 15 to 16 are CRC16 check fields. The uplink parser, based on the offsets and length parameters recorded in this parsing rule example, sequentially performs memory block copy operations from the original byte array, wraps the original byte array with a ByteBuffer, calls its getFloat method to read 4 bytes from offset 4, and then executes the IEEE 16 checksum. The 754 standard is converted to a floating-point value representing the device's location coordinates. The `getShort` method reads 2 bytes from offset 8 and converts them to an integer value representing the current battery level in big-endian order. The `getShort` method then reads 2 bytes from offset 10 and converts them to an integer value representing the running speed. The `get` method reads 1 byte from offset 12 and compares it with a predefined task execution status enumeration table to convert it into a string value representing a status such as "idle," "running," or "fault." Finally, the `getShort` method reads 2 bytes from offset 13 and performs a bitwise AND operation with a predefined fault code bitmap dictionary to parse it into a list of specific fault descriptions. This fault code bitmap dictionary is a static mapping table that maps each bit of a 16-bit integer to a specific fault type description. `ByteBuffer` refers to the Java standard library's Java...The nio package provides a buffer class for efficient manipulation of raw byte data. Internally, it maintains a byte array storage space and four core cursor pointers for location, limits, capacity, and flags. Finally, after extracting the above field values, the uplink parser writes the floating-point values of the device location coordinates into the location coordinate attribute of the standard status object, the integer value of the current battery level into the battery level attribute, the integer value of the running speed into the speed attribute, the string value of the task execution status into the status attribute, and the list of fault descriptions into the fault code attribute, thereby generating a complete standard-format status object.
[0039] It should be noted that the standard format state object in this application is a data transmission carrier that shields the differences in the underlying protocol and contains only unified semantic attributes, for use by the upper-layer scheduling logic to construct a global state view.
[0040] In some embodiments, updating the real-time running state in the corresponding device context object is achieved through the following steps: Receive uplink status messages reported by the target heterogeneous device and read the protocol type identifier from the device context object corresponding to the target heterogeneous device; Based on the protocol type identifier, the corresponding decoding strategy is matched, and the uplink status message is parsed to obtain a standard format status object. The target state attribute field that has changed is determined by comparing the differences between each state attribute field in the state object and the existing real-time running state in the device context object. The target state attribute field is updated to the real-time running state of the device context object through an atomic write operation.
[0041] Specifically, upon receiving the uplink status message reported by the target heterogeneous device, the system retrieves the corresponding device context object from the concurrent hash map table using the device identifier of the target device as the key, and then uses the protocol type identifier of the device context object. Next, it searches the driver instance cache table for the corresponding target device driver instance using the protocol type identifier as the key, and obtains its uplink parser component from the driver instance. The uplink parser is then called, passing the original uplink status message byte array as an argument. Based on the field offset, field length, and data type definition recorded in the parsing rule instance, the uplink parser wraps the original byte array with a ByteBuffer and sequentially calls the getFloat, getShort, and get methods to extract the device from the specified offset position. The system takes field values such as location coordinates, current battery level, operating speed, task execution status, and fault codes, and assigns each field value to the corresponding attribute of a new standard-format status object, generating a standard-format status object. Then, it reads the current real-time operating status attribute set from the device context object. This real-time operating status attribute set is a mapping structure where status attribute names are keys and attribute values are values. It iterates through each status attribute field in the standard-format status object, performing an equality comparison operation with the corresponding key value in the real-time operating status attribute set. Fields whose attribute values have changed are filtered out and recorded in an incremental change set. This incremental change set is a temporary list used to temporarily store status change items. For example, when the location coordinate value (X=10.5, ...) in the standard-format status object changes... When comparing the floating-point precision threshold between the X coordinate (Y=20.3) and the position coordinates (X=10.2, Y=20.3) recorded in the current real-time running state, it is found that the difference in the X coordinate exceeds the preset threshold of 0.1. Therefore, the position coordinate field is marked as a target state attribute field that has changed. Finally, an atomic write operation is performed on the real-time running state mapping structure in the device context object. This atomic write operation is protected by the ReentrantLock reentrant mutex lock in the Java concurrency package. After acquiring the lock, the new value of each target state attribute field recorded in the incremental change set is written to the corresponding key of the real-time running state mapping structure in sequence. After the write is completed, the lock is released, thereby ensuring that concurrent read and write operations on the device context object in a multi-threaded scheduling environment will not lead to inconsistent state data, and the update of the real-time running state field in the device context object is completed.
[0042] In step S104, based on the real-time running status in the updated device context objects, cross-protocol collaborative scheduling decisions are made for each heterogeneous device.
[0043] In some embodiments, cross-protocol collaborative scheduling decisions for heterogeneous devices based on the updated real-time operating status in each device context object are implemented using the following steps: Read the real-time running status from the updated device context objects and build a global device status view; Based on the global device status view, path conflict detection is performed to determine whether multiple heterogeneous devices are about to have a path conflict in the shared area. When a path conflict is detected, conflict resolution paths are planned for each heterogeneous device involved in the conflict, and cross-protocol collaborative scheduling instructions are generated. The cross-protocol collaborative scheduling instruction is decomposed into standard control commands for each target device, and then issued and executed through the corresponding device driver instance.
[0044] Specifically, firstly, all online device context objects in the concurrent hash mapping table are traversed. From each device context object, the position coordinates, running speed, and task execution status field values from the real-time running status mapping structure are extracted. These values, along with the kinematic constraint parameters from the device identifier and device capability information, are then filled into a two-dimensional spatial index data structure to obtain a global device status view. This global device status view is a spatiotemporal snapshot data structure representing the real-time position distribution, motion trends, and task execution progress of all online heterogeneous devices in the shared physical space at the current moment. Internally, the current position and outline projection of all devices are organized using a recursive nesting method with minimum bounding rectangles. Secondly, a predicted displacement vector is calculated by multiplying the current velocity vector (including speed and direction) of each heterogeneous device by a preset path look-ahead time window. The current position of this predicted displacement vector is then extrapolated along the task waypoint direction. The magnitude of the displacement vector is used to obtain the expected position coordinates at future moments. Then, the spatial range query interface of the R-tree is called. Using the expected position coordinates as the center and the sum of the radius of the outer circle of the device's outline and the preset safety distance as the query radius, the system searches for whether the current or expected positions of other devices fall within the query range. If the query result set is not empty, a path conflict is determined, and the device identifier set of the conflicting devices and the two-dimensional coordinates of the conflict point are recorded. After determining the path conflict, the current position, target waypoint, kinematic constraints, and geometric boundary information of the shared area of each device in the conflicting device set are used as input. A standard conflict-based search algorithm is called to perform conflict resolution path planning. That is, the algorithm adopts a two-layer framework of high-level constraint tree search and low-level single-device path planning. First, a constraint tree root node without any additional constraints is created at the high level, and the low-level planner is called separately for each conflicting device. The algorithm plans the initial path from the current position to the target waypoint. The algorithm discretizes the two-dimensional planar space into a unified grid map by rounding down the diameter of the circumcircle of the device's outline and using it as the grid side length. In the time dimension, it uses the shortest time required for the device to move one grid distance as the time discretization step length, thus expanding the search space into a three-dimensional spatiotemporal grid containing horizontal and vertical coordinates and time step indices. The algorithm's cost function f(n) consists of the cumulative cost g(n) and the heuristic cost h(n). g(n) is the accumulated cost from the starting point in spacetime to the current node along the searched path. This accumulated cost is expressed in time steps. When the movement direction from the parent node to the current node differs from the movement direction from the parent node to the grandparent node, it is considered a turn. The actual cost for this step is multiplied by a turning penalty coefficient greater than 1 and added to g(n), thus ensuring that the search path optimizes the total time consumption of both travel and turning in the time dimension. h(n) uses the Manhattan distance from the current node to the target waypoint divided by the maximum straight-line speed of the device, rounded up, as the estimated remaining time steps. Since the Manhattan distance does not consider turning and the rounded result of dividing by the maximum speed is not greater than the actual remaining optimal time steps, this heuristic function satisfies the acceptability requirement, ensuring that the search result is the time-optimal or near-optimal path. Low-level The algorithm starts from the initial spatiotemporal point during the search, and expands the node with the smallest f(n) value at each step. It generates all legal successor nodes in the 3D spatiotemporal grid for the current node. Legal successor nodes include those that wait for one time step at the current grid coordinates and those that move one time step to their four neighboring grids. Each successor node must satisfy the condition that its corresponding spatiotemporal grid cell is not marked as prohibited from occupation by the constraint set of the current device in the higher-level constraint tree. After generating initial paths for all conflicting devices at the lower level, each path is a sequence of grid coordinates with a time step index. All device paths are aligned according to their time step indices, starting from 0. The time step length of the longest path is found as the maximum time step range for conflict detection. If a device's path length exceeds a certain time step, the device is considered to maintain the last grid coordinate of its path and continue to occupy that grid at that time step. For each time step from time step 0 to the maximum time step, pairwise collision detection is performed. For any two devices A and B, at each time step t, it is checked whether the grid coordinates of device A at time step t are the same as those of device B at time step t. If they are the same, it is recorded as a vertex collision, and its collision tuple contains the device A identifier, the device B identifier, the collision time step t, and the collision grid coordinates. At the same time, it is checked whether the grid coordinates of device A at time step t are the same as those of device B at time step t+1, and whether the grid coordinates of device B at time step t are the same as those of device A at time step t+1. If both conditions are met, it is recorded as an edge crossing collision, and its collision tuple contains the device A identifier, the device B identifier, the collision start time step t, and the two swapped grid coordinates. Upon receiving a detected conflict tuple, the higher-level constraint tree generates two child nodes for that tuple. The first child node adds a spatiotemporal constraint to device A, prohibiting device A from occupying conflict grid coordinates at conflict time step t. The second child node adds a spatiotemporal constraint to device B, prohibiting device B from occupying conflict grid coordinates at conflict time step t. Each child node inherits all existing constraints from its parent node and adds its own new constraints. Then, each child node calculates the total cost of all device paths under its respective node and inserts the child node into a priority queue sorted in ascending order of total cost. Subsequently, the higher-level constraint tree retrieves the node with the lowest total cost from the priority queue and only re-invokes the lower-level constraints for the devices involved in the newly added constraints. The algorithm searches for a new path while satisfying all cumulative spatiotemporal constraints of the device. Other devices unaffected by the new constraints retain their original paths. The newly generated path set undergoes a full-match, full-collision check again using the alignment method described above. If conflicts still exist, the conflicts are decomposed and new child nodes are generated and inserted into the priority queue. If all paths are conflict-free, the path set corresponding to that node is output as the conflict resolution path. If the priority queue is emptied during the search and no conflict-free global path solution is found, the current conflict set is deemed unsolvable, and a cooperative scheduling instruction is generated to issue an immediate stop command to all conflicting devices as a safe termination process. Finally, the conflict-free spatiotemporal trajectory of each device obtained by the successful solution is converted into a cross-protocol coordinated scheduling instruction consisting of a movement speed command and a time-stamped waypoint sequence. This cross-protocol coordinated scheduling instruction is a structured object that encapsulates a multi-device coordinated action scheme. Finally, each target device entry in the cross-protocol coordinated scheduling instruction is traversed, and the movement speed command for a single heterogeneous device and the target waypoint coordinates are encapsulated into a standard control command object. The command type attribute of this standard control command object is set to "MOVE". The command parameter dictionary contains speed value and target coordinate key-value pairs. Using the device identifier of the target heterogeneous device as the key, the corresponding device context object is retrieved from the concurrent hash mapping table to obtain its protocol type identifier. Then, using the protocol type identifier as the key, the corresponding target device driver instance is matched from the instance cache table. The downlink converter of the driver instance is called to convert the standard control command into a control message in the device-specific protocol format and send it to the target device for execution through the communication link, completing the complete closed loop from global decision-making to single-machine execution.
[0045] Furthermore, in another aspect of this application, in some embodiments, this application provides a multi-protocol collaborative scheduling and control system for heterogeneous devices, with reference to... Figure 3 The figure is a schematic diagram of the structure of a multi-protocol collaborative scheduling control system for heterogeneous devices according to some embodiments of this application. The multi-protocol collaborative scheduling control system for heterogeneous devices includes: a context management module 201, a driver routing module 202, a protocol conversion module 203, and a collaborative scheduling module 204, which are described below: The context management module 201 in this application is mainly used to construct corresponding device context objects for accessed heterogeneous devices. The device context object includes at least a device identifier, a protocol type identifier, and a real-time running status. The driver routing module 202 in this application is mainly used to respond to standard control commands, obtain the protocol type identifier of the target heterogeneous device from the device context object according to the standard control commands, and dynamically determine the target device driver instance corresponding to the target heterogeneous device from multiple registered device driver instances based on the protocol type identifier. Each device driver instance includes a downlink converter and an uplink parser for protocol conversion. Protocol conversion module 203, in this application, is mainly used to convert the standard control command into a protocol using the downlink converter in the target device driver instance, generate a control message in a device-specific protocol format and send it to the target heterogeneous device, receive the uplink status message reported by the target heterogeneous device, decode the uplink status message into a standard format status object using the uplink parser, and update the real-time running status in the corresponding device context object; The collaborative scheduling module 204 in this application is mainly used to make cross-protocol collaborative scheduling decisions for each heterogeneous device based on the real-time running status in the updated device context objects.
[0046] In addition, this application also provides a computer device, the computer device including a memory and a processor, the memory storing code, the processor being configured to acquire the code and execute the above-described multi-protocol cooperative scheduling and control method for heterogeneous devices.
[0047] In some embodiments, reference Figure 4 The figure is a schematic diagram of the structure of a computer device implementing a multi-protocol cooperative scheduling and control method for heterogeneous devices, according to some embodiments of this application. The multi-protocol cooperative scheduling and control method for heterogeneous devices in the above embodiments can... Figure 4 The computer device shown is used to implement this, and the computer device includes at least one processor 301, a communication bus 302, a memory 303, and at least one communication interface 304.
[0048] The processor 301 can be a general-purpose central processing unit (CPU), an application-specific integrated circuit (ASIC), or one or more devices used to control the execution of the multi-protocol cooperative scheduling control method for heterogeneous devices in this application.
[0049] The communication bus 302 can be used to transmit information between the aforementioned components.
[0050] The memory 303 may be a read-only memory (ROM) or other type of static storage device capable of storing static information and instructions, random access memory (RAM) or other type of dynamic storage device capable of storing information and instructions, or electrically erasable programmable read-only memory (EEPROM), compact disc read-only memory (CD-ROM) or other optical disc storage, optical disc storage (including compressed optical discs, laser discs, optical discs, digital universal optical discs, Blu-ray discs, etc.), magnetic disks or other magnetic storage devices, or any other medium capable of carrying or storing desired program code in the form of instructions or data structures and accessible by a computer, but not limited thereto. The memory 303 may exist independently and be connected to the processor 301 via the communication bus 302. The memory 303 may also be integrated with the processor 301.
[0051] The memory 303 stores program code for executing the scheme of this application, and its execution is controlled by the processor 301. The processor 301 executes the program code stored in the memory 303. The program code may include one or more software modules. In the above embodiments, the determination of the multi-protocol cooperative scheduling control method for heterogeneous devices can be implemented by the processor 301 and one or more software modules in the program code in the memory 303.
[0052] Communication interface 304 uses any transceiver-like device for communicating with other devices or communication networks, such as Ethernet, radio access network (RAN), wireless local area networks (WLAN), etc.
[0053] In a specific implementation, as one example, a computer device may include multiple processors, each of which may be a single-core (single-CPU) processor or a multi-core (multi-CPU) processor. Here, a processor may refer to one or more devices, circuits, and / or processing cores used to process data (e.g., computer program instructions).
[0054] The aforementioned computer device can be a general-purpose computer device or a special-purpose computer device. In specific implementations, the computer device can be a desktop computer, a portable computer, a network server, a handheld digital assistant (PDA), a mobile phone, a tablet computer, a wireless terminal device, a communication device, or an embedded device. This application does not limit the type of computer device.
[0055] In addition, this application also provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the above-described multi-protocol cooperative scheduling and control method for heterogeneous devices.
[0056] Although preferred embodiments of this application have been described, those skilled in the art, once they have learned the basic inventive concept, can make other changes and modifications to these embodiments.
[0057] Obviously, those skilled in the art can make various modifications and variations to this application without departing from the spirit and scope of this application.
Claims
1. A multi-protocol collaborative scheduling and control method for heterogeneous devices, characterized in that, Includes the following steps: For each accessed heterogeneous device, a corresponding device context object is constructed. The device context object includes at least a device identifier, a protocol type identifier, and a real-time running status. The device context object also includes a device communication address, device capability information, and a task execution sequence. The device communication address is used to identify the network communication endpoint of the corresponding heterogeneous device. The device capability information is used to describe the action types and load parameters supported by the corresponding heterogeneous device. The task execution sequence is used to record the atomic tasks currently to be executed and assigned to the heterogeneous device. In response to a standard control command, the protocol type identifier of the target heterogeneous device is obtained from the device context object according to the standard control command, and the target device driver instance corresponding to the target heterogeneous device is dynamically determined from multiple registered device driver instances based on the protocol type identifier, wherein each device driver instance includes a downlink converter and an uplink parser for protocol conversion; The standard control command is converted into a protocol by the downlink converter in the target device driver instance, generating a control message in a device-specific protocol format and sending it to the target heterogeneous device. The uplink status message reported by the target heterogeneous device is received, and the uplink parser decodes the uplink status message into a standard format status object and updates the real-time running status in the corresponding device context object. The system reads the real-time running status from the updated device context objects and constructs a global device status view. This global device status view is a spatiotemporal snapshot data structure that represents the real-time location distribution, movement trends, and task execution progress of all online heterogeneous devices in the shared physical space at the current moment. Based on the global device status view, path conflict detection is performed to determine whether multiple heterogeneous devices are about to have a path conflict in the shared area. When a path conflict is detected, conflict resolution paths are planned for each heterogeneous device involved in the conflict, and cross-protocol collaborative scheduling instructions are generated. The cross-protocol collaborative scheduling instructions are decomposed into standard control commands for each target device and executed through the corresponding device driver instance.
2. The method as described in claim 1, characterized in that, Specifically, the standard control commands are converted into protocol using the downlink converter in the target device driver instance to generate control messages in a device-specific protocol format and sent to the target heterogeneous device. The downlink converter reads the device communication address from the target device context object and uses the device communication address as the target address of the control message; The message instruction code is determined based on the command type of the standard control command. According to the message encapsulation rules corresponding to the protocol type identifier, the message instruction code and the device communication address are encapsulated into a control message in the device-specific protocol format, and sent to the target heterogeneous device through the corresponding communication link.
3. The method as described in claim 1, characterized in that, Decoding the uplink status message into a standard format status object via the uplink parser specifically includes: The protocol type identifier of the target heterogeneous device is obtained through the uplink parser, and the device status field is extracted from the uplink status message according to the message parsing rules corresponding to the protocol type identifier. The device status fields are mapped to unified status attributes to generate the standard format status object; wherein, the unified status attributes include device location coordinates, current battery level, operating speed, task execution status, and fault code.
4. The method as described in claim 1, characterized in that, Also includes: When each device driver instance is registered, it declares the corresponding protocol type identifier through the service provider interface configuration file. The configuration file records the correspondence between the protocol type identifier and the location of the driver class file.
5. The method as described in claim 1, characterized in that, Dynamically determining the target device driver instance corresponding to the target heterogeneous device from multiple registered device driver instances based on the protocol type identifier specifically includes: Determine from among the registered device driver instances whether a device driver instance matching the protocol type identifier already exists; If it does not exist, the corresponding device driver class is instantiated through reflection, a new device driver instance is created and stored in the instance cache table; Use an existing or newly created device driver instance as the target device driver instance.
6. A multi-protocol collaborative scheduling and control system for heterogeneous devices, used to execute the multi-protocol collaborative scheduling and control method for heterogeneous devices as described in any one of claims 1 to 5, characterized in that, The system includes: The context management module is used to construct corresponding device context objects for accessed heterogeneous devices. The device context object includes at least a device identifier, a protocol type identifier, and a real-time running status. The driver routing module is used to respond to standard control commands, obtain the protocol type identifier of the target heterogeneous device from the device context object according to the standard control commands, and dynamically determine the target device driver instance corresponding to the target heterogeneous device from multiple registered device driver instances based on the protocol type identifier. Each device driver instance includes a downlink converter and an uplink parser for protocol conversion. The protocol conversion module is used to convert the standard control command into a protocol using the downlink converter in the target device driver instance, generate a control message in a device-specific protocol format and send it to the target heterogeneous device, receive the uplink status message reported by the target heterogeneous device, decode the uplink status message into a standard format status object using the uplink parser, and update the real-time running status in the corresponding device context object. The collaborative scheduling module is used to make cross-protocol collaborative scheduling decisions for heterogeneous devices based on the real-time running status in the updated device context objects.
7. A computer device, characterized in that, The computer device includes a memory and a processor, the memory storing code, and the processor being configured to retrieve the code and execute the multi-protocol cooperative scheduling and control method for heterogeneous devices as described in any one of claims 1 to 5.
8. A computer-readable storage medium storing a computer program, characterized in that, When the computer program is executed by the processor, it implements the multi-protocol cooperative scheduling and control method for heterogeneous devices as described in any one of claims 1 to 5.
Citation Information
Patent Citations
Connection method of single system and AGV, adapter, control method and device
CN116112576A
Internet of Things equipment access system based on model context protocol
CN122348899A
