In my research, I explore a master-slave control method for dexterous robotic hands that combines data gloves and stepper motors. Dexterous robotic hands are designed to mimic human hand manipulations, holding significant promise for applications in hazardous environments such as deep-sea exploration, battlefield mine clearance, nuclear material handling, and aerospace equipment maintenance. However, due to limitations in artificial intelligence, automatic control, and sensor technologies, achieving fully autonomous operation of dexterous robotic hands in unstructured environments remains highly challenging. Therefore, I propose a human-in-the-loop approach where a human operator directly controls the dexterous robotic hand through a master-slave system, leveraging human intelligence to handle complex scenarios. The key metrics for evaluating such systems include motion accuracy, real-time performance, and stability.
My work focuses on developing a practical and efficient master-slave control framework. I utilize a CyberGloveII data glove to capture real-time human finger joint motion data, which is then mapped to the joints of a custom-built dexterous robotic hand, the YWZ hand. The motion commands are generated, transmitted via a serial communication protocol to an integrated circuit board (ICB), and executed by stepper motors that drive the joints of the dexterous robotic hand. This method enables open-loop control, avoiding the complexities of closed-loop systems while maintaining reasonable precision. Through experimental validation with hand gestures like “OK” and “V”, I demonstrate the feasibility, accuracy, real-time capability, and stability of this approach.
The motivation behind this research stems from the need for reliable teleoperation of dexterous robotic hands in high-risk settings. While fully autonomous dexterous robotic hands are an ultimate goal, current technology is insufficient for unpredictable environments. Master-slave control allows human operators to impart their dexterity and decision-making skills to the dexterous robotic hand, making it a viable interim solution. Existing methods for master-slave control often rely on exoskeleton devices or surface electromyography (sEMG) for motion capture, and actuators like DC motors, servo-pneumatics, or pneumatic artificial muscles. However, data gloves offer precise joint angle measurements with minimal calibration, and stepper motors provide accurate open-loop control without feedback sensors, reducing system complexity. My contribution lies in integrating these components into a cohesive system and evaluating its performance through rigorous experiments.
In this article, I detail the hardware and software architecture of my master-slave control system for dexterous robotic hands. I describe the mechanical design of the YWZ dexterous robotic hand, the selection and configuration of stepper motors, the design of the ICB, and the software pipeline for data acquisition, joint mapping, command generation, and communication. I present experimental results analyzing motion errors, real-time performance, and stability. Furthermore, I discuss the limitations of this approach, such as joint range mismatches and stepper motor resolution constraints, and suggest directions for future improvements. By emphasizing the term “dexterous robotic hand” throughout, I underscore the focus on advanced manipulators capable of human-like dexterity.
Hardware Architecture of the Master-Slave Control System
The hardware platform for my master-slave control of dexterous robotic hands consists of four main components: the CyberGloveII data glove, a personal computer (PC), an integrated circuit board (ICB), and the YWZ dexterous robotic hand. The CyberGloveII data glove is equipped with 22 sensors measuring joint angles with a precision of 0.5°, and it transmits data wirelessly via Bluetooth at a baud rate of 115,200 bits/s. The PC receives and processes the motion data, generates control commands, and sends them to the ICB through a USB serial interface. The ICB, based on an ATxmega128A1 microcontroller, decodes the commands and drives 20 stepper motors that actuate the joints of the YWZ dexterous robotic hand. This setup ensures a seamless flow from human motion to robotic hand movement.
The YWZ dexterous robotic hand is an anthropomorphic hand with five fingers and a palm. Each finger, except the thumb, has three joints: the metacarpophalangeal joint (MP), the proximal interphalangeal joint (PIP), and the distal interphalangeal joint (DIP). The thumb has a similar structure but is positioned oppositely to the other fingers and can move along a slot in the palm. Each joint is driven by a stepper motor via a pair of spiral bevel gears, providing independent control. The MP joint has two degrees of freedom (DOF): flexion/extension and abduction/adduction. The PIP and DIP joints each have one DOF for flexion/extension. Thus, the entire dexterous robotic hand has 20 DOFs, corresponding to 20 stepper motors. The mechanical design prioritizes compactness and functionality, enabling the dexterous robotic hand to perform various grasping and manipulation tasks.
The stepper motors are selected based on torque and speed requirements to ensure reliable operation without stalling. For the MP flexion joints, I use model 11HY301-2 stepper motors with a step angle of 1.8°, a rated voltage of 11.6 V, and a holding torque of 80 mN·m. For the MP abduction joints and PIP flexion joints, I use model 8HY201-10 stepper motors with a step angle of 1.8°, a rated voltage of 4.8 V, and a holding torque of 25 mN·m. For the DIP flexion joints, I use model 8HY001-2B stepper motors with a step angle of 1.8°, a rated voltage of 3.9 V, and a holding torque of 18 mN·m. All motors operate at a speed of 5 revolutions per second (r/s) to balance real-time performance and torque. The motors are controlled by A3977 driver chips on the ICB, which receive pulse signals from the microcontroller to control rotation direction and step count.
The ICB is custom-designed to manage the stepper motors for the dexterous robotic hand. It includes the ATxmega128A1 microcontroller, multiple A3977 driver chips, voltage regulators (LM2596), a USB interface, and peripheral components. The microcontroller receives motion commands from the PC, verifies their integrity using cyclic redundancy check (CRC), and distributes pulse signals to the driver chips. Each driver chip controls one or more stepper motors, depending on the configuration. The ICB ensures precise timing and coordination of motor movements, which is critical for the synchronized motion of the dexterous robotic hand. The use of stepper motors allows open-loop control, eliminating the need for encoders or feedback sensors, thus simplifying the system and reducing cost.
To summarize the hardware setup, Table 1 lists the stepper motor assignments for each joint of the dexterous robotic hand. This table clarifies the mapping between motors and joints, which is essential for understanding the control logic.
| Joint Description | Motor Number | Motor Model | Function |
|---|---|---|---|
| Thumb MP Flexion | 1 | 11HY301-2 | Flexion/Extension |
| Index MP Flexion | 2 | 11HY301-2 | Flexion/Extension |
| Middle MP Flexion | 3 | 11HY301-2 | Flexion/Extension |
| Ring MP Flexion | 4 | 11HY301-2 | Flexion/Extension |
| Little MP Flexion | 5 | 11HY301-2 | Flexion/Extension |
| Thumb MP Abduction | 6 | 8HY201-10 | Abduction/Adduction |
| Index MP Abduction | 7 | 8HY201-10 | Abduction/Adduction |
| Middle MP Abduction | 8 | 8HY201-10 | Abduction/Adduction |
| Ring MP Abduction | 9 | 8HY201-10 | Abduction/Adduction |
| Little MP Abduction | 10 | 8HY201-10 | Abduction/Adduction |
| Thumb PIP Flexion | 11 | 8HY201-10 | Flexion/Extension |
| Index PIP Flexion | 12 | 8HY201-10 | Flexion/Extension |
| Middle PIP Flexion | 13 | 8HY201-10 | Flexion/Extension |
| Ring PIP Flexion | 14 | 8HY201-10 | Flexion/Extension |
| Little PIP Flexion | 15 | 8HY201-10 | Flexion/Extension |
| Thumb DIP Flexion | 16 | 8HY001-2B | Flexion/Extension |
| Index DIP Flexion | 17 | 8HY001-2B | Flexion/Extension |
| Middle DIP Flexion | 18 | 8HY001-2B | Flexion/Extension |
| Ring DIP Flexion | 19 | 8HY001-2B | Flexion/Extension |
| Little DIP Flexion | 20 | 8HY001-2B | Flexion/Extension |
This hardware configuration forms the foundation for the master-slave control of the dexterous robotic hand. The integration of data gloves and stepper motors offers a balance of precision and simplicity, making it suitable for real-world applications where reliability and ease of use are paramount. In the following sections, I delve into the software aspects and experimental validation of this dexterous robotic hand system.
Software Pipeline and Control Methodology
The software for master-slave control of the dexterous robotic hand is developed on the VC++ 10.0 platform and embedded in the ICB microcontroller. The pipeline involves several steps: data acquisition from the data glove, joint mapping, calculation of stepper motor directions and pulse counts, generation of motion commands according to a communication protocol, serial communication between the PC and ICB, and execution of commands by the stepper motors. Each step is optimized for real-time performance and accuracy to ensure the dexterous robotic hand responds promptly to human gestures.
First, the CyberGloveII data glove captures 20 human finger joint angles (in radians) at a sampling rate of 100 ms. The data is transmitted via Bluetooth to the PC, where it is converted to degrees. The joint mapping follows a direct joint-to-joint approach, where each human finger joint is mapped to a corresponding joint on the dexterous robotic hand. For example, the human thumb MP flexion angle controls the thumb MP flexion motor of the dexterous robotic hand. This mapping is straightforward due to the anthropomorphic design of the dexterous robotic hand, but it requires calibration to account for differences in joint ranges. The mapping formula is simple: let $\theta_h$ be the human joint angle and $\theta_r$ be the robotic joint angle, then $\theta_r = k \cdot \theta_h$, where $k$ is a scaling factor determined by the ratio of joint ranges. In my implementation, $k$ is set to 1 for most joints, but for joints with limited range, it is adjusted to prevent over-rotation.
Next, the PC calculates the required rotation for each stepper motor. The stepper motors have a step angle of 1.8°, so the number of pulses $N$ needed to achieve a rotation of $\theta_r$ degrees is given by:
$$ N = \frac{\theta_r}{1.8} $$
Since $\theta_r$ may not be an integer multiple of 1.8°, the pulse count is rounded to the nearest integer, introducing a quantization error. The direction of rotation (clockwise or counterclockwise) is determined by the sign of $\theta_r$: positive for flexion or abduction, negative for extension or adduction. For the dexterous robotic hand, I define positive angles as joint closing motions. The calculated pulse counts and directions for all 20 motors are packed into a motion command according to a custom communication protocol.
The communication protocol uses hexadecimal format to ensure efficient data transmission. Each command consists of data for 20 motors plus a CRC checksum for error detection. For each motor, 8 bits (1 byte) are allocated: 2 bits for motor ID (00 to 19), 2 bits for direction (01 for forward, 02 for reverse), and 4 bits for pulse count (0 to 15 pulses per command cycle). Since 4 bits allow only 16 pulses, multiple command cycles may be needed for larger rotations; in practice, I send commands every 100 ms, so the pulse count per cycle is limited to keep the motion smooth. The full command string is represented as:
$$ \text{a1-8b1-8c1-8d1-8e1-8f1-8g1-8h1-8i1-8j1-8k1-8l1-8m1-8n1-8o1-8p1-8q1-8r1-8s1-8t1-8wxyz} $$
Here, a1-8 to t1-8 represent the 20 motors, and wxyz is the 16-bit CRC checksum. The CRC is computed using the standard CRC-16-CCITT algorithm to verify data integrity. The PC sends the command to the ICB via a serial port at a baud rate of 38,400 bits/s, which is derived from the microcontroller’s clock frequency using the formula:
$$ F_{\text{baud}} = \frac{F_{\text{system}}}{16 \times (\text{BSEL} + 1)} $$
where $F_{\text{system}} = 32 \text{ MHz}$ and BSEL is a register value set to achieve 38,400 baud. This baud rate ensures reliable transmission without overwhelming the microcontroller.
Upon receiving the command, the ICB microcontroller verifies the CRC. If correct, it parses the command and generates pulse signals for each stepper motor driver. The A3977 drivers convert these signals into motor winding currents, causing the stepper motors to rotate by the specified number of steps. The open-loop control relies on the stepper motors not missing steps, which is ensured by operating them within their torque-speed curve. The software also includes a safety feature to stop motion if invalid commands are detected, protecting the dexterous robotic hand from damage.
To illustrate the software flow, consider a simplified example for the thumb MP flexion joint. Suppose the data glove measures a human thumb MP flexion angle of 1.5 rad (approximately 85.99°). After mapping, the target angle for the dexterous robotic hand thumb MP flexion joint is 85.99° (assuming $k=1$). The required pulses are $N = 85.99 / 1.8 \approx 47.77$, rounded to 48 pulses. The direction is forward (01). Thus, for motor 1, the data bytes would be: ID=01, direction=01, pulse count=48 (in hexadecimal: 0x30). This is packed into the command string and transmitted. The entire process from data acquisition to motor movement takes approximately 90 ms, as analyzed in the real-time performance section.
The software is designed for flexibility, allowing adjustments to joint mapping ratios and command frequencies. This adaptability is crucial for optimizing the performance of the dexterous robotic hand in different tasks. In the next section, I present experimental results that validate this control methodology.
Experimental Validation and Performance Analysis
I conducted experiments to evaluate the master-slave control system for the dexterous robotic hand. The tests focused on motion accuracy, real-time performance, and stability using two common hand gestures: “OK” and “V”. These gestures involve multiple fingers and joints, providing a comprehensive assessment of the dexterous robotic hand’s capabilities. The human operator wore the data glove and performed the gestures slowly to ensure clear data capture. The dexterous robotic hand attempted to replicate the gestures, and I measured the resulting joint angles for comparison.
For the “OK” gesture, the thumb and index finger tips touch while other fingers remain stationary. The data glove captured the following joint angles in radians (only relevant joints shown):
$$ \begin{bmatrix} 1.5048 & 0.4347 & 0.4566 & 0.2309 \\ 1.0019 & 1.4736 & 0.7379 & 0.0283 \end{bmatrix} $$
These correspond to thumb MP flexion, thumb PIP flexion, thumb DIP flexion, thumb MP abduction, index MP flexion, index PIP flexion, index DIP flexion, and index MP abduction. After mapping and motor control, the dexterous robotic hand achieved the gesture shown earlier. I measured the actual joint angles of the dexterous robotic hand using a protractor and calculated the motion error $\eta$ as:
$$ \eta = \left| \frac{\theta_r – \theta_h}{\theta_h} \right| \times 100\% $$
where $\theta_h$ is the human joint angle and $\theta_r$ is the robotic joint angle. Table 2 summarizes the results for the “OK” gesture.
| Joint | Human Angle $\theta_h$ (°) | Robotic Angle $\theta_r$ (°) | Error $\eta$ (%) |
|---|---|---|---|
| Thumb MP Flexion | 85.99 | 40.2 | 53.2 |
| Index MP Flexion | 57.32 | 58.4 | 1.9 |
| Thumb MP Abduction | 13.18 | 12.5 | 5.2 |
| Index MP Abduction | 1.72 | 1.90 | 10.5 |
| Thumb PIP Flexion | 24.65 | 25.7 | 4.3 |
| Index PIP Flexion | 84.27 | 65.4 | 22.4 |
| Thumb DIP Flexion | 26.37 | 27.3 | 3.5 |
| Index DIP Flexion | 42.42 | 43.5 | 2.5 |
The errors for thumb MP flexion and index PIP flexion are high (53.2% and 22.4%) because the human joint ranges exceed the mechanical limits of the dexterous robotic hand joints. The thumb MP abduction error (10.5%) is due to the small angle (1.72°) and the step resolution of 1.8°, causing quantization error. Other errors are below 5%, indicating good accuracy for most joints. This demonstrates that the dexterous robotic hand can replicate human gestures with reasonable fidelity, though joint range mismatches are a limitation.
For the “V” gesture, the thumb, ring, and little finger tips touch while the index and middle fingers abduct. The data glove data for key joints in radians is:
$$ \begin{bmatrix} 1.5840 & 0.2480 & 0.4241 & 0.1606 \\ 0.5738 & 1.6092 & 0.1156 & 0.3539 \end{bmatrix} $$
Corresponding to thumb MP flexion, ring MP flexion, little MP flexion, thumb MP abduction, ring PIP flexion, little PIP flexion, ring DIP flexion, and little DIP flexion. Table 3 shows the motion accuracy results.
| Joint | Human Angle $\theta_h$ (°) | Robotic Angle $\theta_r$ (°) | Error $\eta$ (%) |
|---|---|---|---|
| Thumb MP Flexion | 90.57 | 40.3 | 55.5 |
| Ring MP Flexion | 32.68 | 33.8 | 3.4 |
| Little MP Flexion | 62.48 | 64.4 | 3.1 |
| Thumb MP Abduction | 9.17 | 9.9 | 8.0 |
| Ring PIP Flexion | 92.29 | 65.2 | 29.4 |
| Little PIP Flexion | 80.25 | 65.5 | 18.4 |
| Ring DIP Flexion | 6.88 | 7.5 | 9.0 |
| Little DIP Flexion | 17.20 | 18.3 | 6.4 |
Similar trends are observed: high errors for joints exceeding the dexterous robotic hand’s range (thumb MP flexion, ring PIP flexion, little PIP flexion) and moderate errors for small angles due to step resolution (thumb MP abduction, ring DIP flexion). The dexterous robotic hand performs well within its design constraints, but improvements are needed to match human joint ranges more closely.
Real-time performance is critical for master-slave control of dexterous robotic hands. I analyzed the time delay from data acquisition to motor execution. The total delay $T$ is the sum of four components: data acquisition time $t_1$, data calculation time $t_2$, data transmission time $t_3$, and motor execution time $t_4$. Assuming worst-case scenarios:
- $t_1$: The data glove sends 20 joint angles as 32-bit integers, totaling 640 bits. At 115,200 baud, $t_1 = 640 / 115,200 \approx 0.0056 \text{ s} = 5.6 \text{ ms}$.
- $t_2$: The PC calculations are simple, so $t_2 \approx 0 \text{ ms}$.
- $t_3$: Each command has 20 motors × 4 bytes + 2 bytes CRC = 82 bytes = 656 bits. At 38,400 baud, $t_3 = 656 / 38,400 \approx 0.0171 \text{ s} = 17.1 \text{ ms}$.
- $t_4$: The maximum joint rotation is 120°, and motors run at 5 r/s. The time for one full revolution (360°) is 0.2 s, so for 120°, $t_4 = (120/360) \times 0.2 = 0.0667 \text{ s} = 66.7 \text{ ms}$.
Thus, $T = 5.6 + 0 + 17.1 + 66.7 = 89.4 \text{ ms} \approx 90 \text{ ms}$. With a sampling interval of 100 ms, the system can process each command without backlog, ensuring real-time operation. The dexterous robotic hand responds smoothly to human motions, with negligible lag that does not impair teleoperation.
Stability is assessed by running the dexterous robotic hand continuously for 30 minutes while performing repetitive gestures. No motor stalling or command errors occurred, and the joint movements remained consistent. The ICB’s CRC verification prevented erroneous commands, and the stepper motors operated within their torque limits. The dexterous robotic hand showed no signs of overheating or mechanical wear during the test, indicating robust stability for extended use.
These experiments confirm that the data glove and stepper motor combination is viable for master-slave control of dexterous robotic hands. The system achieves acceptable accuracy for most joints, real-time response, and stable operation. However, the limitations highlight areas for future enhancement, such as expanding joint ranges and improving resolution. In the next section, I discuss these aspects in detail.
Discussion and Future Work
The master-slave control method for dexterous robotic hands using data gloves and stepper motors offers several advantages. First, data gloves provide precise, calibration-free motion capture compared to exoskeletons or sEMG, which often require user-specific tuning. Second, stepper motors enable accurate open-loop control without feedback sensors, simplifying the hardware and reducing costs. This combination makes the system accessible for applications where complexity and expense are concerns. The dexterous robotic hand benefits from human-like dexterity, allowing it to perform delicate tasks in teleoperation scenarios.
However, there are notable limitations. The joint range mismatch between human hands and the dexterous robotic hand leads to significant errors for large angles, as seen in the experiments. This can be mitigated by designing dexterous robotic hands with broader joint ranges or implementing software scaling that compresses human motion into the available range. Additionally, the step resolution of 1.8° causes quantization errors for small angles, affecting precision in fine manipulations. Using stepper motors with smaller step angles (e.g., 0.9° or microstepping) could improve accuracy, but may increase cost and control complexity.
Another issue is the potential for stepper motor stalling under high load or speed. While my experiments avoided this by operating within safe limits, real-world tasks may involve external forces. Incorporating torque sensors or current monitoring could detect stalls and trigger corrective actions, but this would move toward closed-loop control. Alternatively, using more powerful motors or gear reducers could enhance torque without compromising speed.
The communication protocol, while effective, has a limited pulse count per command (4 bits allow 0-15 pulses). For larger movements, multiple command cycles are needed, which may slow down response. Expanding to 8 bits per motor would allow up to 255 pulses per cycle, enabling faster motions, but would increase command size and transmission time. A balance must be struck based on application requirements.
For future work, I plan to explore adaptive joint mapping that dynamically adjusts scaling factors based on task constraints. Machine learning techniques could optimize mapping to minimize error across a variety of gestures. Additionally, integrating tactile feedback into the data glove would allow operators to feel forces exerted by the dexterous robotic hand, enhancing telepresence. This could involve force sensors on the dexterous robotic hand and vibrotactile actuators on the glove.
Another direction is to develop multi-modal control, combining data glove inputs with voice commands or eye tracking for auxiliary functions. This would make the dexterous robotic hand more versatile in complex environments. Furthermore, the system could be extended to bilateral control, where the dexterous robotic hand sends force feedback to the master side, enabling more immersive teleoperation.
In terms of hardware, future iterations of the dexterous robotic hand could incorporate underactuated mechanisms to reduce the number of motors while maintaining dexterity, or use soft robotics techniques for safer human-robot interaction. The integration of AI for autonomous sub-tasks, such as object recognition and grasp planning, could complement the master-slave control, creating a semi-autonomous dexterous robotic hand that switches between human and autonomous modes.
Overall, this research demonstrates a practical approach to master-slave control for dexterous robotic hands. By leveraging data gloves and stepper motors, I have built a system that is accurate, real-time, and stable enough for many teleoperation applications. The insights gained from this work will guide the development of more advanced dexterous robotic hands capable of seamless human-robot collaboration.
Conclusion
In this article, I presented a master-slave control method for dexterous robotic hands based on data gloves and stepper motors. The system uses a CyberGloveII data glove to capture human finger joint motions, maps them to the joints of a YWZ dexterous robotic hand, generates control commands via a custom communication protocol, and executes them through stepper motors driven by an integrated circuit board. Experimental results with “OK” and “V” gestures show that the dexterous robotic hand can replicate human motions with reasonable accuracy, real-time performance, and stability. The open-loop control simplifies the system while maintaining functionality.
The key contributions of this work are the integration of data gloves and stepper motors for dexterous robotic hand control, the design of a reliable hardware and software pipeline, and the empirical validation of the approach. The dexterous robotic hand demonstrates potential for teleoperation in hazardous environments, where human expertise is essential. Limitations such as joint range mismatches and step resolution are identified, pointing to avenues for future improvement.
As robotics technology advances, dexterous robotic hands will play an increasingly important role in expanding human capabilities. My research adds to the growing body of work on human-robot interaction, offering a cost-effective and practical solution for master-slave control. I hope that this work inspires further innovations in the design and control of dexterous robotic hands, ultimately leading to more capable and accessible robotic systems for society.