Using Raspberry Pi to Control Servo Motors in Automated Inspection Systems

Automated inspection systems are quietly becoming the backbone of modern manufacturing, agriculture, logistics, and even laboratory research. From checking PCB solder joints on a production line to scanning fruit for surface defects, these systems rely on precise, repeatable motion to position sensors, cameras, and probes. And while industrial servo drives often steal the spotlight, there is a smaller, cheaper, and surprisingly capable hero hiding in the wings: the micro servo motor.

Pairing a Raspberry Pi with micro servo motors is one of the most accessible ways to build a functional automated inspection rig. The combination is inexpensive, well-documented, and flexible enough to handle everything from a simple pan-tilt camera mount to a multi-axis scanning gantry. This article walks through why micro servos deserve serious attention in inspection applications, how to wire and drive them from a Raspberry Pi, and what practical lessons come out of real builds.

Why Micro Servo Motors Fit Inspection Work So Well

The Anatomy of a Micro Servo

A micro servo motor is typically a small, self-contained actuator that bundles four things into a plastic or metal case: a DC motor, a gear train (often nylon or metal), a potentiometer for position feedback, and a control circuit. Most hobby-grade micro servos weigh between 5 and 20 grams, deliver torque in the range of 0.5 to 3 kg·cm, and rotate roughly 180 degrees. The classic SG90 is the poster child, but the MG90S (metal gears), the SG92R, and various digital micro servos offer upgraded durability and precision.

What makes them special is the closed-loop control baked into the package. You send a PWM pulse, and the servo's internal circuitry handles the rest — comparing the potentiometer reading to the commanded position and driving the motor until they match. For an inspection system, that means you get positional repeatability without designing your own feedback loop.

The Characteristics That Matter for Inspection

Three features make micro servos particularly attractive for automated inspection:

Repeatability over raw power. Inspection tasks rarely need brute force. They need the sensor to return to the same angle, scan line, or focal plane over and over. A decent micro servo holds position within a degree or two, which is plenty for camera aiming, mirror deflection, or probe positioning.

Low cost and modularity. At a few dollars apiece, you can afford to build multi-axis rigs — pan-tilt heads, rotating turntables, articulated arms — without blowing the budget. If one fails, you swap it out in minutes.

Small footprint and low power draw. Micro servos run happily off a 5V rail and draw modest current at idle. They fit into tight enclosures, which matters when the inspection head has to get close to the object being examined.

Where They Fall Short — and How to Design Around It

Micro servos are not industrial-grade. They jitter under load, their plastic gears wear, and their potentiometers drift with temperature. The fixes are straightforward: use metal-gear variants for anything that moves constantly, power them from a dedicated supply rather than the Pi's 5V pin, and add mechanical stops or soft limits in software so the servo never slams into its end range. For inspection systems that run intermittently or at moderate duty cycles, these mitigations are usually enough.

Wiring a Micro Servo to the Raspberry Pi

The Power Problem Nobody Warns You About

The single most common failure mode in Pi-servo projects is brownouts. A micro servo can spike to several hundred milliamps when it starts moving, and the Raspberry Pi's onboard 5V regulator is not designed for that. The result is a Pi that reboots mid-inspection, which is exactly the kind of reliability failure an inspection system cannot tolerate.

The fix: give the servo its own power supply. A 5V, 2A wall adapter or a separate UBEC works fine. Connect the servo's ground to both the external supply's ground and the Pi's ground so the PWM signal has a common reference. Only the signal wire goes to a GPIO pin.

Choosing the Right GPIO Pin

Any GPIO pin can generate PWM on the Raspberry Pi, but hardware PWM (available on GPIO 12, 13, 18, and 19 on most models) gives you cleaner, more stable pulses. For inspection work where jitter translates directly into measurement noise, hardware PWM is worth the small extra setup effort. For multi-servo rigs, pigpio's software-timed PWM is an excellent fallback because it handles many channels simultaneously with microsecond resolution.

A Minimal Control Script

The following Python snippet uses gpiozero, which wraps the low-level PWM handling in a friendly API:

python from gpiozero import Servo from time import sleep

servo = Servo(18, minpulsewidth=0.5/1000, maxpulsewidth=2.5/1000)

while True: servo.min() # sweep to one end sleep(1) servo.mid() # center sleep(1) servo.max() # sweep to the other end sleep(1)

For finer control, servo.value = 0.35 sets an intermediate position. If you need tighter timing or more channels, pigpio lets you set pulse widths directly in microseconds, which is the better choice when you are calibrating an inspection axis against a physical reference.

Building an Inspection Rig Around Micro Servos

A Pan-Tilt Camera Head for Surface Inspection

The simplest useful inspection system is a camera on a two-axis pan-tilt mount. One micro servo handles azimuth, another handles elevation, and the Pi captures frames at programmed angles. This setup works well for inspecting curved surfaces — bottle caps, lenses, machined parts — where a single fixed camera would leave blind spots.

The practical details matter. Mount the camera as close to the servo's rotation axis as possible to minimize the arc the lens travels. Use metal-gear servos if the camera is heavy, and add a short settling delay (100–200 ms) after each move before capturing, because micro servos overshoot slightly and oscillate before locking in.

A Rotating Turntable for 360-Degree Scans

Continuous-rotation servos (or standard servos modified for full rotation) can drive a small turntable that presents each face of an object to a fixed sensor. This is ideal for inspecting cylindrical parts, fasteners, or produce. The Pi commands a step, waits for the servo to settle, triggers the camera, and repeats. Stitch the frames afterward, or run a defect-detection model on each one.

One caveat: continuous-rotation servos sacrifice positional feedback, so you cannot command an exact angle. If your inspection needs indexed positions, use a standard servo with a geared-down turntable, or add a hall-effect sensor or optical encoder as an index marker.

A Linear Scan Axis Using a Servo-Driven Linkage

For flat objects — PCBs, printed labels, fabric swatches — a servo driving a belt or a four-bar linkage can move a sensor in a straight line across the surface. The Pi steps through positions, capturing a narrow strip of data at each stop. This is a poor man's line-scan camera, and with a decent micro servo and careful calibration, it produces surprisingly usable results.

Software Patterns That Make Inspection Reliable

Calibration Beats Assumption

Never trust the nominal pulse widths printed on a servo datasheet. Every unit varies by a few percent. Write a calibration routine that sweeps the servo to its mechanical limits (gently), records the pulse widths at which it stalls or hits a hard stop, and stores safe operating bounds in a config file. Your inspection positions should be defined relative to those calibrated bounds, not to abstract 0–180 degree values.

Move, Settle, Capture

The core loop of any servo-driven inspection system is: command a position, wait for settling, trigger the sensor, store the result. Encode this as a reusable function so every axis behaves consistently. The settling time should be tuned per servo and per load — a bare SG90 settles in tens of milliseconds, while a camera-laden MG90S may need a quarter second.

Error Handling and Watchdogs

If a servo jams or a wire comes loose, the Pi should notice rather than blindly continuing to capture garbage data. Add a watchdog that checks whether commanded moves complete within an expected time window, and log any anomalies. In a production inspection context, a flagged frame is far better than a silently wrong one.

Real-World Considerations and Upgrades

Micro servos shine in prototyping, but production inspection systems often need more. The natural upgrade path runs from micro servos to standard-size servos to stepper motors to closed-loop industrial servos, with each step trading cost for torque, precision, and durability. A sensible approach is to prototype the entire inspection workflow with micro servos on a Raspberry Pi, validate the sensing and software stack, and only then invest in heavier actuators for the final build.

It is also worth noting that the Raspberry Pi ecosystem has matured around this exact use case. Libraries like gpiozero and pigpio are stable, camera modules are well-supported, and the community has published countless pan-tilt and turntable designs. The barrier to entry for a competent automated inspection prototype is now measured in afternoons, not weeks.

Micro servo motors are not glamorous, and they will never replace industrial motion hardware in high-duty-cycle environments. But for the vast middle ground of inspection tasks — laboratory setups, small-batch quality checks, educational demos, proof-of-concept rigs — they deliver an unbeatable combination of precision, price, and simplicity. Paired with a Raspberry Pi, they turn a pile of parts into a working inspection system faster than almost any other actuator choice. The next time you sketch an inspection rig on a napkin, start with the little servo in the corner of the parts bin. It will probably get you further than you expect.