Raspberry Pi colour-tracking pan-tilt camera with OpenCV: design worksheet and code

A ₹6,990 camera that turns to keep a coloured ball in the middle of the picture. OpenCV finds the ball by its colour, the code measures how far off-centre it is in pixels, converts that to degrees, and moves a pan servo and a tilt servo by a fraction of the error each frame. The page works out the conversion and why a fraction, not the whole error, is used.

Scope: advanced. This is a design worksheet with illustrative costs. It has not been bench-tested by this site. The table was computed by script using 62.2° horizontal field of view across 640 pixels, which is the figure commonly listed for the Raspberry Pi camera module v2; check the field of view of your own camera. Colour tracking depends heavily on lighting, so thresholds need tuning on site. This page does not cover faces or people, and a camera pointed at people should only be used with their knowledge.

How it works

A 640-pixel-wide frame covering 62.2° gives 0.097° per pixel. An object 100 pixels from the centre is therefore about 9.7° off-axis, and one 320 pixels away, at the frame edge, about 31°. The vertical axis is handled the same way with its own field of view.

Moving the servo by the whole error each frame would overshoot, because the image arrives late and the servo takes time to move. Moving by 40 percent of the error each frame is a simple proportional controller that homes in smoothly; the third column of the table shows the move for each error. If it still oscillates, lower the gain.

Prices are illustrative figures for Indian sellers in November 2026, before shipping, and have not been checked against current listings.

The numbers

At 30 frames per second a 40 percent step closes about 97 percent of an error in six frames, which is roughly a fifth of a second. If you raise the gain to 100 percent, delay in the camera and servo can make the mount swing; lower gains are slower but steadier.

Power and wiring

The sketch

# Colour-tracking pan-tilt: Raspberry Pi + camera + 2 servos
# Design worksheet: tune the HSV range for your lighting.
# Needs: opencv-python, gpiozero, pigpio (run: sudo pigpiod)

import cv2
from gpiozero import AngularServo
from gpiozero.pins.pigpio import PiGPIOFactory

W, H = 640, 480
FOV_X, FOV_Y = 62.2, 48.8        # degrees, commonly listed for camera module v2
GAIN = 0.4                       # fraction of the error corrected per frame
DEAD_PX = 12                     # ignore tiny errors
LOW = (35, 90, 60)               # example green range in HSV
HIGH = (85, 255, 255)
MIN_AREA = 300                   # ignore small blobs

factory = PiGPIOFactory()
pan = AngularServo(17, min_angle=-90, max_angle=90, pin_factory=factory)
tilt = AngularServo(27, min_angle=-90, max_angle=90, pin_factory=factory)
pan_angle, tilt_angle = 0.0, 0.0
pan.angle, tilt.angle = pan_angle, tilt_angle

cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, W)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, H)

while True:
    ok, frame = cap.read()
    if not ok:
        break
    hsv = cv2.cvtColor(cv2.GaussianBlur(frame, (7, 7), 0), cv2.COLOR_BGR2HSV)
    mask = cv2.inRange(hsv, LOW, HIGH)
    mask = cv2.erode(mask, None, iterations=2)
    mask = cv2.dilate(mask, None, iterations=2)
    contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    if contours:
        c = max(contours, key=cv2.contourArea)
        if cv2.contourArea(c) > MIN_AREA:
            m = cv2.moments(c)
            cx, cy = m["m10"] / m["m00"], m["m01"] / m["m00"]
            err_x, err_y = cx - W / 2, cy - H / 2
            if abs(err_x) > DEAD_PX:
                pan_angle -= GAIN * err_x * FOV_X / W     # sign depends on mounting
            if abs(err_y) > DEAD_PX:
                tilt_angle += GAIN * err_y * FOV_Y / H
            pan_angle = max(-80, min(80, pan_angle))
            tilt_angle = max(-60, min(60, tilt_angle))
            pan.angle, tilt.angle = pan_angle, tilt_angle

    cv2.imshow("mask", mask)
    if cv2.waitKey(1) & 0xFF == 27:                        # Esc to quit
        break

cap.release()
cv2.destroyAllWindows()

The signs of the two corrections depend on how the servos and camera are mounted; if the camera runs away from the target, flip the sign. The camera capture call may need another backend on newer Raspberry Pi OS releases, where the camera is read through its own library, so check the camera documentation for your OS version before debugging the code. The HSV range above is an example only. The sketch has been proofread but not compiled on this site.

Test plan

1. Camera first: confirm a live picture before adding servos.
2. Colour mask: hold the target in view and tune the HSV range until only it shows white in the mask window.
3. Direction: move the target left, right, up and down and check the camera follows, flipping signs if needed.
4. Gain test: try 0.2, 0.4 and 0.8 and note when it begins to oscillate.
5. Lighting: repeat near a window, under a lamp and in dim light.
6. Lost target: hide the target and confirm the mount holds still instead of wandering.

What usually goes wrong

Upgrades

• Search sweep: sweep slowly when the target is lost.
• Distance estimate: use blob size to estimate range.
• Mount on a rover: steer the wheels toward the target.
• Lower resolution: trade picture size for speed.

Cost and parts notes

The ₹6,990 total is an illustration and does not include shipping. Use the cost calculator to compare sellers.

Common questions

Last reviewed: November 2026. This is a design worksheet with illustrative costs. It has not been bench-tested by this site; library names, pins and limits must be checked against your board and the current library versions, and measurements from your build are welcome.