Controlling 16 Servo Motors with Arduino and PCA9685 Driver

Hobby servo motors are radio-controlled devices with three wires: brown (ground), red (5V power), and orange (control signal). Internally, they contain a DC motor, potentiometer for position sensing, gearbox, and a microcontroller-based feedback system. The potentiometer measures the actual position, while the controller compares it to commanded values from incoming PWM pulses. This closed-loop system ensures the motor reaches and maintains the desired position. The motor can rotate approximately 180 degrees (some models up to 270 degrees) and requires continuous 5V power for operation.

A servo motor is a rotary actuator capable of precise 180-degree positioning with built-in feedback. It requires three connections: Vcc (red), GND (brown), and signal (orange/yellow). The signal wire connects to a digital pin (e.g., pin 9), while Vcc connects to 5V and GND to ground. A potentiometer controls the position by providing an analog input (0-1023) that maps to the servo's 0-180 degree range. Proper wiring involves connecting the potentiometer's middle pin to an analog pin (A0), one outer pin to 5V, and the other to ground.

A servo motor is a closed-loop control system that uses pulse-width modulation (PWM) signals to achieve precise angular positioning, where the control circuit converts the PWM signal into a DC voltage through low-pass filtering, compares it with feedback from a potentiometer sensor, and drives an H-bridge to rotate the motor until the actual position matches the commanded position; homemade servos can be created by modifying standard RC servos by removing hard stops and the potentiometer linkage, or by building custom circuits using RC filters, comparators, and H-bridges to convert conventional DC motors into controllable servos with adjustable speed and torque characteristics.

This section provides detailed instructions for wiring a servo motor to an Arduino. A servo motor has three wires: ground (GND, typically brown or black), power (VCC, typically red), and signal (typically orange or yellow). The ground wire connects to Arduino's GND pin, the power wire connects to 5V (not 3.3V, as servos require 5V), and the signal wire connects to the Z+ pin on the CNC Shield, which corresponds to Arduino pin 11 (the PWM spindle control pin). The presenter recommends researching servo motor operation before attempting this connection, and suggests that beginners should stick with stepper motors for simpler implementations. Larger servos may require a driver amplifier instead of direct Arduino connection.

A servo motor has three wires: signal (orange, white, or yellow), 5V power (red), and ground (black). The signal wire connects to a microcontroller input. The signal is a TTL-level digital signal (5V) that controls an internal driver stage. The servo contains an internal motor connected to a gear reduction system.

PWM is a method where electrical high voltage pulses vary from 0% to 100% duty cycle. In PWM, the width of the electrical pulse determines the encoded information. In the RC hobby, PWM pulses range from 1,000 to 2,000 microseconds. The pulse is never at 0% duty cycle because servos require the high voltage pulse to receive energy for holding position. If duty cycle drops too low, servos lose authority to maintain their position. The pulse width directly corresponds to the throttle value being communicated.

PWM (Pulse Width Modulation) is a square wave signal used to control servo motor angles. The duty cycle of the PWM signal determines the angle of the servo motor. As the duty cycle increases, the servo angle increases, and as the duty cycle decreases, the servo angle decreases. The frequency and duty cycle range of the PWM signal are specified in the servo motor's datasheet. The PWM signal is generated by a microcontroller such as Arduino, PIC, or Raspberry Pi, which can output PWM signals to control the servo motors.

PWM (Pulse Width Modulation) converts analog signals to digital signals that electronic control units can process. It uses rapid on/off switching to create a square wave signal. When the switch is closed, the load receives full voltage (12V); when open, it receives zero voltage. The period is the time to complete one full cycle. Duty cycle is the percentage of time the signal is 'on' during one period. A 50% duty cycle means the signal is on for half the period and off for the other half. This determines the average voltage delivered to the load. The average voltage equals the duty cycle percentage multiplied by the supply voltage. For example, a 50% duty cycle with 12V supply produces 6V average. This is analogous to filling a bucket with water: opening a tap for half the time collects half the water.

PWM is a digital technique for achieving analog results by creating square waves with variable pulse widths. The duty cycle represents the percentage of time a pulse remains high during one complete cycle—for example, a 20% duty cycle means the pulse is high for 20% of the time and low for 80%. Implementing PWM requires four key components: a counter to track position in the cycle, a clock signal for synchronization, an output signal to drive loads, and a comparator to determine when to switch states. The counter increments on each clock cycle and resets when reaching a maximum value (e.g., 100). When the counter value is below a threshold (e.g., 20), the output is high; when it exceeds or equals the threshold, the output goes low. At high frequencies, rapid switching creates the illusion of constant brightness, where higher duty cycles produce brighter apparent output.

This section explains duty cycle control as a method of achieving lower average power output by cycling a load on and off repeatedly. For example, a 1,200W burner at 50% duty cycle delivers 600W average power. The video distinguishes this from pulse width modulation (PWM), noting that while similar in effect, PWM serves broader signaling purposes (like controlling servo motors) whereas duty cycle control focuses solely on power delivery. The simmerstat represents a 100-year-old implementation of duty cycle control using purely mechanical means, contrasting with modern electronic implementations.

The I2C (Inter-Integrated Circuit) bus is a two-wire serial communication protocol using SDA (Serial Data) and SCL (Serial Clock) lines, where one device acts as Master and others as Slaves; communication begins with a START condition (SDA transitions from high to low while SCL is high), followed by a 7-bit device address and a read/write bit, with each byte acknowledged by the receiving device through pulling the SDA line low during the clock pulse, and ends with a STOP condition (SDA transitions from low to high while SCL is high).

I2C uses two lines: SDA (Serial Data) and SCL (Serial Clock). The CPU acts as master, sending commands to slave ICs. Each slave has a unique address (code). When the CPU sends a command, only the matching address responds and performs the action. Pull-up resistors (2.2K ohms) connect SDA and SCL to 1.8V, maintaining signal strength over distance. This allows one CPU to efficiently control multiple ICs through shared communication lines.

The I2C (Inter-Integrated Circuit) bus is a two-wire serial communication protocol developed by Philips in the 1980s for connecting integrated circuit devices, using SDA (Serial Data) and SCL (Serial Clock) lines with a Master-Slave architecture where the Master generates clock signals and initiates communication, supporting hot-plugging of devices and capable of connecting multiple devices with 7-bit addressing (up to 100 devices) at speeds up to 100 kbps, with data transmission occurring only when SCL is low and using Start/Stop conditions for communication framing.

I2C (Inter-Integrated Circuit) is a serial communication protocol that enables multiple devices to communicate over just two wires (SCL for clock and SDA for data), using a master-slave architecture where the master initiates communication by sending a device address followed by register addresses and data bytes, with each 8-bit sequence followed by an acknowledge bit from the slave device; practical implementation with Arduino involves using the Wire library to send device addresses and register addresses, then reading the returned data bytes.

I2C (Inter-Integrated Circuit) is a two-wire serial communication protocol originally developed by Philips in 1982 for television circuits, now widely used for connecting microcontrollers, sensors, and displays. It operates on a master-slave architecture where the master device generates the clock signal and initiates all communications, while slaves respond to the master's commands. The protocol uses only two wires: SDA (Serial Data Line) and SCL (Serial Clock Line), with pull-up resistors ensuring proper signal integrity. Each slave device has a unique 7-bit address, allowing up to 128 devices on a single bus. Using the Arduino Wire library, you can easily implement I2C communication between two Arduinos by connecting their grounds together and tying their SDA and SCL lines together. The master can send data to the slave using Wire.beginTransmission() and Wire.write(), while the slave receives data through the onReceive() function and can respond using Wire.write() when the master requests data.

This section explains the power requirements of servo motors and why external power supplies are necessary. Servo motors draw varying current: idle state ~10mA, normal movement 100-250mA, stalled conditions up to 360mA. Small servos like the SG90 may work directly from the microcontroller's 5V pin, but larger servos require external power supplies to prevent microcontroller damage. The section emphasizes that the microcontroller should only handle control signals while dedicated power supplies provide the necessary current for motor operation.

Servo motors require external power supply because they consume significant current (200-300mA per servo). A single SG90 can be powered directly from a microcontroller's 5V output, but connecting multiple servos exceeds the microcontroller's current capacity. An external power source should supply both the microcontroller and the servos, with the power supply capacity determined by the number of servos operating simultaneously.

When using multiple servos (such as four SG90 servos), an external power supply is required because the Arduino's 5V pin cannot handle the combined current draw. To create an external power supply, strip one end of a USB cable and connect the red wire (positive 5V) and black wire (ground) to a breadboard. Use a USB-A to USB-C converter connected to a quality 5V 3A adapter. Always ensure exposed wires do not touch each other to prevent short circuits.

Servos require separate power from the microcontroller board because they draw significantly more current than the Raspberry Pi or Arduino can safely provide. The servo driver board has dedicated power connections (labeled voltage positive) that must be connected to an external power source (such as a 6V battery pack), while the ground connection is shared between the controller and servos. This separation prevents power fluctuations from affecting the microcontroller's operation.

Large servo motors require more power than a microcontroller's built-in power supply can provide. An external power supply (such as batteries or a wall adapter) must be used to power the servo motor separately from the microcontroller. The microcontroller only needs to provide the signal to control the motor, not the power.