17-4 Implementation
Figure 1: Video - First Complete Mobile Test of Linkage Larry with Transmitter
Section I: Mechanical Drive System
The final design evolved from an initial single-linkage model into a synchronized multi-leg system. Power is delivered by a DC motor integrated with a machined 200:1 worm gear drive. This is coupled to a 2:1 gear train, resulting in a cumulative reduction ratio of 400:1. This high-reduction setup provides the significant torque necessary to drive the complex linkages under load. To have smooth locomotion and mitigate "bumpiness" (gait fluctuations), the legs are arranged with specific phase offsets rather than moving in unison. For example: Adjacent lateral legs are offset by 180°. Corner linkages (front to back) are offset by 90°. This staggered timing creates a more organic, fluid gait that maintains constant ground contact and distributes the load more evenly across the motor's rotation.
Figure 2: Initial Design to Iteration REV02 of “Linkage Larry”
Section II: Structural Analysis (FEA)
To validate the assembly, we conducted a coarse mesh Finite Element Analysis (FEA) on a single 8-bar Jansen linkage. The model utilized the mechanical properties of standard laminate plywood. Forces were applied based on the peak loads identified during kinematic analysis, using a conservative safety factor of 1.5x total body weight to account for dynamic impact. The FEA identified the crank as the primary failure point. This is due to its relatively small moment arm and the fact that it acts as the primary conduit for all torque entering the linkage system, leading to high stress concentrations at the drive interface, however even with conservative estimates, no linkage failed under load.
Figure 3: Coarse Mesh FEA, 1.5X total body weight (2kg) for conservative estimate.
Section III: Fabrication and Assembly
Materials and Hardware The mechanism was fabricated using a hybrid manufacturing approach:
Primary Linkages: Laser-cut from 6mm plywood.
Mounting Fixtures: Custom 3D-printed components.
Hardware: 3mm stainless steel pan-head bolts with matching locknuts.
To minimize parasitic power loss through friction, stainless steel washers were placed at every interface between the plywood linkages. These washers reduce the contact surface area and provide a smoother bearing surface than wood-on-wood contact. Additionally, plastic spacers were utilized to prevent mechanical interference between the three layers of linkages as they pass through their respective paths of motion.
Precision Assembly and Poka-yoke
The assembly process followed a strict modular workflow. Each leg required a specific hardware kit (8 linkages, 12 washers, and varying lengths of 20mm, 25mm, and 30mm bolts).
A critical challenge was the center ternary linkage; because its triangular dimensions are nearly equilateral, it is easy to misorient during assembly. To prevent this, we implemented a Poka-yoke (error-proofing) feature by adding a small, asymmetric indicator hole in the CAD model. This ensured the linkage could only be installed in the correct orientation, guaranteeing the intended kinematic gait.
During the final tightening, locknuts were torqued until the joints were rigid, then gradually backed off. This "sweet spot" allowed for free rotation while eliminating undesired lateral play (axial slop) that would otherwise compromise the mechanism's stability.
Once the individual leg sub-assemblies were functional, they were mounted onto a central connecting rod. This rod was bolted into a 3D-printed gear that had been undersized and manually tapped to provide secure, threaded attachment points. The completed side assemblies were then secured to the main chassis via four primary mounting points, providing a rigid housing for the electronics and the custom motor mounts.
Figure 4: Miscellaneous Images of Development
Section IV: Electronics and Software
Our Electronic Components are as follows:
Arduino Uno R3
Handles the drive logic
Arduino Shield
Motor Controller
3S 11.1V Lipo battery
Worm Gear Motor
Chosen for its 200:1 Gear Reduction ratio
Flysky Fs-i6x Drone Controller + Receiver
Enables RC Capabilities
The wiring is a BEC (Battery Elimination Circuit). The idea of a BEC is to power the entire circuit using only one battery, eliminating separate power source needed for the receiver. The Arduino Shield connects directly on top of the Arduino Uno R3, allowing for compact wiring and easy integration. The motors are connected to the Arduino Shield via screw connectors (blue) to read out the motor signals from the Arduino Uno
One consideration for the wiring was to be careful not to send too much current into the Uno R3 (Rated for ~2A). This is due to the motors drawing a lot of current at once when under heavy loads, proper wiring helped prevent this.
The Code is like the project 2 car. With the Uno R3 reading from A2 and A3 (analog). However instead of being read directly from a wired button, the signals are now received by the Flysky receiver, enabling wireless capabilities.
Whenever an analog signal is detected from the receiver the it is interpreted by pulsein(). Since the motors prefer power outputs from (-255, 255) and the signals received are around 1000-2000 map() is used to perform a linear mapping within the power output range, constrain() is used to make sure any larger/smaller signals stay within the bounds.
Once the output is mapped mixing is applied where y is the forward/backward input, and x is the turning input. These values used to determine the speed of the left and right motor. This code uses differential drive, where turning is done in place. (If one of the motors has the reverse mapping, since they’re brushed the wires can be swapped to quickly reverse the direction).
To ensure the robot is controllable brake logic is included in drive(). Whenever the speed of the motor is detected to be zero the brake pin is applied to prevent any further motion when the joystick is placed in the “dead” zone”. This ensures that any momentum in the robot doesn’t cause unwanted motion when stopping.
// TWO-MOTOR CONTROL - Arduino Motor Shield Rev3
// VRX -> A2 | VRY -> A3
//
// Channel A Pins (Right Motor)
const int dirA = 12;
const int brakeA = 9;
const int pwmA = 3;
// Channel B Pins (Left Motor)
const int dirB = 13;
const int brakeB = 8;
const int pwmB = 11;
//yellow x, green y,
void setup() {
// Initialize all motor pins
pinMode(dirA, OUTPUT); pinMode(brakeA, OUTPUT); pinMode(pwmA, OUTPUT);
pinMode(dirB, OUTPUT); pinMode(brakeB, OUTPUT); pinMode(pwmB, OUTPUT);
Serial.begin(9600);
Serial.println("Dual Motor Control Ready");
}
void loop() {
// 1. Read Joystick Pins
int xRaw = pulseIn(A2, HIGH);
int yRaw = pulseIn(A3, HIGH);
// 2. Convert to Steering Logic
// Center is ~512. We apply a deadzone of 50.
int x = 0;
int y = 0;
if (abs(xRaw - 1500) > 30) x = map(xRaw, 1000, 2000, -255, 255);
if (abs(yRaw - 1500) > 30) y = map(yRaw, 1000, 2000, -255, 255);
// 3. Mix Y (Forward/Back) and X (Left/Right) for two motors
int leftSpeed = y + x;
int rightSpeed = (y - x);
leftSpeed = constrain(leftSpeed, -255, 255);
rightSpeed = constrain(rightSpeed, -255, 255);
// 4. Send commands to both motors
drive(dirA, brakeA, pwmA, rightSpeed);
drive(dirB, brakeB, pwmB, leftSpeed);
// 5. Output data to Serial Monitor
Serial.print("L Motor: "); Serial.print(leftSpeed);
Serial.print(" | R Motor: "); Serial.println(rightSpeed);
delay(30);
}
// Function to handle the specific shield logic for one motor
void drive(int dPin, int bPin, int pPin, int spd) {
// Constrain speed to the allowable PWM range
int finalSpeed = constrain(abs(spd), 0, 255);
// We keep the Brake pin LOW at all times to disable the hard brake
digitalWrite(bPin, LOW);
if (spd == 0) {
digitalWrite(bPin, HIGH); // Engage Brake
analogWrite(pPin, 0);
} else {
digitalWrite(bPin, LOW); // Disengage Brake
digitalWrite(dPin, (spd > 0) ? HIGH : LOW); // Set Direction
analogWrite(pPin, finalSpeed);
}
}
Section V: Final CAD Designs and Renders: