Introduction: 3D Printed Robot Dog
In 2020 I became immersed in the marvelous world of quadrupedal robots. Viewing YouTube videos of robots such as SPOT by Boston Dynamics, and the MIT Mini Cheetah has inspired me to make my very own. These cleverly crafted bots are known for their dynamic movements and realistic appearances. Over the past year, I've made it my personal goal to create my very own affordable quadrupedal robot. One that could function similar to the high-end quadrupeds. Here I present ARES, a fully 3D printed 12 DOF robot dog capable of omni directional travel as well as many other maneuvers. In this instructable, I'll show you how to make your very own ARES!
Here is a list of the tools and supplies needed for the build. For a more detailed overview of the supplies needed, download the bill of material excel file here.
- needle nose plier
- wire stripper
- lighter or heat gun (for heat shrink tubing)
- Allen wrenches
- soldering iron and solder
- super glue
- exacto knife
- wire cutter
- hot glue gun and hot glue
- 12 x DS3218 20kg digital servo (Most standard size servos work as well. Make sure they are 180°)
- Teensy 4.1
- Radiolink T8S RC controller and reciever
- 12 pin Polulu Maestro servo controller
- 3.3 to 5v logic level converter
- half proto board
- mini proto board
- SPST switch
- 18 AWG wire
- heat shrink tubing
- XT60H connector pair
- 2S (7.4v) 6200mah lipo battery
Other supplies ($146)
- 2 x 1" velcro straps
- 4 x 25T servo horn (24mm hole center)
- 8 x 25T servo disc
- 4 x m3 x 100mm pushrod connector
- 8 x 22mm long m3 tie rod
- 73 x m3 x 6mm threaded inserts
- 16 x m3 locknuts
- M3 Screws
- 8 x m3 x 4mm
- 35 x m3 x 6mm screws
- 30 x m3 x 8mm screws
- 12 x m3 x 16mm screws
- 4 x m3 x 16mm button head screws
- 4 x m3 x 18mm button head screws
- 4 x m3 x 20mm screws
- 4 x m3 x 22mm screws
- 4 x m3 x 30mm screws
Total cost of used supplies (not including 3D printed parts) = $530
Step 1: 3D Print the Parts
My design process
I designed all parts of this robot in the CAD software Fusion 360. I started off by making a conceptual design (image #2) and then creating the actual design (image #3). This is not the first quadrupedal robot that I have designed. I came into this particular project with a lot of design constraints that made my previous attempts obsolete. Images #4 - #6 show some of these older designs. Go here and here to view some of these past quadrupeds in action. As you can see, ARES is a lot more robust and compact than my other designs. My main goal with ARES was to have it be 12 DOF, lightweight, and relatively cheap to reproduce. ARES is the most dynamic quadruped that I have designed. Unlike my previous designs, ARES has no bulk. All of the parts are thin but strong. Another great thing about ARES is that the parts require no sanding. I incorporated tolerances and offsets into each part to have them fit nicely. The servos should slide in snug. ARES also utilizes a clever leg design that makes a 3DOF leg extremely compact. I first saw this leg design here. All in all, I am extremely proud of the design for ARES. It is the culmination of about a year's worth of other design iterations.
3D printing the parts
The robot uses 34 3D printed parts. I printed all of these parts on my Creality CP-01 3D printer using ABS and PLA filament. I have assembled all of the STL files on my Thingiverse page here. Below I have also attached the STEP and Fusion 360 file of the robot if you want to view or edit the design. Using CAD software to view individual parts (as well as the robot as a whole) will be extremely helpful in deciphering the correct orientation of things and the positions of the threaded inserts. If you don't have CAD software no worries! Use the interactive model below for reference.
If you have a 3D printer I'd recommend doing the following:
- 25% infill for all parts
- Auto-generated supports on all parts
- PLA (210° extruder and 45° bed) is strongly recommended but ABS (250° extruder and 100° bed) also works
- Use flexible TPU filament (210° extruder and 45° bed) for the 4 feet. This will allow the robot to have better traction when walking on slick surfaces.
There are 34 printed parts weighing a combined 600g without supports. A single 1kg roll of filament can print this all!
If you do not have a 3D printer I would recommend getting these parts printed on a website that offers 3D printing services like Shapeways. I would also recommend printing the 4 feet in TPU filament.
Step 2: Assemble the Legs
Let's start off by assembling the 4 legs of the robot. Each leg is oriented differently so pay close attention to which 3D printed parts you use for each leg. For each leg do the following:
Image #1: Assemble the following material
- The 6 3D printed parts for each leg: link 1, link 2, link 3, link 4, foot, servo carriage
- 3 x servo
- 25T servo horn
- 2 x 25T servo disc
- 10 x m3 threaded inserts
- 100 mm m3 push rod connector
- 2 x 22mm long m3 tie rod
- m3 screws
- 2 x 4mm
- 8 x 6mm
- 3 x 16mm
- 1 x 16mm button head
- 1 x 18mm button head
- 1 x 20mm
- 1 x 22mm
- 1 x 30mm
Image #2: Using a heated soldering iron, push the 10 threaded inserts into the holes on link 3, link 4, and the servo carriage. Go here to watch how to install threaded inserts into 3D printed parts (this will be done throughout the build).
Image #3: Using 4 x m3 by 6mm screws, screw on a 25T servo disc to both the servo carriage and link 3.
Image #4: Screw on all 3 servos onto the servo carriage. 2 of the servos slide into the carriage while the other servo is screwed onto the 25T servo disc. Screw this servo onto the disc first. Also, cut off the little notches near the screw holes on this servo alone. This will allow the servo to slide into the main robot body.
- Screw link 4 onto link 3 using an m3 by 30mm screw and a lock nut.
- Screw the tie rods onto both ends of the push rod connector.
- Screw one end of link 1 onto the servo horn using an m3 by 18mm button head screw and a lock nut.
- Screw the other end of link 1 onto link 2 using an m3 by 16mm button head screw and a lock nut.
- Screw the other end of link 2 onto one of the tie rods using an m3 by 16mm screw and a lock nut.
- Screw the other tie rod onto the hinge on link 4.
- Screw the TPU foot onto link 4 using 2 x m3 by 16mm screws.
- Link 2 should now be able to rest on the servo disc on link 3 while also being able to rotate.
- Screw the servo disc on link 3 onto the top servo on the servo carriage using an m3 by 22mm screw.
- Screw the servo horn onto the bottom servo on the servo carriage.
- The leg should now be able to move freely.
Step 3: Electronics!
Now onto the heart of the project, the electronics! Creating the circuit correctly is vital to this project. Attached is a schematic showing how everything should be connected.
Electronic components needed:
- Teensy 4.1
- Radiolink T8S RC controller and reciever
- 12 pin Polulu Maestro servo controller
- 3.3 to 5v logic level converter
- half proto board
- mini proto board
- SPST switch
Inciteful info for creating a proper circuit.
- Use the above images of the labeled pins of each of the components.
- Overview of the circuit
- Teensy 4.1: This is the brain of the robot. All of the other electronic components are connected to the Teensy. Make sure to cut the VIN to USB trace on the back of the Teensy. This will ensure that the Teensy never gets powered by the computer when it is plugged into the computer. We don't need computer power since we are using a battery to power the Teensy and all the other components. More info on the Teensy 4.1 microcontroller can be found here.
- 12 pin Polulu Maestro: This is what controls the servos. The servos connect to the maestro and the maestro connects to the Teensy via the RX and TX pins (Teensy pins 1 and 0 respectively). The 2S battery connects directly to the maestro. The Teensy is also powered by the maestro since the maestro has a 5V output pin. Note that the maestro has a jumper that connects the servo voltage to the input voltage (labeled VSRV and VIN respectively). This jumper will be removed when the maestro is plugged in directly to the computer. Otherwise, it stays on. For more information on the 12 pin maestro go here.
- Logic Level Converter (LLC): since Teensy microcontrollers use a 3.3V logic level and the maestro uses a 5V logic level, the Pololu maestro's RX and TX pins cannot be connected to the teensy directly. Instead, they must connect to the LLC which then connects to the Teensy.
- RC Receiver: The receiver is what will read the commands sent by the remote. Each channel on the receiver has 3 pins: signal, VCC, and ground. Only one of the VCC and one of the ground pins should be connected to the Teensy 3.3V pin and ground pin respectively. Each of the signal pins must be connected to the Teensy. The pin assignment is specified on the schematic. Make sure to check that the remote connects to the receiver. You can do so by powering the whole circuit and binding the receiver to the remote. If done successfully the receiver should stop blinking. For more information on the RC receiver and RC remote and instructions on how to bind the receiver, take a look at the pdf below entitled T8S Manual.
- Solder the Teensy onto the half proto board and solder the LLC onto the mini protoboard. I used header pins to allow the electronics to be removable.
- I found it best to use servo extension cables to connect a bunch of the electronics. Allowing for plug-and-play action makes things easily removable which is important since things may not always work as expected.
- Image #2 shows the switch wiring used. The switch turns the robot on and off by completing the circuit on one lead of the battery. Use the XT60H female connector to connect to the switch. This way, the 2S lipo battery can be plugged and unplugged.
- All ground pins on all components are connected together.
Step 4: Assemble the Main Body
Now that we've assembled the legs, let's assemble the main body.
Image #1: Gather 25 threaded inserts, the bottom mid-plate, the bottom front plate, the bottom back plate, and the electronics plate. Using a heated soldering iron put inserts into all of the holes that need them.
Image #2: Using 16 x m3 by 8mm screws, screw the electronics plate onto the three other plates. The electronics plate connects all the other plates together.
Image #3: Assemble the top covering by gathering the top mid-plate, the top front plate, the top back plate, and the battery plate. Using a heated soldering iron push in 8 x m3 threaded inserts into holes on the top front and top back plates each.
Image #4: Using 4 x m3 by 8mm screws, connect the top mid-plate, the top back plate, and the top front plate using the battery holder. Here is also a good time to insert the switch into the top front plate.
Image #5: Mount the electronics onto the electronics plate. The half proto board and the mini proto board can be screwed onto the electronics plate using 4 x m3 by 6mm screws. The Polulu maestro and the RC receiver can be glued onto the electronics plate using hot glue.
Image #6: Slide each of the robot's legs into their corresponding slot.
Image #7: Using 8 x m3 by 8mm screws, screw on the servo covers on each side of the robot to hold the legs in place.
Image #8: Plug in all of the servos onto the maestro. Each servo goes into a specific channel on the maestro. This channel assignment is shown on image #9. The numbers on this image correspond to the channel number that each servo should be plugged into on the maestro.
Step 5: Calibrate Legs
Before we screw on the top cover, we need to ensure that the maestro has the right settings and that the legs are calibrated.
Downloading Maestro Control Center (Maestro User's Guide)
Let's start off by downloading the maestro control center software. This is the software used to control the servos and configure the maestro to use its UART serial communication ports (RX and TX) in order to allow the maestro to be controlled by the Teensy.
- Go here to download maestro control center for windows.
- Go here to download maestro control center for Linux.
Once you have downloaded maestro control center, plug in the maestro and learn how to use it. Detailed instructions on how to use maestro control center can be found here. Now copy the servo settings on image #1 and the serial communication settings on Image #2. The serial settings will allow the maestro to communicate with the Teensy. More information on the maestro's serial communication can be found here.
**NOTE** When plugging the maestro directly into a computer, make sure that voltage is only going into the servos and not to the maestro itself. To do this, remove the jumper cable connecting VSRV and VIN and have voltage only flow through VSRV.
Calibrating The Legs
The program created for the robot dog uses inverse kinematic equations to move each leg to a certain position. In order for these equations to work, the program must know the position of each servo. Since we put the servos in arbitrary places, the program has no way of knowing the servos' positions. To communicate this information to the program we must use the maestro control center to move each servo to a certain known position, record that position in microseconds, and later transfer those positions to the program. The video above will explain how to obtain those positions for all 12 servos. After calibrating the legs, Make sure to reattach the jumper connecting VSRV and VIN.
Step 6: Finishing Touches
Now that the robot has been calibrated, we can go ahead and cover it up using the top cover made in step 4. After that, use 2 x velcro straps to hold the battery. The battery plate should have two slits allowing the velcro straps to slide through. If your velcro straps are too long like mine, cut off the part that sticks and use super glue to glue it at a lower level.
Step 7: Upload the Program
It's time to upload the Arduino program. Doing so is simple.
- First you need to upload two Arduino libraries. The first library is Robot_Control and the second is RC_Receiever.
- Next download the main program and add the 12 positions obtained in step 5 to the program. The place to add these values is shown in image #1. You may also want to look at the instructions for uploading Arduino sketches to a Teensy board here.
Step 8: Using the Remote
The robot has 3 modes. Switch between modes by moving channel 5 (labeled on image #2) to its forward, neutral, or backward position.
Mode 1: Translate (channel 5 is in its neutral position)
- Move forward or backward: push the right analog stick forward or backward
- Move left or right: push the right analog stick left or right
- Rotate the robot clockwise or counterclockwise: push the left analog stick right or left
Mode 2: Trot (channel 5 is flipped forward)
- The robot continuously trots in place
Mode 3: Tilt (channel 5 is flipped backward)
- Tilt the robot forward or backward: push the right analog stick forward or backward
- Tilt the robot left or right: push the right analog stick left or right
- Move the robot back to its normal stance: push channel 6 (labeled on image #2)
**NOTE** While running the robot be mindful of how hot the servos get and the voltage of the LiPo battery. Overheating the servos or draining the battery can lead to permanent damage.
Step 9: Optional Touches
Here are 2 optional upgrades to enhance this build.
Change The Thumbsticks of the RC Remote
At first, I changed the thumbsticks because the ones that the remote came with were quite uncomfortable, however, I realized that the new thumbsticks also improved the visual aesthetic of the remote and added to the black and yellow theme. The stl file of the thumbstick can be found below. You will need to print two of them and use a heated soldering iron to place 2 threaded inserts into the back of them.
Change the Servos Entirely
If you really want to take this project to the next level (and have the budget) I would recommend using faster servos to get more dynamic movement. The servos used in this project are great, but they are some of the cheapest I could find. A great example of a faster servo is the JX CLS6336HV which is double the price of the servos used in this project, but is faster and rated to output a higher torque. A great example of a robot that uses these servos is the Stanford Pupper.
Step 10: How the Program Works
Inverse Kinematic Equations
This project uses inverse kinematic equations to move the legs to certain positions by calculating where to move each servo. I derived these equations using geometry and algebra. I also simulated these equations in Fusion 360. Using Fusions sketch tools, I design a mock leg that is constrained by the kinematic equations. Using Fusions parameter tool, the leg is able to move to an exact location based on the X, Y, and Z values entered. This Fusion file is available below. The kinematic equations are used in the program to move each leg. For example, when the robot moves forward each leg undergoes the same sequence:
- move up 40mm
- move forward 50mm
- move down 40mm
- move back 50mm
As you can see, the leg returns to the same position it starts at each time it steps. In order for the leg to move vertically up and horizontally right, the inverse kinematic equations must calculate where the servo must move to.
Robot Control Library
This library uses the inverse kinematic equations to calculate where each servo needs to move and then moves them to that position. I created this library by using the pre-existing library for Polulu maestro servo controllers. This library simply moves a servo to a certain position at a certain speed and acceleration. I modified this library by creating a command for 12 servos to move at once and also making the input value be the desired position of each foot rather than simply just a servos position. The library allows me to tell the robot to move its front left foot 30mm forward. The program then uses its kinematic formulas to find what position to move the 3 servos for that leg in order to move the leg 30mm forward.
RC Reciever Library
This library uses the RC receiver to read the RC remote. When a button is pressed on the remote, this library is used to understand what button was pressed. It also reads the analog values of the analog sticks. If an analog stick is pushed all the way up, the library returns a high value. if an analog stick is pushed halfway up, the library returns a lower value.
The main program uses the two aforementioned libraries to allow the robot to move. Most of this program consists of sequences of movements made by the legs in order to move the robot a certain way. These sequences can be somewhat long since each step that the robot makes is precisely calculated. For example, take a look at image #6. This is the code that allows the robot to take one single step. The main program also uses the RC Receiver library to understand how the robot should respond to certain commands made by the remote. For example, when the right analog stick is pushed continuously forward, this means the robot needs to move forward. The program responds to this by looping the code in image #6 that makes the robot take a single step.
General Flow of events
- The RC receiver library receives a command from the remote
- The main program finds the sequence of movements that the robot should perform based on said command
- The main program executes this sequence of movements by calling the Robot Control library
- The Robot Control library uses inverse kinematic equations to figure out where each servo should be moved and moves them there.
Finalist in the