tangletron-3000 🤖

A 3D-printed robotic arm designed using Fusion 360, controlled by an ESP32 over Bluetooth, with more tangled wires than a conspiracy theorist’s wall.

Note: The demo GIF may take a few seconds to load. Please be patient

This was my attempt at designing, building, and controlling a basic robotic arm; while it is far from a polished product, it represents a completely functional 4-DOF robot – designed, built, and coded from scratch. Despite its wobbles, it helped me level up in CAD design, embedded systems, and debugging messy real-world hardware.

Features ✨

• 🦾 4-DOF Robotic Arm – Features 3 servo-driven joints and a gripper, offering basic articulation and grasping capabilities.
• 📱 Bluetooth App Control – Send commands in real time using the Dabble mobile app over Bluetooth.
• 🧩 Simple Modular Construction – Designed in Fusion 360 and printed in PLA for easy tweaks, repairs, and reassembly.

🛠️ Under the Hood

⚙️ Mechanical

• 3D-Printed Modular Design – All parts were modeled in Fusion 360 (preview the model here) and printed in PLA. Assembly uses only M3 machine screws and nuts: some holes are tight to grip the screw, while others are loose to allow rotation around an axis.
• Rotating Base Platform – A stationary base holds a rear servo that drives a rotating platform via a parallel linkage, allowing rotation around the Z-axis.
• Vertical Arm & Gripper – Two servos on the base control up/down and forward/backward movement through another parallel linkage. The gripper is actuated by a small servo using a rack-and-pinion mechanism.

🔌 Electronics

• Stable Power Supply – A 12V DC input is regulated down to 5V using an L7805 voltage regulator with smoothing capacitors, which powers both the ESP32 microcontroller and the PCA9685 servo driver.
• I2C Communication – The ESP32 communicates with the PCA9685 via I2C (good description here), sending control signals to manage the servos.
• Servo Control – The PCA9685 handles all four servos, providing both the necessary PWM signals and power to drive them reliably.

💻 Software

• Bluetooth Gamepad Control – The Dabble mobile app sends gamepad inputs to the ESP32 over Bluetooth, using the DabbleESP32.h library to handle communication and input parsing.
• Input Processing & Angle Mapping – The ESP32 reads gamepad inputs and converts them into target joint angles, using custom mapping functions to translate angles into servo pulse values.
• PWM Signal Generation – The ESP32 sends these mapped values over I2C to the PCA9685, using Wire.h and Adafruit_PWMServoDriver.h, which generates precise PWM signals to drive the servos accordingly.

Files Included 📁

• tangletron-3000.f3z: Original Fusion 360 file, complete with parametric design history.
• tangletron-3000.ino: The magic script for ESP32. Apologies for the whiff; debugging is an art, not always a deodorized one.

Limitations ⚠️

• 🍝 Wires The wiring is a complete mess, and gets in the way of the movement of the robot; at certain angles, it trips over itself, and in the process pulls out its own arteries.
• ⚖️ Instability – The robot is generally unstable, and the linkages have too much play, causing wobbling during movement.
• 🔒 Limited Range of Motion – The geometry of the linkages restricts the range of servo rotation, limiting their permissible angles.

Future Improvements 📈

Here are a couple of improvements that could be made to the current design:

• Tidy Up the Wiring – Replace loose wires with connectors or a custom PCB to keep everything neat and prevent wires from getting in the way.
• Increase Base Stability – Enlarge and weight the base platform to keep the robot steady during operation, especially when the arm is fully extended or moving quickly.
• Redesign Joints with Shoulder Bolts – Use shoulder bolts instead of regular screws to reduce wobble and make the joints more stable.
• Add Inverse Kinematics – Instead of manually controlling each joint, use math to automatically move the arm to a target position.
• Use Stepper Motors Instead of Servos – Replace servos with stepper motors and drivers to get more precise and consistent movement, especially for tasks that need accurate positioning.

If I were to redesign the whole thing, I would probably switch to a serial arm layout; instead of using parallel linkages, use a joint-after-joint setup where each motor drives a single joint directly. It would take me a long time to design housings for the servos / stepper motors / bearings, and it would also mean each joint has to carry more weight. But in the long term it gives better flexibility and works well with existing kinematics tools.