4.4 - Implementation
The implementation phase turned the linkage design into a single-finger exoskeleton prototype. The prototype was built to show finger-curling motion and test whether the compact multi-link design could work as a wearable device.
Table of Contents:
Final Design
Fabrication and Assembly
Electronics, Actuation, and Control
Final Prototype
Code Explanation
1. Final Design
The final design is a wearable single-finger exoskeleton made from connected four-bar linkages. The mechanism has three sections for the MCP, PIP, and DIP joints. The MCP and PIP sections are powered, while the DIP section moves passively with the fingertip.
The goal was to make a compact mechanism that could help the finger curl in a natural way. The MCP and PIP linkages create the main bending motion. The DIP linkage guides the fingertip without needing another motor.
The final CAD model includes the base, linkage arms, pivot joints, finger pads, straps, and hardware attachment points. The base supports the mechanism and the actuation system. The stacked linkage design helps the finger bend in a curved path instead of moving like a simple hinge.
2. Fabrication and Assembly
After the linkage design was finished in CAD and checked, the first prototype was built to test the motion. Most of the main parts were 3D printed using _________. This made it easy to make the links, base pieces, and finger pads. It also made it easy to change the design between versions.
The mechanism was put together with small screws, pins, and bearings at the pivot points. M2 screws and steel pins were used for the main joints. Bearings were added to help reduce friction and make the motion smoother.
Several versions were tested before the final design. Early versions had spacing problems near the pivot points. Later versions moved better and matched the curved motion of a finger more closely. Testing also showed that some links still hit each other, so future versions need better spacing, stronger links, and better joint alignment.
Finger straps and contact pads were added to attach the mechanism to the user’s finger. These parts helped move the finger while keeping the device wearable. The prototype showed that the actuator could move the mechanism without the structure failing. This showed that the basic idea worked.
3. Electronics, Actuation, and Control
The actuation system controlled the MCP and PIP linkages using two motors. The prototype used two TT DC gearbox motors because they were small, low-cost, and accessible. Each motor helped move one main linkage section.
The DIP linkage was passive and did not use its own motor. This made the design simpler and lighter. The DIP section followed the motion from the MCP and PIP linkages to help create the finger-curling motion.
An Arduino board was used to control the motors. A 9V battery powered the system. The wiring was kept simple and placed away from the moving parts so the mechanism could move freely.
The main materials included two TT DC gearbox motors, an Arduino board, wires, a 9V battery, a bike cable kit, bearings, M2/M3 fasteners, 3D-printed parts, and finger straps. The bike cable kit transferred motion from the motors to the linkages, but it also caused tension problems that made the motion less consistent.
4. Final Prototype
 Figure 1: Final single-finger exoskeleton prototype showing the 3D-printed linkage mechanism, finger straps, cable actuation system, and motor housing used to test finger flexion.
|
|---|
Figure 2: Single-finger exoskeleton prototype during finger flexion. The MCP, PIP, and DIP linkage sections engage with the finger to guide the curling motion produced by the cable-driven actuation system. |
Figure 3. Single-finger exoskeleton prototype in the extended position. The MCP, PIP, and DIP linkage sections are aligned with the user’s finger before actuation, showing the resting position of the mechanism. |
5. Code explanation
The Arduino code controlled two DC motors using a motor driver. Each motor had one pin for speed and two pins for direction. This allowed the motors to move forward, move backward, stop, and change speed.
The motors were controlled through the Serial Monitor. The user typed simple commands to control the system. The command u increased the motor speed, d decreased the speed, s stopped both motors, f moved the motors forward, and r reversed the motors.
The motor speed was controlled using PWM values from 0 to 255. The speed changed by 5 each time, so the team could slowly increase the power instead of starting the motors at full speed. This made testing safer and easier to control.
When the program started, both motors were set to move forward, but the speed was set to 0. This meant the motors were ready to move, but they would not start until the user increased the speed.
This code was useful because the team could test the motors while watching how the linkage moved. Slowly increasing the speed helped show how much power was needed to move the mechanism. It also helped the team notice problems like friction, binding, or links hitting each other.
Overall, the code was a simple control system for early prototype testing. It did not use sensors or feedback, but it was helpful for testing motor direction, motor speed, and basic linkage motion. Future versions could add sensors, limit switches, or force feedback to make the finger motion smoother and more repeatable.
int ENA = 9;
int IN1 = 8;
int IN2 = 7;
int ENB = 10;
int IN3 = 6;
int IN4 = 5;
int pwm = 0;
void setup() {
Serial.begin(9600);
pinMode(ENA, OUTPUT);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(ENB, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
// Forward direction for both motors
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
digitalWrite(IN3, HIGH);
digitalWrite(IN4, LOW);
analogWrite(ENA, pwm);
analogWrite(ENB, pwm);
Serial.println("Dual motor control ready.");
Serial.println("u = increase power");
Serial.println("d = decrease power");
Serial.println("s = stop");
Serial.println("r = reverse");
Serial.println("f = forward");
}
void loop() {
if (Serial.available() > 0) {
char key = Serial.read();
if (key == 'u') {
pwm += 5;
if (pwm > 255) pwm = 255;
Serial.print("PWM increased to: ");
Serial.println(pwm);
}
else if (key == 'd') {
pwm -= 5;
if (pwm < 0) pwm = 0;
Serial.print("PWM decreased to: ");
Serial.println(pwm);
}
else if (key == 's') {
pwm = 0;
Serial.println("Motors stopped.");
}
else if (key == 'f') {
digitalWrite(IN1, HIGH);
digitalWrite(IN2, LOW);
digitalWrite(IN3, HIGH);
digitalWrite(IN4, LOW);
Serial.println("Direction: forward");
}
else if (key == 'r') {
digitalWrite(IN1, LOW);
digitalWrite(IN2, HIGH);
digitalWrite(IN3, LOW);
digitalWrite(IN4, HIGH);
Serial.println("Direction: reverse");
}
analogWrite(ENA, pwm);
analogWrite(ENB, pwm);
}
} |
|---|