Robot Arm

3D printed 6-Axis Robot Arm

Summer 2022-present

Summer break after my first year of college I was looking for project ideas, and I was also motivated by a lot of YouTube videos from others attempting 3D printed robotics projects. I was specifically interested in a robot arm because of the amount of mechanical design that would have to take place, which I really enjoy, and also the fact that it would be a great learning experience. In the end this choice resulted in a commitment to a long-term project which was at times very frustrating, but overall extremely rewarding.

I will attempt to show the iterative process on this page beginning with the mechanical design.

Objectives

-1m reach

-1 kg payload

-3D printed

-Rigid enough to lift payload with minimal flex

-Minimal backlash

First Prototypes

Began the process with the wrist, figured it would be complex but small enough to prototype quickly
Started in CAD with the goal of creating a belt driven differential wrist

Wrist + forearm assembly
This was the first assembly I prototyped for this project

Upper arm design challenges

Above are a series of views of progressive iterations of the elbow and 4th axis
Drawings go by CAD versions, numbers that are not represented were similar enough that they should not have had a seperate version

Above are build images from the elbow design process
Other subassemblies were being made in parallel with this one but the elbow was the most problematic
The elbow suffered from bad belt tension, belt skipping, low torque, and fragile parts throughout many of the earlier iterations

Elbow recap:

Elbow joint posed the most challenges during development.
Seven iterations of the elbow were designed, with four being fully implemented
- - Final design included:
  - Sturdier belts
  - Machined hubs
  - Larger axles
  - Precise gearboxes
  - Motor pulleys supported on both sides
Other joints had issues with backlash or lack of belt tension as well, not just the elbow
The 4th axis above the elbow was revised multiple times
Initially planned to use a differential (similar to the wrist) with two motors (elbow + 4th axis)
High backlash from 3D printed wrist gears led to reconsidering this approach for the elbow
A belt-based differential design was briefly considered, but an additional motor was added instead
Two smaller Nema 17 motors were used for the elbow instead of a single Nema 23 stepper

IMG_3318.mov

early version elbow testing

Cross section of the current upper arm of the robot.

Final design for 4th axis drive with off the shelf hub to eliminate plastic hub shearing problems.

Motor and gearbox installed with 3D printed interface for the lower arm and wrist to attach. Top section with outer bearing not pictured.

Base Challenges

Another area of concern for me on the robot was the base joint, since it has to support a lot of force from the offset weight of the arm.
My solution for this was a number of larger thrust and ball bearings, but in the end a custom thrust bearing assembly was required to support the base out to the edge and eliminate significant flexing.

Base before roller assembly

large sections of the base were reprinted to accommodate this new piece, but thankfully the problematic flex was eliminated.

A wire frame view of the bearing carrier that was seated in a new version of the base joint.

Design Progression

Very early render

Middle stages

Current design

Summary of changes from the early render:

Over the course of the project I made a lot of small changes, but I tried to avoid completely redesigning parts in the hopes that I could finish eventually and save major changes for a version two. Some highlights of the changes from the first assembly to now include:

base: new base belt tensioner
shoulder: larger HTD belts, new tensioners, new motor mounts, larger mounting bolts
elbow: new motor mounts, HTD belts, aluminum hubs, new output pulleys, larger bearings, new gearboxes
axis 4: new gearbox, aluminum hub, new bearing assembly
wrist: wrist pulleys and gears, new tensioners, higher torque reduction, new side panels, stronger main body

The mechanical portion of the project is just one aspect however, so I will show some additional photos from along the way and then move on to the electronics.

Electronics

Electronics Summary:

The electronics are centered around an Arduino Mega 2560
Arduino interfaces with switches and sensors and drives the motors
It runs 8 stepper drivers, which control motor current.
Powered by a 1000w 24v power supply
Current version includes:
- Additional power distribution for a gripper.
- A locking switch for turning the robot on, besides the emergency stop
The robot has sensors for homing but no joint encoders
Relies on stepper motors' accuracy for positioning
Encoders are planned for the next robotics project
Open-loop control is possible as long as motors do not skip steps

Robot electronics assembly

Controlled by an Arduino Mega 2560 which communicates with a python script.

One of the limit switches used on the arm for homing.

Hall effect sensor used on the arm. Magnets are embedded into the joints with 360 degrees of rotation.

First Full Tests

Below are links to videos of some of the first successful tests of the robot.

The first video was a sort of repeatability test, but since effectively only one joint is moving it is not a very realistic test. The second video shows a test of the elbow and shoulder, which had been the most problematic at this point.

Software

Arduino runs code for homing the robot and sending pulses to motor drivers.
Initial software plan was as follows:
- - Interface the Arduino with a Python program over serial to receive low-level instructions (e.g., joint positions).
  - Human controller will create programs using a custom programming application on a computer.
  - The application will translate the programs into joint positions and send them to the Arduino.

Above is a demonstration of a simulator/controller program which I wrote in python. Using the Pyrender library and mesh files straight from Fusion360, this program was written as a starting point for controlling and programming this robot. There are definitely more robust solutions that already exist to do this, but I thought it might be interesting to try to create one myself as a programming exercise.
The above video is the result of a lot of work to derive the necessary equations and implement all of the posing of robot geometry in a custom program. This visualizer has grown since this video, but has been an extremely useful tool to verify the real robot will behave as intended and avoid damage.

troubleshooting robot movement was a lot easier with a visualizer
the wrist was supposed to orbit around a single point here

Updated Software:

Added file browser
Added support for reading text file programs and scrolling through positions before sending to the robot
Added support for the robot to execute consecutive moves to positions
Added gripper support as a 7th element of a position (6axes + gripper open/closed)
Eliminated the need for the joystick in controlling the robot

updated look

Added a startup screen to choose a file to run

Future Plans

In general I have done almost all of what I set out to do at the start of this very long project, but there are are a lot of directions in which I can extend the scope further including:

Path planning and interpolation
Validating performance, creating a test plan
Testing on a real-life application