1. What is this project?

This is a robotics project I developed for one of my classes. It is a fully functional set of animatronic eyes capable of looking in all directions (X/Y axis) and blinking/winking (independent eyelids).

The system is powered by an ESP32, which connects via Bluetooth to a standard PS4 controller. This allows for real-time manual control of the eyes using the analog sticks and triggers, rather than just running pre-programmed loops.

2. Why did I make it?

I built this to learn more about servo kinematics and Bluetooth integration. I wanted to move away from simple automated movements and create something interactive. Using a game controller makes the mechanism feel much more like a digital puppet.

The goal was to make this accessible and affordable, so it uses standard, low-cost components that most students or hobbyists already have lying around, rather than expensive proprietary robotics gear. Also i had only 5 servos lying around so i couldn't copy any of the existing designs. ;D

3. How does it work?

The Mechanics

The eyes are designed in CAD and 3D printed. The mechanism uses a linkage system where:

-2 Servos control the X and Y movement (looking up/down/left/right).

-2 Servos control the left and right eyelids independently.

I used standard, budget-friendly 9g micro servos (like the SG90 or MG90S). While they aren't industrial grade, they are perfect for a lightweight plastic mechanism like this.

The Electronics

The brain of the operation is an ESP32.

I used a PCA9685 16-Channel Servo Driver.

Communication: The ESP32 sends commands to the PCA9685 via I2C.

Power: The PCA9685 has an external power terminal, which allows me to power the servos directly from a battery supply (preventing brownouts on the microcontroller).

The Control Logic

I used the Bluepad32 library to interface with the PS4 controller.

Left Analog Stick: Maps to the X/Y coordinate of the eyes.

L2/R2 Triggers: Linearly control the eyelids (analog blinking).

Triangle Button: Triggers a specific function I call "Sus Mode" which is a pre-programmed animation where the eyes squint and look suspicious.

4. Wiring & Schematic

The wiring is straightforward. The ESP32 powers the logic of the servo driver, while an external power source handles the load of the motors.

ESP32 3V3 → PCA9685 VCC

ESP32 GND → PCA9685 GND

ESP32 Pin 22 → PCA9685 SCL

ESP32 Pin 21 → PCA9685 SDA

Battery Power → PCA9685 Green Terminal Block

5. Bill of Materials (BOM)

1x ESP32 Development Board

1x PCA9685 PWM Driver

4x SG90 or MG90S Micro Servos (Generic cheap servos)

1x PS4 Controller (or compatible Bluetooth gamepad)

3D Printed Parts (PLA)

Wires & 5V Power Supply

ASSEMBLY INSTRUCTIONS:

1. Install Software

  * Install Arduino IDE

  * Add ESP32 board support to Arduino IDE

  * Install required libraries: Adafruit PWM Servo Driver Library, Bluepad32

2. Initial Hardware Setup

  * Wire the ESP32 and PCA9685 as described above.

3. Servo Calibration

  * Connect the first servo to Channel 0:

   PCA9685  -> Servo

   V+     -> Red (5V)

   GND    -> Brown (GND)

   Channel 0 -> Orange (Signal)

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>


Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();


#define SERVO_MIN 102
#define SERVO_MAX 512


#define SERVO_CENTER map(90, 0, 180, SERVO_MIN, SERVO_MAX)


#define SERVO_1 0
#define SERVO_2 1
#define SERVO_3 2
#define SERVO_4 3


void setup() {
  Serial.begin(115200);
  Wire.begin();
  pwm.begin();
  pwm.setPWMFreq(50);  


  delay(500);
  uint16_t pulse = SERVO_CENTER;
  Serial.print("Centering servos to pulse: "); Serial.println(pulse);


  pwm.setPWM(SERVO_1, 0, pulse);
  pwm.setPWM(SERVO_2, 0, pulse);
  pwm.setPWM(SERVO_3, 0, pulse);
  pwm.setPWM(SERVO_4, 0, pulse);
}


void loop() {
}

4. Servo Range Test

  * Test each servo channel:

   * Channel 0 (X-axis): Find left/right limits (typically 70°-130°)

   * Channel 1 (Y-axis): Find up/down limits (typically 70°-110°)

   * Channel 2-3 (Eyelids): Test open/close (see below for values)

  * The default values provided below should work for most setups. If you experience issues, use the angle\_tester to determine your own safe ranges and update them in `main.ino`.

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>


Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();


#define SERVO_MIN 102   
#define SERVO_MAX 512    
#define SERVO_CH   2    


void setServoAngle(uint8_t ch, int angle) {
  angle = constrain(angle, 0, 180);
  uint16_t pulse = map(angle, 0, 180, SERVO_MIN, SERVO_MAX);
  pwm.setPWM(ch, 0, pulse);
  Serial.print("Servo "); Serial.print(ch);
  Serial.print(" -> "); Serial.print(angle); Serial.println("°");
}


void setup() {
  Serial.begin(115200);
  Wire.begin();            
  pwm.begin();
  pwm.setPWMFreq(50);        
  delay(200);


  setServoAngle(SERVO_CH, 90);
  Serial.println("Enter angle (0–180) and press ENTER:");
}


void loop() {
  if (Serial.available()) {
    String line = Serial.readStringUntil('\n');
    line.trim();
    if (line.length()) {
      int angle = line.toInt();
      if (angle < 0 || angle > 180) {
        Serial.println("Error: angle must be 0–180");
      } else {
        setServoAngle(SERVO_CH, angle);
      }
    }
  }
}

5. Software Configuration

   const int xLeft = 130; // Your tested left limit

   const int xRight = 70;  // Your tested right limit

   const int xMid  = 95;  // Your center position

   const int yUp  = 70;  // Your tested up limit

   const int yDown = 110; // Your tested down limit

6. Final Testing

  * Upload main.ino

  * Pair your Bluetooth gamepad (PS4 controller)

  * Test controls:

   * Left analog stick: Eye X/Y movement

   * L2/R2 triggers: Left/right eyelid control

   * Triangle button: "Sus mode" animation

## Assembly Instructions

1. Servo Mounting

  * Mount all servos to the base. Ensure that the yAxisArm1 is connected to the y-axis servo before assembling the left eyelid servo.

2. Arm Connections

  * Connect all arms to their corresponding servos.

  * Connect both eyes to the base, being careful not to break the flexible but fragile base pins.

  * Connect xAxisArm3.stl to the eyes, then xAxisArm2.stl to xAxisArm3.stl. After centering the servos, insert the protruding part of xAxisArm2.stl into the hole in xAxisArm1.stl.

  * Connect yAxisArm3.stl to yAxisArm2.stl, then yAxisArm2.stl to xAxisArm1.stl (which should already be connected to the servo). Be cautious as these parts are flexible but can break under tension.

3. Eyelid Assembly

  * Connect the eyelids to both the left and right eyes. The supporting part is designed to be flexible but can bend or break under excessive tension.

  * Attach the upper and lower arms to the eyelids using the corresponding screws (long screw for the lower eyelid arm, short screw for the upper eyelid arm). First attach the upper arm, then the lower arm.

  * For easier assembly, first attach the arms to the eyelids, then connect them to the base.

  * Connect the eyeLidArmLeft.stl and eyeLidArmRight.stl to the eyelid arms using the eyeLidScrew.stl

4. Eyelid Servo Calibration

  Important Note: The arm/horn mounted on the eyelid servo should not be perpendicular to the servo itself.

  Calibration Steps:

   * Ensure all servos are calibrated to 90 degrees.

   * Close both eyelids.

   * Mount the arm on the servo (eyelidarmleft/right) and slide it until the eyelids are closed. This should not move the motor; if it does, recalibrate the servo.

   * Repeat the process for the other eye.

5. Final Adjustments

* The assembly is designed for a tight, snap-fit connection. Only the x and y axis arms require screws for the horns.

* Ensure all connections are secure and the mechanism moves smoothly without additional parts.

6. Additional Resources

* I found these doll eyes on AliExpress that fit perfectly into the eye.stl - https://a.aliexpress.com/_EHM9l0K