Dial-Actuating Robotic Arm
Overview
Inspired by traditional toggle-switch-based designs, I decided to create an overcomplicated version of the simple useless machine. Instead of a toggle switch, I created an entire 4-DOF servo-actuated robotic arm to keep a rotating dial in place.
This project combines CAD, 3D printing, circuit board design, microcontroller programming, motor control, sensor feedback, and inverse kinematics, making it one of the most exciting projects I have taken on.
CAD Design
This is an animation from Fusion 360 of the robot arm executing a knob twist. It was very reassuring at this stage to validate that my objective was kinematically feasible, but it was a long journey from here to actually bring the robot and this motion into the real world.
Fusion 360 Assembly Animation
Construction
The device is fully 3D printed. Care was taken to avoid support material and eliminate fasteners to keep assembly simple and post processing minimal. In place of standard fasteners, threaded features are integrated into the components and printed nuts fit seamlessly onto the links. ​​ ​​​
Fastener-Free Construction
Electronics
A custom circuit board routes traces from an RP2040 QTPY to 4 MG90s micro-servo motors and a KY-040 rotary encoder. The schematic was tested on a breadboard, designed in Autodesk Eagle, and manufactured by OSH park in Oregon.
​
The first microcontroller I used had only 256kb of flash memory. I quickly ran out of space and upgraded to the new RP2040 version with 8MB of flash. This new board also solved a problem I was having where the rotary encoder was skipping steps. With the RP2040, the encoder runs independently from other processes on PIO hardware and never misses a step.
What's Inside
Robot's First Steps! Inverse Kinematics Success!
Inverse Kinematics
I knew the robot was capable or carrying out the knob-turning motion I desired from the CAD animation, but until I figured out how to use inverse kinematics and solve for the joint angles needed to make the arm move in a circle, it was just moving around arbitrarily.
​
To accomplish this I learned how to use the MATLAB robotics toolbox, built a kinematic model of the robot, and generated two lists of angles. One list is of all the angles needed to move the arm in a circle just above the knob, and the other is all the angles needed to make the arm move in a circle with the knob within the grasp of the end-effector. These lists are loaded onto the QTPY as .txt files
Robot flailing around in a world without inverse kinematics.
"Annoyed State" Robot Follows Knob
Programming
The programming for this arm was done in collaboration with my cousin, Matt Auer, a Computer Science Engineering grad from the University of Michigan.
​
The decision to pre-process the angle lists was made to reduce the number of calculations being done on the microcontroller. The value of these angles never change, thus we do not need to re-calculate them every time we move the robot in a circle. I did, however, have to fine tune these values by adding or subtracting a few degrees from particular joints to compensate for slop.
​
The angles from the list are matched with position feedback from the rotary encoder to find the knob, latch onto it, and spin it back to home.
​
Currently we are working on implementing a state machine to give the robot a sense of irritation and change its behavior based on how much you mess with it. An example of an "annoyed state" is showcased in the video to the left.