5-DOF Letter Writing
Robotic Arm
A challenging project from my Robotics course. Small 2-4 person teams were tasked with building a functional robotic arm capable of writing on a vertical whiteboard any 5 letter combination using the letters A thru J. No translational movements could be used, only rotational motion was allowed.
​
We were given six servo motors to use, two MX-64A motors and four AX-12 motors. We chose to use one of our AX-12s with our gripper mechanism leaving us with 5 degrees of rotational freedom.
​
My friend Drew Wendeborn was largely responsible for the mechanical design, the 3D printing of the linkages, and the programming of the Arduino servo controller board (OpenCM).
​
I developed the end-effector path planning algorithms, the forward and inverse kinematic schemes for the robot, and the numerical side of the robotic control (Matlab). Drew and I worked together to interface the two systems via serial communication, sending packets of robotic instruction data to the robot, and sending location data from the robot, back into Matlab.
Reachable Space
One considerable design constraint came from the reachable space. Our whiteboard was a specific distance from our robot, and we wanted to be able to write on the entire whiteboard with the end effector (our pen) in the same orientation. One of our methods for reducing error and creating legible script was to keep the pen as close to orthogonal to the whiteboard as possible.
Forward Kinematics &
Transformation Matrices
Because Drew had designed our linkages in CAD, figuring out the transformation matrices for our robot was not difficult. In order to find the position of the end effector I had to take into account the position (X,Y and Z) of each motor and it's standard rotational direction.
​
With this transformation matrix, forward kinematics tells me where will my end effector be given a specific set of servo positions. For this type of robot the forward kinematics always has a simply determined solution, this is what I used to check my end effectors current position.
Path Generation and Letter Discretization
I had to create a 2D path for each letter that could be used in our mystery word our robot would have to write. We stuck with capitals to minimize curves, thinking our robot would be better suited to straight lines. I generated cartesian points in a web-based app in which you can click a path over an image. Because each letter was a different size, I normalized the height and width of each set of points. Then I created additional points linearly distributed between my original points in order to facilitate smooth end effector movement. I wanted the tip of the pen to take very small steps in between instructions.
​
When a user typed in a specific word to be written, the program would compile all the individual letter paths and generate a master path of desired end effector positions.
Inverse Kinematics
Inverse kinematics was used to solve for servo rotational angles given a desired end-effector position. These equations can often lead to multiple solutions. To pick a solution, the position with the angles closest to the last defined position was used. Since there was no obstacle avoidance necessary, in all but a few cases this was adequate and robotic arm operation was smooth and predictable.
Grabber Design
The tip of the robot had a servo actuated grabber that Drew designed. One difficulty we came across was that the pen would chatter across the whiteboard instead of consistently pressing throughout the entirety of it's motion. To make the pen tip more flexible, a spring was added under the base of the pen within the holder. This allowed the pen to apply more constant pressure against the board.
Workable Space Defined andÂ
Real-time Adjustments
Defining the writing plane was one of the first steps in allowing our system to write. In order to do this, the robot end-effector was guided via keypad input to three corners of the whiteboard. Each position was stored, and a 3D plane was established. The 2D letter path was then projected onto this plane, and thus created the desired end-effector path in 3D space.
​
During testing we noticed was that as the robot wrote, occasionally it would experience a drifting of the end effector. Sometimes the pen tip would lift off the board and other times the pen would move the board. Since the pathfinding software was written in Matlab, I coded adjustment interrupts into the program so that a user could adjust the pen pressure on the fly, moving the end effector in or out by a specific. distance. This greatly improved the legibility of our writing.
​