Few robots are more recognisable than WALL·E; his cute appearance and distinctive personality make him instantly endearing to anyone who sees him! In this project, I designed a WALL·E replica with the aim to allow each of the robot’s joints to be moveable by hand or using servo motors.

Loosely based on the dimensions and design of ChaosCoreTech’s Wall-E replica, this version was designed from scratch in Solidworks and allows 7 of the joints to be actuated, including the arms, neck, head and eyes. The robot design has the following features:

  • Each eye can be raised and lowered independently with servo motors.
  • There is room in each eye to add a small camera.
  • The head can look left and right using a servo motor.
  • The neck is actuated at two joints, allowing the head to look up/down and to be raised/lowered.
  • Each arm has a motor at the shoulder to move it up/down.
  • The arms consist of pressure fit joints, hands and fingers, which can be manually posed.
  • The tank treads (skid steering) are fully 3D printed and can be powered using two 12V DC geared motors.

This is an ambitious project, aimed at people who want to build a fully animatronic WALL·E robot with servo controlled joints. It took me about 3 months to design and assemble the robot, with more than a month spent on just 3D printing all of the parts. In total, there are 310 parts (although 210 of those are very small and make up the tank treads).

1. List of 3D Printed Parts

The robot comprises of 310 individual parts, so this definitely is not an easy project suitable for people who don’t have much experience with 3D printing! Personally, I spent more than a month printing all the parts, with the printer running almost every day. The largest components (the main body parts) took up to 14 hours of print time each, while the smaller parts took 5-6 hours. If you are interested in making your own robot, I have uploaded the 3D files for all the components on Thingiverse.

2. List of other Components

A variety of other hardware is used to fasten the 3D printed parts together and bring the robot to life. A list of the hardware and electronic parts that I used is shown below. To make WALL·E look more realistic, I took apart some old binoculars and used the lenses as the eyes. I think that the shine and reflections on the glass adds a lot of soul to the robot, and make him look even cuter.

Note: Links are for reference only, and are not where I bought my parts. Please shop around to find the best supplier near you! The DC geared motors can also be bought with additional encoders, allowing you to have better control of the robot’s movement speed. However, if you want to add encoders you will need to modify my Arduino code in order to support them; an intermediate level of programming knowledge is required!

While it is possible to use a Wifi/bluetooth connected Arduino micro-controller to control the robot, I decided to use a Raspberry Pi instead. Since the Raspberry Pi is essentially a small computer, it can be used to play sound effects, stream the video from a USB camera, and host a web interface through which the robot can be controlled.

3. 3D Design and Printing

I designed all the components in Solidworks, using images and other 3D models as reference. The main aim in the design process was to split the robot into small enough pieces so that they would fit into the 3D printer, and also to integrate all the motors and electronic components. I tried to make the robot as small as possible, while still leaving enough room for the motors.

4. Painting

After 3D printing each of the parts, I spent a lot of time sanding the parts to remove all of the print lines and give them a smooth finish. Two coats of filler-primer were then applied, with more sanding done between each of the coats. Using a primer is important, as it helps the paint to stick to the plastic and not rub off as easily. It is also useful as it makes imperfections and bumps on the part more obvious, showing where further sanding needs to be done.

Each of the parts was then individually painted with lacquer spray paints. I only used yellow, white, light grey, dark grey, black, and red spray paints to paint the whole robot. By splattering light layers of black and red paint onto the parts that were painted grey, it was possible to add texture and make them look a lot more like real metal.

Finally, after fully assembling the robot, I used black and brown acrylic paints to weather the robot. This involves applying the paint liberally onto all the surfaces, and roughly wiping away most of it with a towel. The paint that isn’t wiped away stays in the corners and crevices of the parts, making the overall replica look older and more realistic.

5. Assembly

The video below shows how to assemble the robot. Overall, the assembly is not too difficult, but it is important to put the parts together in the right order. While a couple of small parts needs to be glued together, most parts are fastened together using bolts. This makes assembly and disassembly easy if any parts need to be fixed or replaced. The trickiest part was probably the wiring, figuring out how to connect the motors in the eyes of the robot to the controller in the body. When attaching the servo motors, make sure the the servo horns are attached such that the servos can move between the positions shown in the images in section 8(c) (Servo motor calibration).

6. Wiring and Electronics

The wiring diagram is shown below, illustrating how each of the electronic components were connected in the robot. The USB port of the Arduino Uno was then connected to the USB port of the Raspberry Pi. If the 12v to 5v DC buck converter is capable of delivering up to 5 amps, then the Raspberry Pi can be directly powered from the converter. Otherwise, it should be connected to a separate 5v battery.

7. Programming

The programming of the robot can be split into two main parts; the code for the Arduino micro-controller, and the web-server on the Raspberry Pi. I’ve uploaded all my code onto GitHub; the link is shown below.

The Arduino controls all of the motors within the robot, determining how they should move. In the code I added a velocity controller, so that the servo motors don’t suddenly jump into life at full speed, but instead start and stop gently.

The Raspberry Pi is connected to the Arduino via a USB cable, and can send user commands to the Arduino to make the robot move in a specific way. The Pi is also connected to a USB webcam and a speaker, and can play sound effects. The code is written in Python, and uses ‘Flask’ to generate a webserver. Any computer on the same local network can then access the page and remote control the robot.

8. Arduino Installation Guide

[a] Basic Installation

  1. Ensure that the wiring of the electronics matches the circuit diagram.
  2. Download/clone the folder “wall-e” from the GitHub repository.
  3. Open wall-e.ino in the Arduino IDE; the files MotorController.hpp and Queue.hpp should automatically open on separate tabs of the IDE as well.
  4. Install the Adafruit_PWMServoDriver.h library
    1. Go to Sketch -> Include Library -> Manage Libraries…
    2. Search for Adafruit Servo.
    3. Install version 1.0.2 of the library; the newest version has a bug and does not work properly.
  5. Connect to the computer to the micro-controller with a USB cable. Ensure that the correct Board and Port are selected in the Tools menu.
  6. Upload the sketch to the micro-controller.

[b] Testing the Main Program

  1. Once the sketch has been uploaded to the Arduino, power on the 12V battery while the micro-controller is still connected to the computer.
  2. Open the Serial Monitor (button in top-right of Arduino IDE). Set the baud rate to 115200.
  3. To control the movement of the robot, send the characters ‘w’, ‘a’, ‘s’ or ‘d’ to move forward, left, back or right respectively. Send ‘q’ to stop all movement.
  4. To move the head, send the characters ‘j’, ‘l’, ‘i’ or ‘k’ to tilt the head left or right and the eyes upwards or downwards.
  5. Only move on to using the Raspberry Pi if all these functions are working correctly!

[c] Servo Motor Calibration

  1. Download/clone the folder “wall-e_calibration” from the GitHub repository.
  2. Open wall-e_calibration.ino in the Arduino IDE.
  3. Upload the sketch to the micro-controller, and open the serial monitor and set the baud rate to 115200.
  4. The sketch is used to calibrate the maximum and minimum PWM pulse lengths required to move each servo motor across its desired range of motion. The standard LOW and HIGH positions of each of the servos is shown in the images below.
  5. When starting the sketch and opening the serial monitor, a message should appear after 2-3 seconds, saying that it is ready to calibrate the LOW position of the first servo motor (the head rotation).
  6. Send the character ‘a’ and ‘d’ to move the motor backwards and forwards by -10 and +10. For finer control, use the characters ‘z’ and ‘c’ to move the motor by -1 and +1.
  7. Once the motor is position in the correct position (as shown in the images below), send the character ‘n’ to proceed to the calibration step. It will move on to the HIGH position of the same servo, after which the process will repeat for each of the 7 servos in the robot.
  8. When all joints are calibrated, the sketch will output an array containing the calibration values to the serial monitor.
  9. Copy the array, and paste it into lines 85 to 92 of the program wall-e.ino. The array should look similar to this:
    int preset[][2] =  {{398, 112},  // head rotation
                        {565, 188},  // neck top
                        {470, 100},  // neck bottom
                        {475, 230},  // eye right
                        {270, 440},  // eye left
                        {350, 185},  // arm left
                        {188, 360}}; // arm right

9. Raspberry Pi Web Server

[a] Basic Installation

  1. Setup the Raspberry Pi to run the latest version of Raspbian/NOOBS. The setup instructions can be found on the Raspberry Pi website.
  2. Open the command line terminal on the Raspberry Pi.
  3. Ensure that the package list has been updated (this may take some time): sudo apt-get update
  4. Install Flask – this is a Python framework used to create webservers:
    1. Ensure that pip is installed: sudo apt-get install python-pip
    2. Install Flask and its dependencies: sudo pip install flask
  5. Clone repository into the home directory of the Raspberry Pi:
    cd ~
    git clone https://github.com/chillibasket/walle-replica.git 
  6. Connect to the Arduino/micro-controller:
    1. Plug the Arduino/micro-controller into the USB port of the Raspberry Pi.
    2. Use the following command to list the connected USB devices. Record the name of the device you want to connect to:
      result=$(python <<EOF
      import serial.tools.list_ports
      for p in serial.tools.list_ports.comports():
      echo $result
    3. Open app.py: nano ~/walle-replica/web_interface/app.py
    4. Paste the exact name of the micro-controller into line 92, where is says ARDUINO. To jump to a specific line number in the editor, you can press CTRL + _.
  7. Set the web server password:
    1. On line 180 of app.py where is says put_password_here, insert the password you want to use for the web interface.
    2. Press CTRL + O to save and CTRL + X to exit the nano editor.

[b] Using the Web Server

  1. To determine the current IP address of the Raspberry Pi on your network, type the command: hostname -I
  2. To start the server: python3 ~/walle-replica/web_interface/app.py
  3. To access the web interface, open a browser on any computer/device on the same network and type in the IP address of the Raspberry Pi, follow by :5000. For example
  4. To stop the server press: CTRL + C

[c] Adding a Camera Stream

  1. Install mjpg-streamer – this is used to stream the video to the webserver. A good description of the installation procedure is described here. Complete the Install & Setup steps, as well as creating the Auto Start Manager Script. Stop when you reach the Start on Boot section.
  2. Make sure that the manager script you created has the correct name and is in the correct directory: /home/pi/mjpg-streamer.sh

[d] Automatically start Server on Boot

  1. Create a .service file which is used to start the web interface: nano ~/walle.service
  2. Paste the following text into the file:
    Description=Start Wall-E Web Interface
    ExecStart=/usr/bin/python3 app.py
  3. Press CTRL + O to save and CTRL + X to exit the nano editor.
  4. Copy this file into the startup directory using the command: sudo cp ~/walle.service /etc/systemd/system/walle.service
  5. To enable auto-start, use the following command: sudo systemctl enable walle.service
  6. The web interface should now automatically start when the Raspberry Pi is turned on. You can also manually start and stop the service using the commands: sudo systemctl start walle.service and sudo systemctl stop walle.service

[e] Adding new Sounds

  1. By default the Raspberry should automatically select whether to output audio to the HDMI port or the headphone jack. However, you can ensure that it always uses the headphone jack with the following command: amixer cset numid=3 1
  2. Make sure that all the sound files you want to use are of type *.ogg. Most music/sound editors should be able to convert the sound file to this format.
  3. Change the file name so that it has the following format: [file name]_[length in milliseconds].ogg. For example: eva_1200.ogg
  4. Upload the sound file to Raspberry Pi in the following folder: ~/walle-replica/web_interface/static/sounds/
  5. All the files should appear in the web interface when you reload the page. If the files do not appear, you may need to change the privileges required to access the folder: sudo chmod -R 755 ~/walle-replica/web_interface/static/sounds
If you have any questions or comments, please leave a reply below: Create new Comment