Why does my ESP32-CAM reset when the servos move?

This is a classic 'brownout' issue. Servo motors draw high current spikes (up to 1A+) when they start moving. If they share the same 5V line as the ESP32-CAM, the voltage drops, causing the ESP32 to reset. The solution is to power the servos from a separate, dedicated 5V 2A (or higher) power supply, ensuring only the GND is shared with the ESP32.

What is the best Edge Impulse model for ESP32-CAM object tracking?

FOMO (Faster Objects, More Objects) is highly recommended for the ESP32-CAM. It is specifically optimized for microcontrollers, offering a great balance between accuracy, memory usage, and inference speed (often achieving 10-15 FPS on the ESP32), which is crucial for real-time tracking.

How can I make the camera movement smoother and less jerky?

Instead of simple proportional control, implement a PID (Proportional-Integral-Derivative) controller. The 'Derivative' term predicts future error based on the current rate of change, effectively damping the movement and preventing the servos from overshooting and oscillating around the target. Additionally, implement a 'deadzone' to ignore tiny pixel errors.

Can this system track multiple objects at once?

Yes, Edge Impulse models can detect multiple bounding boxes. However, for a single pan-tilt camera, you must program the logic to decide *which* object to follow (e.g., the largest bounding box, the one closest to the center, or the one with the highest confidence score) to calculate the error for the servo movement.

DIY ESP32-CAM Object Tracking System: Auto-Follow Robotics with Edge Impulse & Servo Motors

ESP32-CAM mounted on a 2-axis servo pan-tilt bracket for object tracking

Figure 1: A 2-axis pan-tilt mechanism powered by an ESP32-CAM and Edge Impulse AI for real-time object tracking.

⚠️ CRITICAL WARNINGS: POWER & PRIVACY

Power Supply Brownouts: Servo motors draw high current spikes when moving. Never power servos directly from the ESP32-CAM's 3.3V or 5V pin. Use a dedicated 5V 2A (or higher) external power supply with a common ground to prevent ESP32 brownout resets.
Privacy & Ethics: This project is designed for educational purposes, robotics, and tracking inanimate objects or pets. Do not deploy autonomous tracking systems to monitor people without their explicit consent.

Welcome to TechFix Hub! Imagine a camera that doesn't just record, but actively watches and follows a specific object. Whether it's a security camera that tracks movement, a robotic head that follows your face, or a turret that tracks a colored ball, the core technology is the same: Computer Vision + Mechanical Actuation.

In this comprehensive guide, we will build an Auto-Follow Object Tracking System using the affordable ESP32-CAM, a 2-axis servo pan-tilt bracket, and the power of Edge Impulse for custom, offline object detection. No cloud subscriptions, no complex Raspberry Pi setups—just pure, efficient Edge AI.

🧠 1. The Architecture: How Auto-Tracking Works

The system operates in a continuous, high-speed feedback loop:

Capture: The ESP32-CAM captures a frame (e.g., 160x120 or 320x240 resolution) from its OV2640 sensor.
Inference (Edge Impulse): The frame is fed into a pre-trained TinyML object detection model (like FOMO or MobileNetV2 SSD) running locally on the ESP32. The model outputs the bounding box coordinates (X, Y, Width, Height) of the target object.
Error Calculation: The code calculates the "error" by comparing the center of the detected bounding box to the center of the camera frame (e.g., Frame Center X = 160, Object Center X = 200 → Error = +40).
Actuation (Proportional Control): The error is multiplied by a gain factor (Kp) and added to the servo's current angle. This smoothly pans or tilts the camera to center the object, and the loop repeats.

🛠️ 2. Bill of Materials (BOM)

Component	Specification	Function
Microcontroller	ESP32-CAM (with OV2640 camera)	Captures images and runs the Edge Impulse inference engine.
Actuators	2x SG90 (for light setups) or MG996R (for heavier cameras) Servos	Provides Pan (horizontal) and Tilt (vertical) movement.
Mechanical	2-Axis Pan-Tilt Bracket (Plastic or Aluminum)	Mounts the servos and the ESP32-CAM securely.
Power Supply	5V 2A (or 3A) DC Power Adapter	Crucial: Powers the servos independently to prevent ESP32 brownouts.
Programmer	FTDI USB-to-Serial Adapter (3.3V logic)	Required to upload code to the ESP32-CAM.

💻 3. Step 1: Training Your Custom Model in Edge Impulse

Before writing code, we need to teach the ESP32 what to track. We recommend using the FOMO (Faster Objects, More Objects) algorithm, which is optimized for microcontrollers.

Data Collection: Use the Edge Impulse data forwarder or upload 100-200 images of your target object (e.g., a specific toy, a colored ball, or your face) from various angles and lighting conditions.
Labeling: Draw bounding boxes around the target object in every image.
Impulse Design: Set image size to 96x96 or 128x128. Use "Resize" as the processing block, and "Object Detection (FOMO)" as the learning block.
Training & Testing: Train the model. Aim for >85% accuracy on the test set. If it's lower, add more diverse images to your dataset.
Deployment: Go to the Deployment tab, select "Arduino Library", and download the ZIP file. Install it in your Arduino IDE.

🔌 4. Step 2: Wiring and The Tracking Code

Wiring Rule #1: Connect the GND of the ESP32-CAM, the GND of the external 5V power supply, and the GND of the servos together. Do not connect the 5V from the power supply to the ESP32's 5V pin; only power the servos externally.

Connect Servo 1 (Pan) to GPIO 13 and Servo 2 (Tilt) to GPIO 14 (or other available PWM-capable pins).

Core Tracking Logic (Arduino Snippet):

#include 
#include 

Servo panServo;
Servo tiltServo;

// Target frame center (for 160x120 resolution)
const int FRAME_CENTER_X = 80;
const int FRAME_CENTER_Y = 60;

// Proportional control gains (Tweak these for smoothness)
const float Kp_pan = 1.5;  
const float Kp_tilt = 1.2; 

int current_pan_angle = 90;
int current_tilt_angle = 90;

void setup() {
  Serial.begin(115200);
  panServo.attach(13);
  tiltServo.attach(14);
  panServo.write(current_pan_angle);
  tiltServo.write(current_tilt_angle);
  
  // Initialize Edge Impulse classifier here...
}

void loop() {
  // 1. Capture frame and run inference (pseudo-code)
  // ei::run_classifier(&signal, &result, false);
  
  // 2. Assume we found one bounding box
  if (result.bounding_boxes[0].value > 0.7) { // 70% confidence
    float obj_x = result.bounding_boxes[0].x + (result.bounding_boxes[0].width / 2);
    float obj_y = result.bounding_boxes[0].y + (result.bounding_boxes[0].height / 2);
    
    // 3. Calculate error
    float error_x = FRAME_CENTER_X - obj_x;
    float error_y = FRAME_CENTER_Y - obj_y;
    
    // 4. Apply Proportional Control
    current_pan_angle += (error_x * Kp_pan);
    current_tilt_angle += (error_y * Kp_tilt);
    
    // 5. Constrain to servo limits (e.g., 0 to 180)
    current_pan_angle = constrain(current_pan_angle, 10, 170);
    current_tilt_angle = constrain(current_tilt_angle, 20, 160);
    
    // 6. Move servos
    panServo.write(current_pan_angle);
    tiltServo.write(current_tilt_angle);
  }
  
  delay(100); // Small delay for stability
}

🚀 5. The "TechFix Hub" Upgrade: From Jerky to Cinematic

Basic proportional control can make the camera jitter or overshoot. Elevate your project with these pro upgrades:

Implement a PID Controller: Replace the simple `Kp` multiplication with a full PID (Proportional-Integral-Derivative) library. The Derivative (D) term will dampen the movement, preventing the camera from violently oscillating around the target.
Deadzone Filtering: Add a "deadzone" (e.g., if the error is less than 5 pixels, do nothing). This prevents the servos from constantly micro-adjusting and buzzing when the object is already centered.
Web Dashboard Integration: Use the ESP32-CAM's built-in web server to stream the video with bounding boxes drawn on it (using HTML5 Canvas), allowing you to monitor the tracking performance remotely from your phone.

🔗 Explore More on TechFix Hub

Master Edge AI and ESP32 robotics with our complementary guides:

✅ Conclusion

Building an auto-follow object tracking system is a milestone project that bridges the gap between software AI and hardware robotics. By leveraging the ESP32-CAM and Edge Impulse, you can create a highly responsive, privacy-respecting tracking device for a fraction of the cost of commercial alternatives. Tweak your PID values, refine your dataset, and watch your creation come to life!

🛠️ Building your own tracking robot?

Struggling with servo jitter, Edge Impulse accuracy, or ESP32-CAM brownouts? Drop your questions in the comments below, and the TechFix Hub community will help you troubleshoot!

Keywords: ESP32-CAM Tracking Edge Impulse Auto-Follow Robot Computer Vision DIY

Author Description