Arduino Servo Motor Control Tutorial: PWM & Potentiometer

The PCA9685 is a 16-channel servo driver that enables Arduino to control multiple servos simultaneously by providing dedicated external power, as servos require more current than Arduino can supply directly; the driver connects to Arduino via I2C communication using SDA (A4) and SCL (A5) pins, with VCC and ground connections, and servos are assigned to channels starting from 0, allowing independent control of each servo through the Arduino code.

The PCA9685 is a 16-channel PWM driver that enables precise control of multiple servo motors using I2C communication, freeing up the Arduino microcontroller to perform other tasks; it can control up to 16 servos with a single board or chain multiple boards together for 992 total outputs, with each board having a unique I2C address configurable via solder jumpers, and requires external 5V power for the servos while the VCC pin only powers the driver chip.

The Raspberry Pi has only one native PWM output channel (GPIO18), which limits the ability to control multiple servo motors simultaneously. To overcome this limitation, the PCA9685 16-channel 12-bit PWM/Servo Driver can be used via I2C communication, allowing a single Raspberry Pi to control multiple servo motors by providing additional PWM channels through the I2C interface.

This tutorial demonstrates how to control up to 16 servos simultaneously using a PCA9685 I2C PWM controller board connected to a Raspberry Pi Pico running MicroPython. The PCA9685 board uses the I2C protocol (requiring only two wires: SDA and SCL) to manage all servos, with each servo assigned to one of 16 channels (numbered 0-15). Key implementation details include understanding number bases (hexadecimal for device addresses like 0x40), proper power supply (external 5V source, never from Pico's 5V pin), and using MicroPython libraries (pca9685.py and servo.py) to create servo objects that accept position inputs in degrees, radians, or microseconds. The I2C bus can be scanned to verify device detection, and common troubleshooting includes checking pin assignments, bus IDs, and ensuring correct device addresses.

The ultrasonic sensor connects with power to connection point, signal to Arduino pin 12, echo to Arduino pin 10, and ground to ground. The servo motor connects with power to 3.3V, signal to Arduino pin 9, and ground to ground. The obstacle avoidance program: includes servo library, declares variables, moves forward, stops if distance < 35cm, rotates servo to 0° (right) and 180° (left) to measure distances, moves backward 4ms, then turns right if right distance > left distance, otherwise turns left, then resumes forward movement.

Implement obstacle avoidance by combining ultrasonic sensor with servo motor control. Set distance threshold (e.g., 100cm) for obstacle detection. If distance < threshold, move servo to 90 degrees to raise barrier. If distance >= threshold, return servo to 0 degrees. Use delay() to control movement speed. Adjust threshold and timing values based on application requirements. This demonstrates practical sensor-based automation implementation for barrier control systems.

An obstacle-avoiding robot can be constructed using an Arduino Uno microcontroller, an HC-SR04 ultrasonic sensor for distance detection, an SG90 servo motor to rotate the sensor, and an L293B motor driver to control geared motors; the system works by continuously measuring distance to obstacles, stopping when within a programmed threshold (such as 15 centimeters), and then rotating the sensor to scan for clear paths before resuming forward movement.

This video demonstrates how to connect an HC-SR04 ultrasonic distance sensor to an Arduino Uno and use its measurements to control a servo motor, showing the complete workflow from hardware connections (VCC, ground, trigger, and echo pins) through software implementation using the NewPing library to read distances in centimeters, then mapping those distances to servo angles (e.g., 2-15cm mapped to 15-165°) to create a robot obstacle avoidance system; the project highlights the importance of separating servo power from the Arduino for better performance and managing sensor data noise through appropriate delay settings.

This tutorial demonstrates how to use Tinkercad to create an electronic circuit where an ultrasonic sensor (HC-SR04) measures distance by emitting high-frequency sound waves and measuring the time it takes for the echo to return, then uses that data to control a servo motor's position—opening it when an object is within 50 centimeters and closing it when the object moves away, with LED indicators showing the current state.

Microstepping divides each full step into smaller increments—standard 16x microstepping provides smoother motion than full-step operation, while advanced 256x microstepping enables extremely precise positioning essential for applications like camera movement. StealthChop technology dramatically reduces audible noise to nearly imperceptible levels while simultaneously stabilizing the system by minimizing vibrations. Together, these techniques transform stepper motor operation from noisy, vibrating movements to smooth, silent precision positioning suitable for demanding applications.

Stepper motors are brushless DC motors designed for precise positioning. They have stator and rotor teeth arranged in specific patterns, with two main coils (A and B) controlling movement. Each coil energization moves the rotor by a fixed angle (step angle). For a 17HS motor, 200 steps per rotation means 1.8 degrees per step. Smoother rotation is achieved by energizing adjacent coils simultaneously, halving the step angle. Microstepping further reduces step size. Controllers like A4988 or TMS2209 manage coil sequencing.

Field Oriented Control (FOC) is a sophisticated motor control technique that regulates brushless motor torque by precisely controlling the current in each phase, using encoder feedback to keep the electromagnetic force vector aligned with the rotor's position for maximum efficiency; this involves converting measured phase currents into a stationary reference frame, applying PI controllers to regulate torque-producing and non-torque-producing currents, then transforming back to phase voltages and generating PWM signals through a full bridge inverter.

Brushless motors eliminate the commutator, enabling higher current and power output. Stepper motors use 4-6 wires with two coils for precise positioning, taking steps by sequentially energizing coils. The Troyka Stepper driver module manages step, direction, and power signals. Brushless constant rotation motors connect directly to coils for higher power. Rotor position detection uses Hall sensors or voltage from free coils. PWM at 50 Hz controls all brushless systems, with center position at 0.5ms signal duration. Servo motors use similar PWM principles for angular positioning control.

The AccelStepper library provides advanced stepper motor control features including acceleration and deceleration profiles. To use it with a motor driver: create a stepper object specifying the driver type (1 for our modules), pulse pin, and direction pin. Example code includes functions like moveTo() and run() for automated movement. The bounce example demonstrates moving between limits with smooth acceleration and deceleration. Microstepping settings affect both speed and torque - different microstepping modes provide different torque characteristics. This library simplifies complex motor control tasks compared to writing raw pulse generation code.

Proportional (P) control creates smooth motion by calculating error between current and target positions, then applying corrective force proportional to that error. A velocity profile with exponential decay creates natural-looking movement that starts quickly and slows down over time, mimicking biological motion patterns. This approach prevents jerky movements common in naive servo control.

Motion smoothing in robotics is achieved through code-based filtering that reduces jitter and creates smooth acceleration and deceleration. The Arduino 'smooth' function acts as a filter that processes input values before they reach actuators. The algorithm works by dividing the difference between current and target values into smaller increments, causing the output to move in progressively smaller steps as it approaches the target. This creates a natural deceleration effect that smooths out mechanical jitter.

Trajectory generation involves creating sets of positions, velocities, and accelerations matched with time arrays to command smooth, feasible motions for robots; unlike direct position commands which produce jerky and potentially damaging movements, trajectory generators create minimum-jerk profiles that match velocity and acceleration constraints at waypoints, significantly improving motion control performance and allowing better utilization of control gains across all joints of a robotic system.

S-curve generation creates smooth motion profiles by accelerating at a constant rate, moving at constant speed, then decelerating to exactly hit the target position. The curved acceleration and deceleration phases create an 'S' shape in the velocity profile. This prevents jerky movements and ensures precise positioning without excessive stress on mechanical components.

Profile PID controllers are used to manage acceleration profiles in robotic arms to prevent mechanical failures. When moving from a scoring position down to an intaking position, gravity adds acceleration that can cause belt skipping. The profile PID controller limits acceleration to prevent this skipping. If the arm does skip during a match, current limiting can be used to reset the arm by sending each stage to known reference points where current spikes indicate exact positions.