How to Build the Robotic Eyes Kit

Introduction

Welcome to the official Greene Robotics tutorial for the Robotic Eyes Kit! This step-by-step guide walks you through assembling and bringing to life your own animatronic eyes — just like the ones in our product photos and videos.

This tutorial pairs with the Robotic Eyes Kit, available on our Etsy shop. Every part you need is included — servos, control board, 3D-printed pieces, and wiring — so you can focus on learning, building, and having fun.

Whether you’re a beginner or an experienced maker, this project is approachable and easy to follow. By the end, you’ll have a fully functional pair of animatronic eyes ready to control. Let’s dive in!

Before you start, please read through all of the instructions. We know reading can be boring, but skipping steps is one of the most common reasons a build goes wrong. Taking the time to read everything will help your robot work right the first time. Have fun!

Tip: All images can be clicked on to be enlarged, so that you can zoom in to get a closer look.

Assemble the Eyes

Start with the eyes. Grab an eye and the black part with the numbers 3 and 4 on the back, shown below.

The two eyes are different — use the one that lines up with the two holes, as shown. Attach it to the mechanism with screws: the middle hole (circled green) takes a 16mm screw, the other hole (circled red) takes a 6mm screw.

It should look like the image below. Keep the screws snug but not overtight — if a screw is too tight, the friction will stop the eye from moving. It’s better to start them off loose, then tighten once you know it works.

1× 16mm screw + 1× 6mm screw

Start two 12mm screws into the holes on the outside of the assembly, as shown. Don’t tighten them yet — just get them started.

2× 12mm screws

Get a pair of eyelids and lay them flat, like this.

Lift them into the position shown. The center holes line up with the screws you just started, so you can tighten those fully to hold the eyelids in place.

Once tightened, the screws hold the eyelids in place while still letting them move freely.

Connect the push rods to the eyelids with two 6mm screws, as shown. Remember, they should just be tight enough to keep the screw in place. If you make them too tight, it will restrict the eyelid from actually closing, which is a problem in itself, and it can also cause your motor to break. So, start loose, then once you know it works you can tighten them slightly if you’d like.

2× 6mm screws

Nice work — that’s one finished eye! Now build the second one (unless you’re going for a cyclops). The steps are identical, just mirrored, so reference the first eye as you go.

Assemble the Neck

With both eyes done, it’s time to attach them to the neck — the part that moves up, down, left, and right. Grab the piece shown below.

Flip the eyes upside down and arrange them exactly as shown, with the eyelid push rods facing outward.

Once in place, use four 12mm screws to tightly secure the eye mechanism to the neck base.

4× 12mm screws

Place the assembly as shown. The motors should read 1 to 4, left to right — if the leftmost motor is 3, swap the eyes’ positions. Match the image exactly, with the eyelid push rods on the outside.

Next, we will connect the platform that holds the eyes to the “neck” that moves it up, down, left, and right. Gather the parts shown below.

Set the black joint into the base as shown. Then take the smaller of the two black pins and push it all the way through the hole to secure the joint.

Secure it with a 6mm screw on the other side.

1× 6mm screw

Assembled, it should look like the image below, and the black joint should rotate easily.

Get the two black rods — these push the eyes up and down for neck movement. Attach them to the servo motors by aligning the hole on each rod with the hole on the motor.

Secure them with two 10mm screws — snug, but not too tight.

2× 10mm screws

Now attach the assembled eyes: align the hole on the bottom of the eye base with the black neck joint you installed earlier.

Connect the joint with the long pin, sliding it all the way through.

Secure the pin with a 6mm screw so it can’t fall out, as shown.

1× 6mm screw

Now connect the up-and-down rods to the eyes themselves.

Use two 6mm screws, tightened to a snug fit, as shown. This is another point where the screws should definitely not be tight — if they’re too tight, it won’t allow the robot to move, and could burn out the motors controlling it. So, it’s better to play it safe and keep them fairly loose, and after it operates the first time you can tighten them as you see fit.

2× 6mm screws

Great work — the eyes and neck are fully assembled. Next, we are going to connect it to the base!

Assemble the Base

Get the big base and the four adhesive rubber pads.

Flip the base upside down. The four indented circles are where the rubber pads go — they keep the robot from sliding around on a surface.

Stick the pads into the circles, as shown.

Flip the base back over and find the square pin. Align it as shown below, with its screw hole facing the hole in the base so you can screw it down.

Once it’s in place, secure it with a 6mm screw.

1× 6mm screw

Tighten it all the way. This pin is what the rest of the eye assembly connects to.

Line up the square hole on the eye assembly with the pin you just secured.

Slide it onto the pin and lock them together with another 6mm screw. Everything is now securely connected.

1× 6mm screw

Good work — all the mechanical parts are now assembled and connected. The last step is wiring everything up so the components can talk to each other and bring your robot to life.

Wire it up

Time to wire it up. The wiring is designed to be simple, but pay close attention here — misplaced wires can damage your robot. Don’t let that scare you; follow the directions exactly and it’ll work perfectly. Start by facing the back of your robot.

Below is what the servo wire looks like. Notice that it has 3 wires bundled into one connector, and each wire has a different color. This is very important, and we’ll get into the specific wiring details next. It matters because each wire is expecting a specific signal, and if it receives the wrong signal, it could cause damage to the servo motor.

Now it’s your turn to wire every wire up to the board. Remember, all you have to do is match the number on the motor to the number on the board, as well as follow the color orientation rule for the wire: the yellow end plugs into the row labeled yellow, red to red, and brown to brown. Motor 1 plugs into slot 1, motor 2 plugs into slot 2, and so on. Remember, we only use the first 6 rows — the last 2 (labeled 7 and 8) won’t be used for this project.

Once they’re all plugged in, it should look like this — every yellow wire facing the robot (the “Yellow wires this side” label) and every brown wire facing away. Double-check that color orientation, then confirm each wire is in its matching pin (1 to 1, 2 to 2, etc.). If everything checks out, nice work — the servos are wired.

If you are confident that you followed the directions carefully and every wire is plugged in correctly, then congrats! Feel free to keep moving on. If you have any doubt that you may have plugged in a wire wrong in any way, we recommend going back through this section and checking your work — a wrongly placed wire is the number one cause of the robot not working, or potentially damaging itself.

That’s the build finished — every part assembled and every wire in place. Stick around for the last section to learn how to control it.

Guess what? You just finished building a really cool robot! Whether you’re a beginner or an expert, completing a project and seeing it actually work is an incredibly rewarding experience. This feeling—turning an idea into something real—is what robotics is all about, and it’s a feeling many people end up chasing once they discover a passion for it. Enjoy your robot, and have fun exploring what it can do!

How to Operate

Now that your robot is fully built, it’s time to bring it to life! Below you’ll find instructions on how to power it on, operate it, and keep it running smoothly, along with some helpful tips.

Troubleshooting

Running into an issue? We’ve put together a troubleshooting guide covering the most common problems and how to easily fix them.

View the troubleshooting guide

Bonus Content

The official tutorial is officially over… so why are you still here? It’s because you’re one of the curious ones. You didn’t just want to build the robot—you want to understand how it works. And honestly, that curiosity is one of the most important skills in engineering and robotics.

Below is the code for the joystick-controlled version of the kit — the exact sketch that comes pre-programmed onto its board. If you’re a beginner and want to learn more about coding and engineering, one great way to do that is to copy this code and paste it into an AI, then have it explain what each part does. It might feel like cheating at first, but in reality, this is how many real programmers learn and improve.

So go ahead—dig in, explore the code, and see what makes your robot come to life!

Joystick-Controlled Kit

/*
 * RobotEyesJoystick — two-joystick control for a six-servo animatronic eye
 * mechanism: two eyelids, two eyes, and two neck servos, driven by an Arduino.
 *
 * Both joysticks are read continuously and mapped straight onto the servos, so
 * the robot mirrors your hands in real time. There is nothing to connect to and
 * nothing to configure — power the board and it runs.
 *
 * WHAT EACH STICK DOES
 *   Joystick 1, up/down    Moves both eyes together, side to side.
 *   Joystick 1, left/right Opens and closes the eyelids as a mirrored pair.
 *   Joystick 2             Aims the neck: up/down tilts, left/right turns.
 *
 * HOW IT WORKS
 *   A joystick is just two potentiometers, so analogRead gives a number from
 *   0 to 1023 with about 512 at rest. Each axis is scaled into an angle, held
 *   inside the arc its linkage can physically reach, and then — for the eyes
 *   and neck — eased toward rather than snapped to, which is what keeps the
 *   movement smooth instead of twitchy. The loop repeats about 100 times a
 *   second, so the easing plays out over a fraction of a second.
 *
 * REQUIREMENTS
 *   The Servo library, which ships with the Arduino IDE. Nothing else to install.
 */

#include <Servo.h>

// S1/S4 are the eyelids, S2/S3 the eyes, S5/S6 the neck.
Servo s1, s2, s3, s4, s5, s6;

// --- JOYSTICK PINS ---
const int joy1X = A0;
const int joy1Y = A1;
const int joy2X = A3;
const int joy2Y = A4;

// --- TUNING PARAMETERS ---
// The smooth factors set how much of the remaining distance a servo closes each
// time through the loop: higher is faster and snappier, lower is slower and
// heavier. The neck carries the most weight, so it gets the gentlest value.
// The deadzone ignores small readings around centre, since a joystick at rest
// never sits at exactly 512 and would otherwise drift.
float smoothFactor = 0.1;
float NeckSmoothFactor = 0.07;
int deadzone = 15;

// Eased positions the servos are actually written to, updated a step at a time.
float cur3, cur2, cur5, cur6;

void setup() {
  Serial.begin(9600);

  // Attach each servo to its pin.
  s1.attach(2); s2.attach(3); s3.attach(4);
  s4.attach(5); s5.attach(6); s6.attach(7);

  // Start every smoothed servo from centre so nothing lurches on the first pass.
  cur5 = cur6 = 90;
  cur3 = cur2 = 90;
}

void loop() {
  // ==========================================
  // --- JOYSTICK 1 Y-AXIS (Servos 3 & 2) ---
  // ==========================================
  // Both eyes track this one axis, so they always look the same direction.
  int rawY1 = analogRead(joy1Y);

  if (abs(rawY1 - 512) < deadzone) rawY1 = 512;

  // Scale the reading to an angle, then keep it inside the eyes' travel.
  int targetY1 = map(rawY1, 0, 1023, 0, 180);
  targetY1 = constrain(targetY1, 45, 140);

  // --- SMOOTHING ---
  // Close part of the gap to the target rather than jumping to it outright.
  cur3 += (targetY1 - cur3) * smoothFactor;
  cur2 += (targetY1 - cur2) * smoothFactor;

  s3.write((int)cur3);
  s2.write((int)cur2);


  // ==========================================
  // --- JOYSTICK 1 X-AXIS (Servos 4 & 1) ---
  // ==========================================
  // Only half of this axis is used: anything from centre downward clamps to 90,
  // which holds the eyelids open, so it takes a deliberate push to close them.
  int rawX1 = analogRead(joy1X);

  int activeAngleX = constrain(map(rawX1, 0, 1023, 0, 180), 90, 180);

  // The two lids are mirrored — one closes by counting up, the other by counting
  // down — and both are written straight through, so a blink lands instantly.
  s4.write(map(activeAngleX, 90, 180, 90, 150));

  s1.write(map(activeAngleX, 90, 180, 90, 30));


  // ==========================================
  // --- JOYSTICK 2 (Servos 5 & 6 Mix) ---
  // ==========================================
  // The neck servos work as a pair. Moving them the same way tilts the head;
  // moving them opposite ways turns it. Mixing both axes into each servo is what
  // lets one stick do both at once.
  int rawX2 = analogRead(joy2X);
  int rawY2 = analogRead(joy2Y);

  if (abs(rawX2 - 512) < deadzone) rawX2 = 512;
  if (abs(rawY2 - 512) < deadzone) rawY2 = 512;

  // Re-centre each axis on zero so it reads as an amount to move, not a position.
  int moveY = map(rawY2, 0, 1023, -90, 90);
  int moveX = map(rawX2, 0, 1023, -90, 90);

  // Y is added to both (they move together), X is added to one and subtracted
  // from the other (they move apart).
  int target5Base = 90 + moveY - moveX;
  int target6Base = 90 + moveY + moveX;

  // Combining two axes can overshoot, so clamp to the neck's travel.
  int target5 = constrain(target5Base, 30, 165);
  int target6 = constrain(target6Base, 30, 165);

  cur5 += (target5 - cur5) * NeckSmoothFactor;
  cur6 += (target6 - cur6) * NeckSmoothFactor;

  s5.write((int)cur5);
  s6.write((int)cur6);

  delay(10);   // ~100 loops per second, the rate the smoothing is tuned around
}