Master-slave multi-mcu control module synchronous upgrading method and system

Abstract

The application provides a master-slave multi-MCU control module synchronous upgrading method and system, wherein the method comprises the following steps: setting a master MCU and multiple slave MCUs, wherein the master MCU is used for monitoring and controlling firmware upgrading of the slave MCUs, and the multiple slave MCUs are used for controlling motors; providing an external shared storage area used for storing firmware of the master MCU and the slave MCUs; the master MCU checks firmware of the slave MCUs sent by a host through a first group of paths and saves the firmware into the shared storage area; and the master MCU activates corresponding slave MCUs in sequence through a second group of paths, so that the slave MCUs read the firmware in the shared storage area by themselves, update their own firmware, and complete synchronous upgrading of the multiple MCUs. Through the design of the shared storage upgrading scheme, the application not only improves the efficiency and safety of the firmware upgrading, but also ensures firmware version consistency among the multiple MCUs, thereby improving the stability of the whole system.

Description

Technical Field

[0001] This invention relates to the field of multi-MCU synchronous upgrade technology for robot dexterous hands, specifically to a method and system for synchronous upgrade of multi-MCU control modules with one master and multiple slaves, and also to a corresponding five-finger dexterous hand. Background Technology

[0002] In existing technologies, firmware upgrades for multi-MCU systems typically employ a self-upgrade process, with each MCU independently downloading and updating its firmware. This usually comes with the following drawbacks: Complexity: Each MCU requires an independent firmware upgrade mechanism, which increases the complexity of system design and maintenance.

[0003] Low efficiency: When multiple firmware downloads and writes are performed from the MCU, there may be time redundancy, resulting in low overall efficiency.

[0004] Security issues: During the upgrade process, firmware data transmission may be interfered with, resulting in incomplete or incorrect firmware writing, which affects the stability and reliability of the system.

[0005] Version inconsistency: Due to different firmware upgrade times for different MCUs, firmware version inconsistencies may occur, affecting the overall system performance. Summary of the Invention

[0006] To address the aforementioned shortcomings in the prior art, this invention provides a method and system for synchronously upgrading multiple MCU control modules with one master and multiple slaves, and also provides a corresponding five-finger dexterity hand.

[0007] According to one aspect of the present invention, a method for synchronously upgrading multiple MCU control modules with one master and multiple slaves is provided, comprising: A master MCU and multiple slave MCUs are configured, wherein the master MCU is used for firmware upgrade monitoring and control of the slave MCUs, and the multiple slave MCUs are used for motor control; Provide an external shared storage area for storing the firmware of the master MCU and slave MCU; The main MCU verifies the firmware sent from the slave MCU by the host and saves it to the shared storage area; The master MCU activates the corresponding slave MCUs sequentially through the first set of paths, so that the slave MCUs can read the firmware in the shared storage area through the second set of paths, update their own firmware, and complete the synchronous upgrade of multiple MCUs.

[0008] Preferably, the master MCU verifies the firmware of the slave MCU sent by the host, including: The host sends an upgrade signal and transmits the entire firmware information file, including version information, firmware file verification information, firmware size, and upgrade target. The firmware information file is sent to the main MCU using a sliding window protocol. After receiving a fixed-size frame, the main MCU retrieves the data and caches it in RAM. When it receives a specified size of data, it writes it to the shared memory area together. Each received frame carries a first checksum. The host triggers a transmission end signal and enters verification mode. In this mode, the firmware information file is verified, the second checksum of the firmware is calculated, and it is determined whether the firmware information file is corrupted. At the same time, the second checksum is written to the shared storage area.

[0009] Preferably, the master MCU activates the corresponding slave MCU, including: The master MCU is connected to all the slave MCUs through the first set of SPI paths; The master MCU notifies the slave MCU that needs to be upgraded to enter the upgrade state through the corresponding SPI path, and selects the current slave MCU to start reading the shared memory area through the chip select signal; The master MCU continuously reads whether the current slave MCU has completed the upgrade, and after the upgrade is completed, it notifies the next slave MCU to perform the upgrade through the corresponding SPI path.

[0010] Preferably, the step of reading the firmware from the shared storage area from the MCU includes: After receiving the upgrade signal, the MCU reads the firmware from the shared storage area through the second SPI path and writes the firmware into its respective backup area for verification. Each MCU flashes the firmware from the backup area to the application area to perform the final firmware upgrade.

[0011] According to another aspect of the present invention, a synchronous upgrade system for multiple MCU control modules with one master and multiple slaves is provided, comprising: The MCU configuration module is used to configure one master MCU and multiple slave MCUs. The master MCU is responsible for monitoring and controlling the firmware upgrades of the slave MCUs, and the multiple slave MCUs are responsible for controlling the motor. Shared storage module: This module provides an external shared storage area responsible for storing the firmware of the master MCU and slave MCU; Firmware acquisition module, which is used by the main MCU to verify the firmware of the slave MCU sent by the host and save it to the shared storage area; The firmware flashing module is used by the master MCU to sequentially activate the corresponding slave MCUs through the first set of paths, so that the slave MCUs can read the firmware in the shared storage area through the second set of paths, update their own firmware, and complete the synchronous upgrade of multiple MCUs.

[0012] According to a third aspect of the present invention, a five-finger dexterous hand is provided, wherein the five joint controllers of the five-finger dexterous hand are synchronously upgraded using the method described in any one of the above-mentioned invention.

[0013] By adopting the above technical solution, the present invention has at least one of the following beneficial effects compared with the prior art: The present invention provides a method and system for synchronous upgrade of multiple MCU control modules with one master and multiple slaves. By designing an upgrade scheme with shared storage, it not only improves the efficiency and security of firmware upgrades, but also ensures the consistency of firmware versions and synchronous upgrades among multiple MCUs, thereby improving the stability of the entire system.

[0014] The present invention provides a method and system for synchronously upgrading multiple MCU control modules with one master and multiple slaves. Through centralized management, it reduces the time spent on repeated downloads by multiple MCUs and improves the overall efficiency of firmware upgrades.

[0015] The present invention provides a method and system for synchronously upgrading multiple MCU control modules with one master and multiple slaves. Through data verification and backup mechanisms, it ensures the integrity and stability of the firmware during the upgrade process and reduces the impact of upgrade failure on the device.

[0016] The present invention provides a method and system for synchronous upgrade of multiple MCU control modules with one master and multiple slaves. The master MCU controls the upgrade process of all slave MCUs, ensuring that all devices are upgraded to the same version at the same time and maintaining the version consistency of the system.

[0017] The present invention provides a method and system for synchronously upgrading multiple MCU control modules with one master and multiple slaves, which reduces the complexity of designing the upgrade process for each MCU individually and lowers the cost of system development and maintenance.

[0018] The present invention provides a method and system for synchronous upgrading of multiple MCU control modules with one master and multiple slaves. In the application of the five-finger dexterity hand, which is a master-slave control scenario, it can realize the synchronous upgrading of five joint controllers and eliminate the problem of motion incoordination caused by firmware version differences. Attached Figure Description

[0019] Other features, objects, and advantages of the present invention will become more apparent from the following detailed description of non-limiting embodiments with reference to the accompanying drawings: Figure 1This is a flowchart illustrating the workflow of a preferred embodiment of the present invention for a synchronous upgrade method of multiple MCU control modules with one master and multiple slaves.

[0020] Figure 2 This is a schematic diagram of the components of a multi-MCU control module synchronous upgrade system with one master and multiple slaves, according to a preferred embodiment of the present invention.

[0021] Figure 3 This is a working architecture diagram of a method and system for synchronously upgrading multiple MCU control modules with one master and multiple slaves, based on a specific application example of the present invention.

[0022] Figure 4 This is a schematic diagram illustrating the synchronous upgrade process of a multi-MCU control module with one master and multiple slaves in a specific application example of the present invention. Detailed Implementation

[0023] The embodiments of the present invention are described in detail below: These embodiments are implemented based on the technical solution of the present invention, and provide detailed implementation methods and specific operation processes. It should be noted that those skilled in the art can make several modifications and improvements without departing from the concept of the present invention, and these all fall within the protection scope of the present invention.

[0024] In existing technologies, multi-MCU firmware upgrades typically suffer from problems such as complex processes, poor security, low efficiency, and difficulty in ensuring version consistency.

[0025] To address the aforementioned issues, one embodiment of the present invention provides a method for synchronously upgrading multiple MCU control modules with one master and multiple slaves. This method, by designing an upgrade scheme with shared storage, not only improves the efficiency and security of firmware upgrades but also ensures firmware version consistency and synchronous upgrades among multiple MCUs, thereby enhancing the stability of the entire system.

[0026] Specifically, such as Figure 1 As shown, the synchronous upgrade method for multiple MCU control modules with one master and multiple slaves provided in this embodiment may include: S1, set up one master MCU and multiple slave MCUs, wherein the master MCU is used to monitor and control the slave MCUs for firmware upgrades, and the multiple slave MCUs are used to control the motor; S2 provides an external shared memory area for storing the firmware of the master MCU and the slave MCU; S3, the main MCU verifies the firmware sent from the slave MCU by the host and saves it to the shared storage area; S4, the master MCU activates the corresponding slave MCUs in sequence through the first set of paths, so that the slave MCUs can read the firmware in the shared storage area through the second set of paths, update their own firmware, and complete the synchronous upgrade of multiple MCUs.

[0027] The synchronous upgrade method provided in the above embodiments of the present invention involves the main MCU receiving firmware data sent by the host, performing an integrity verification operation, and confirming that the data is correct before proceeding through the corresponding SPI path (e.g., ...). Figure 3 The blue path between the main MCU and the FLASH shown in the diagram writes it to the shared memory area. Subsequently, the main MCU writes it to the shared memory area via the first set of SPI paths (such as...). Figure 3 The red path shown in the diagram sends activation commands to each slave MCU in a predetermined order, triggering the slave MCU to enter firmware update mode. The activated slave MCU then sends activation commands through the second set of SPI paths (such as...). Figure 3 The blue path (shown between the FLASH and the MCU) accesses the shared memory area to obtain the firmware file and performs a self-programming operation to overwrite the original program. During this process, the main MCU continuously monitors the upgrade status of each node. If an anomaly is detected, the process is interrupted and an error recovery mechanism is triggered.

[0028] Compared to existing technologies, traditional solutions require separate firmware transmission channels and storage space for each slave MCU, while this invention reduces hardware resource consumption by uniformly storing firmware in a shared storage area. In existing technologies, the shared communication link for firmware transmission and upgrade control can lead to data conflicts, while this invention uses physically isolated SPI paths to handle data transmission and node activation separately, avoiding signal interference. Existing technologies rely on each node independently initiating upgrade requests, while this invention achieves synchronous upgrade control across multiple MCUs through centralized scheduling by the master MCU.

[0029] Through the above technical solutions, the present invention can reduce the complexity of upgrading multi-MCU systems, simplify the control logic with the master-slave architecture, improve upgrade efficiency, avoid duplicate data transmission with the shared storage area, enhance security, prevent the writing of erroneous firmware with the verification mechanism, and ensure version consistency, as all slave MCUs obtain firmware from the same storage location.

[0030] In some preferred embodiments, in the above-mentioned S1, the main MCU adopts the GD32H7 series; the slave MCU adopts the GD32G4 series.

[0031] Furthermore, the GD32H7 series refers to microcontroller units with high clock speeds and multi-core architectures, specifically the GD32H757VIT6 model. It incorporates a double-precision floating-point unit and a hardware encryption module to improve firmware verification speed and data security. The GD32G4 series refers to microcontroller units with integrated motor control peripherals, specifically the GD32G450VKT6 model. It incorporates a high-resolution PWM module and a multi-channel ADC to maintain the stability of motor drive signals during firmware upgrades.

[0032] In some preferred embodiments, in the above-mentioned S2, the shared storage area adopts FLASH W25Q128.

[0033] Furthermore, FLASH W25Q128 refers to a serial flash memory chip with a storage capacity of 128M-bit. Specifically, it can use a four-wire SPI interface to achieve high-speed data transmission, and its industrial-grade erase / write cycle life can reach 100,000 times, with an operating temperature range covering -40℃ to 85℃. This chip, through its hardware-implemented four-wire communication mode, supports data integrity protection mechanisms during concurrent access by master and slave devices.

[0034] In some preferred embodiments, the above-mentioned S3 and / or S4, the master MCU and the host and / or the master MCU and the slave MCU adopt the Ethercat or USB protocol.

[0035] In steps S3 and / or S4, the communication link between the master MCU and the host is configured using the Ethercat or USB protocol. The communication link between the master MCU and the slave MCU can also use the aforementioned protocol. For example, in industrial control scenarios, the master MCU sends a firmware activation command to the slave MCU via the Ethercat protocol, while the slave MCU confirms the firmware reading progress through the protocol's built-in status feedback function, ensuring strict synchronization of the operation timing.

[0036] To address the issues of fragmented computing power and inconsistent verification standards in traditional multi-MCU systems where each slave MCU must independently perform firmware verification, in some preferred embodiments, the aforementioned S3, where the master MCU verifies the firmware of the slave MCUs sent by the host, may further include a combination of single-frame verification and whole-packet verification: S31, the host sends an upgrade signal and transmits the entire firmware information file, including version information, firmware file verification information, firmware size and upgrade target; S32 uses a sliding window protocol to send firmware information files to the main MCU. After receiving a fixed-size frame, the main MCU retrieves the data and buffers it in RAM. When it receives a sufficiently large (e.g., 4096 bytes or 8192 bytes) of data, it writes it to the shared memory area together to improve the write speed. Each received frame carries a first checksum (CRC16 can be used) to verify the correctness of each frame of data, ensuring the correctness of each frame. The sliding window protocol ensures integrity. S33, the host triggers the transmission end signal and enters the verification mode. In this mode, the firmware information file is verified, and the second check code of the firmware (CRC32 can be used) is calculated. Based on the firmware verification information and the correctness of the calculated check code, it is determined whether the firmware information file is corrupted, and the second check code is written to the shared storage area.

[0037] Step S3 executes a high-strength verification algorithm centrally through the main MCU, completing a unified security screening before the firmware is written to the storage medium, thus avoiding any anomalies and security issues that might be missed by decentralized verification.

[0038] In some preferred embodiments, in S4 above, the master MCU activates the corresponding slave MCU, and the master MCU uses... Figure 3 The method of using the red SPI path to notify the MCU of the upgrade and continuously monitor its upgrade status through this SPI path can further include: S41, the master MCU connects to all slave MCUs through the first set of SPI paths, which is the means for communication between the master MCU and the slave MCUs; S42, the master MCU notifies the slave MCU that needs to be upgraded to enter the upgrade state through the corresponding SPI path, and selects the current slave MCU to start reading the shared memory area through the chip select signal; S43, the master MCU continuously reads whether the current slave MCU has completed the upgrade, and after the upgrade is completed, it notifies the next slave MCU to perform the upgrade through the corresponding SPI path.

[0039] In some preferred embodiments, S4 above involves reading the firmware from the shared storage area from the MCU, using a method that reads the firmware from the MCU via... Figure 3 The method of reading and verifying firmware from the shared memory area via the blue SPI path can further include: S44: After receiving the upgrade signal, the MCU reads the firmware from the shared memory area through the second SPI path, writes the firmware into its respective backup area, and performs a checksum verification. In this step, the checksum verification method can refer to the method for verifying the second checksum in S33, which will not be repeated here. S45, each MCU flashes the firmware from the backup area to the application area to perform the final firmware upgrade.

[0040] Based on the same inventive concept, one embodiment of the present invention also provides a synchronous upgrade system for multiple MCU control modules with one master and multiple slaves.

[0041] Specifically, such as Figure 2 As shown, the synchronous upgrade system for multiple MCU control modules with one master and multiple slaves provided in this embodiment may include: The MCU configuration module is used to configure one master MCU and multiple slave MCUs. The master MCU is responsible for firmware upgrade monitoring and control of the slave MCUs, while the multiple slave MCUs are responsible for motor control. Shared storage module: This module provides an external shared storage area responsible for storing the firmware of the master MCU and slave MCU; Firmware acquisition module: This module is used by the main MCU to verify the firmware sent by the host to the slave MCU and save it to the shared storage area. The firmware flashing module is used by the master MCU to activate the corresponding slave MCUs sequentially through the first set of paths, so that the slave MCUs can read the firmware in the shared storage area through the second set of paths, update their own firmware, and complete the synchronous upgrade of multiple MCUs.

[0042] It should be noted that the steps in the method provided by the present invention can be implemented using corresponding modules, devices, units, etc. in the system. Those skilled in the art can refer to the technical solution of the method to realize the composition of the system. That is, the embodiments in the method can be understood as preferred examples for building the system, and will not be elaborated here.

[0043] Based on the method and system for synchronous upgrade of multiple MCU control modules with one master and multiple slaves provided in the above embodiments of the present invention, the present invention also provides a specific application example. In this specific application example, a dexterous five-finger hand is used as the multi-MCU object with one master and multiple slaves. The working architecture of the method and system for synchronous upgrade of multiple MCU control modules involved is as follows: Figure 3 As shown, it mainly includes the following three parts: I. Shared storage design: This part uses an external FLASH W25Q128 as a shared storage area to store the firmware of the master MCU and the slave MCU.

[0044] 2. The main MCU obtains the host firmware cache path. In this part, the main MCU is responsible for verifying and saving the new firmware sent by the host to the FLASH W25Q128 through an SPI from the firmware cache of the MCU.

[0045] III. The synchronous flashing path section where the main MCU activates the slave MCU to read the firmware and update itself is as follows: In this section, the main MCU activates the slave MCU to read the firmware in the FLASH W25Q128 via another SPI and updates the slave MCU's own APP.

[0046] Furthermore, in this specific application example, the shared storage area uses an external FLASH W25Q128, the master MCU uses the GD32H7 series, and the slave MCU uses the GD32G4 series. The master MCU is mainly used for communication and for synchronously updating, monitoring, and controlling the slave MCU, while the slave MCU is used to control the motor.

[0047] The synchronous upgrade process is as follows: Figure 4As shown, the process includes firmware downloading, storage, activation, and flashing. The host only needs to perform a firmware write operation with the main MCU once to update all slave MCUs, greatly simplifying the process, improving stability, and reducing the error rate of multiple writes.

[0048] Verification of the above specific application examples shows that, to improve writing speed, communication with the master MCU can use faster EtherCAT and USB protocols. For the slave MCU firmware, this process only takes 1-2 seconds, after which the slave MCUs can be manually flashed. The speed is improved from 10 seconds per slave to all slave MCUs being upgraded within 10 seconds. This specific application example, through the design of a shared storage mechanism and the coordination control logic between the master and slave MCUs, implements a unique method for synchronous firmware upgrades of multiple MCUs via an external shared storage area. This enables synchronous upgrades of five joint controllers, eliminating motion incoordination issues caused by firmware version differences and ensuring efficient and safe multi-MCU firmware upgrades for five-finger dexterity hands.

[0049] An embodiment of the present invention also provides a multi-MCU synchronous upgrade control device, including a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, it can be used to execute any of the methods in the above embodiments of the present invention, or to run any of the systems in the above embodiments of the present invention.

[0050] Optionally, the memory is used to store programs; the memory may include volatile memory, such as random-access memory (RAM), such as static random-access memory (SRAM), double data rate synchronous dynamic random-access memory (DDR SDRAM), etc.; the memory may also include non-volatile memory, such as flash memory. The memory is used to store computer programs (such as application programs and functional modules that implement the above methods), computer instructions, etc., and the aforementioned computer programs and computer instructions can be partitioned and stored in one or more memories. Furthermore, the aforementioned computer programs, computer instructions, data, etc., can be accessed by the processor.

[0051] A processor is used to execute computer programs stored in memory to implement the various steps of the methods or various modules of the systems involved in the above embodiments. For details, please refer to the relevant descriptions in the preceding method and system embodiments.

[0052] The processor and memory can be separate structures or integrated structures. When the processor and memory are separate structures, they can be coupled together via a bus.

[0053] An embodiment of the present invention also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, can be used to perform any of the methods in the above embodiments of the present invention, or to run any of the systems in the above embodiments of the present invention.

[0054] Computer-readable media include computer storage media and communication media, wherein communication media include any medium that facilitates the transfer of computer programs from one place to another. Storage media can be any available medium accessible to a general-purpose or special-purpose computer. An exemplary storage medium is coupled to a processor, enabling the processor to read information from and write information to the storage medium. Of course, the storage medium can also be a component of the processor. The processor and storage medium can reside in an ASIC. Alternatively, the ASIC can reside in a user device. Of course, the processor and storage medium can also exist as discrete components in a communication device.

[0055] The method and system for synchronous upgrade of multiple MCU control modules (one master and multiple slaves) provided in the above embodiments of the present invention adopts a shared storage mechanism, using external flash memory as a shared storage area to achieve centralized management of firmware. This avoids each MCU downloading firmware independently, reduces the number of data transmissions, and improves efficiency and security. A master MCU control strategy is adopted, where the master MCU acts as the manager of the entire upgrade process, responsible for receiving, verifying, and storing new firmware, as well as controlling the upgrade process of the slave MCUs. This centralized control method ensures the consistency and synchronization of the upgrade process. A slave MCU autonomous update strategy is adopted, where, under the control of the master MCU, the slave MCUs read firmware from the shared storage area and update themselves. This method ensures the synchronization of the upgrade and utilizes the parallel processing capabilities of each MCU, improving overall efficiency. A verification mechanism is also employed, where the master MCU verifies the firmware during reception and storage to ensure its integrity and correctness, improving the security of the upgrade process. Through the above technical solutions, the present invention solves the problems of complexity, low efficiency, security, and version inconsistency in the prior art, simplifies the update method, significantly improves upgrade efficiency, and ensures the consistency of firmware versions across all MCUs.

[0056] Any matters not covered in the above embodiments of the present invention are well-known in the art.

[0057] The specific embodiments of the present invention have been described above. It should be understood that the present invention is not limited to the specific embodiments described above, and those skilled in the art can make various modifications or variations within the scope of the claims, which do not affect the essence of the present invention.

Claims

1. A method for synchronously upgrading multiple MCU control modules with one master and multiple slaves, characterized in that, include: A master MCU and multiple slave MCUs are configured, wherein the master MCU is used for firmware upgrade monitoring and control of the slave MCUs, and the multiple slave MCUs are used for motor control; Provide an external shared storage area for storing the firmware of the master MCU and slave MCU; The main MCU verifies the firmware sent from the slave MCU by the host and saves it to the shared storage area; The master MCU activates the corresponding slave MCUs sequentially through the first set of paths, so that the slave MCUs can read the firmware in the shared storage area through the second set of paths, update their own firmware, and complete the synchronous upgrade of multiple MCUs.

2. The method for synchronous upgrade of multiple MCU control modules with one master and multiple slaves according to claim 1, characterized in that, The main MCU adopts the GD32H7 series, and the slave MCU adopts the GD32G4 series.

3. The method for synchronous upgrade of multiple MCU control modules with one master and multiple slaves according to claim 1, characterized in that, The shared storage area uses FLASH W25Q128.

4. The method for synchronous upgrade of multiple MCU control modules with one master and multiple slaves according to claim 1, characterized in that, The master MCU and the host computer, and / or the master MCU and the slave MCU, use the Ethercat or USB protocol.

5. The method for synchronous upgrade of multiple MCU control modules with one master and multiple slaves according to claim 1, characterized in that, The main MCU verifies the firmware of the slave MCU sent by the host, including: The host sends an upgrade signal and transmits the entire firmware information file, including version information, firmware file verification information, firmware size, and upgrade target. The firmware information file is sent to the main MCU using a sliding window protocol. After receiving a fixed-size frame, the main MCU retrieves the data and buffers it in RAM. When it receives a specified size of data, it writes it to the shared memory area together. Each received frame carries a first checksum. The host triggers a transmission end signal and enters verification mode. In this mode, the firmware information file is verified, the second checksum of the firmware is calculated, and it is determined whether the firmware information file is corrupted. At the same time, the second checksum is written to the shared storage area.

6. The method for synchronous upgrade of multiple MCU control modules with one master and multiple slaves according to claim 1, characterized in that, The master MCU activates the corresponding slave MCU, including: The master MCU is connected to all the slave MCUs through the first set of SPI paths; The master MCU notifies the slave MCU that needs to be upgraded to enter the upgrade state through the corresponding SPI path, and selects the current slave MCU to start reading the shared memory area through the chip select signal; The master MCU continuously reads whether the current slave MCU has completed the upgrade, and after the upgrade is completed, it notifies the next slave MCU to perform the upgrade through the corresponding SPI path.

7. The method for synchronous upgrade of multiple MCU control modules with one master and multiple slaves according to claim 1, characterized in that, The step of reading the firmware from the shared storage area from the MCU includes: After receiving the upgrade signal, the MCU reads the firmware from the shared storage area through the second SPI path, writes the firmware into its respective backup area, and performs a checksum verification. Each MCU flashes the firmware from the backup area to the application area to perform the final firmware upgrade.

8. A synchronous upgrade system for multiple MCU control modules with one master and multiple slaves, characterized in that, include: The MCU configuration module is used to configure one master MCU and multiple slave MCUs. The master MCU is responsible for monitoring and controlling the firmware upgrades of the slave MCUs, and the multiple slave MCUs are responsible for controlling the motor. Shared storage module: This module provides an external shared storage area responsible for storing the firmware of the master MCU and slave MCU; Firmware acquisition module, which is used by the main MCU to verify the firmware of the slave MCU sent by the host and save it to the shared storage area; The firmware flashing module is used by the master MCU to sequentially activate the corresponding slave MCUs through the first set of paths, so that the slave MCUs can read the firmware in the shared storage area through the second set of paths, update their own firmware, and complete the synchronous upgrade of multiple MCUs.

9. A five-fingered dexterous hand, characterized in that, The five joint controllers of a five-finger dexterity hand are synchronously upgraded using the method described in any one of claims 1-7.

Images