The Basics of PWM Signal Generation

Pulse Width Modulation, or PWM, is one of those topics that looks simple on paper and then quietly becomes the most important thing in your project the moment a micro servo motor starts twitching, buzzing, or refusing to hold position. If you have ever wired up a tiny 9-gram servo, fed it a signal from a microcontroller, and watched it slam to one end of its travel for no obvious reason, you have already met PWM — just not on friendly terms yet.

This article walks through the fundamentals of PWM signal generation with a deliberate focus on micro servo motors, because these little actuators are one of the clearest and most demanding real-world applications of PWM. They are unforgiving about timing, sensitive to jitter, and surprisingly picky about voltage levels. Understanding PWM through the lens of a micro servo is a great way to internalize the concepts, because every parameter you tweak has a visible, physical consequence: the horn moves.

What PWM Actually Is

At its core, PWM is a way of encoding information — usually a target position or an average power level — into the timing of a digital square wave. A PWM signal is defined by three properties:

• Frequency: how many complete cycles occur per second, measured in hertz.
• Duty cycle: the percentage of each cycle that the signal spends in its high state.
• Pulse width: the absolute duration of the high portion of each cycle, usually expressed in microseconds.

These three are related. Pulse width divided by period gives you duty cycle, and period is the reciprocal of frequency. For many applications — LED dimming, motor speed control, heater control — duty cycle is the star of the show. For hobby and micro servo motors, pulse width is what matters, and duty cycle is mostly a derived curiosity.

That distinction is worth sitting with for a moment, because it explains a lot of confusion beginners run into. A motor driver that cares about average voltage wants duty cycle. A micro servo wants a specific pulse width in microseconds, and it expects that pulse to arrive at a fairly specific frequency. Mixing up the two mental models is the source of an enormous number of "why is my servo jittering" forum posts.

Why Micro Servo Motors Are a PWM Showcase

A standard analog micro servo — something like the ubiquitous SG90 or its many clones — contains a small DC motor, a gear train, a potentiometer for position feedback, and a control board. That control board does one job: it compares the pulse width it receives on the signal line to the pulse width it expects for the commanded position, and it drives the motor in whichever direction reduces the error.

The conventional contract for these servos is:

• Pulse width of roughly 1000 µs commands one extreme of travel.
• Pulse width of roughly 2000 µs commands the opposite extreme.
• Pulse width of roughly 1500 µs commands center.
• Repeat period of 20 ms, or about 50 Hz.

That 20 ms period is the classic spec, and it is why servo PWM is often described as a 50 Hz signal with a variable pulse width between 1 and 2 ms. The duty cycle in that range is only 5% to 10%, which is a useful sanity check: if you scope a servo signal and see a 50% duty cycle, something is wrong.

The Micro Servo Twist: Tighter Tolerances, Smaller Motors

Micro servos are not just scaled-down standard servos. Their smaller motors, lighter gear trains, and lower torque budgets make them more sensitive to bad signals. A full-size servo might tolerate a sloppy, jittery PWM stream and still hold position reasonably well. A 9-gram micro servo driving a lightweight control surface will often translate every timing hiccup into visible chatter or a faint buzzing sound as the motor hunts back and forth around the setpoint.

They also tend to have narrower usable pulse ranges. Many micro servos will accept pulses beyond 1000–2000 µs, but doing so pushes the internal mechanics against their end stops, which draws excess current and can strip the tiny plastic gears. Respecting the documented range — or better, calibrating your own safe range — matters more with micro servos than with their larger cousins, precisely because there is less mechanical margin for error.

Generating the Signal: From Bit-Banging to Hardware Timers

There are several ways to produce a servo-compatible PWM signal, and the tradeoffs between them are exactly the tradeoffs that determine whether your micro servo behaves.

Bit-Banging in Software

The most direct approach is to toggle a GPIO pin in software: drive it high, wait the pulse width, drive it low, wait out the rest of the 20 ms period, repeat. This works, and it is a fine way to learn. It is also fragile. Any interrupt, any blocking call elsewhere in your program, any garbage collection pause in a high-level environment will stretch or shorten a pulse. Micro servos notice. The result is jitter, and jitter in a position-controlled system means the motor is constantly correcting.

Bit-banging is acceptable for a single servo in a simple loop with nothing else going on. It falls apart quickly once you add more servos, wireless communication, or anything with real-time demands.

Hardware Timers and Compare Registers

The robust approach is to let a hardware timer generate the waveform. You configure the timer's period to 20 ms, set up a compare channel, and write the desired pulse width to a compare register. The hardware handles the toggling with cycle-level precision, immune to whatever your main program is doing. On most microcontrollers, this is a handful of register writes, and it is the correct default for any project that needs reliable servo behavior.

The practical wrinkle is timer resolution. To command pulse widths in fine steps, you need a timer clock fast enough that one tick is a small fraction of your intended resolution. If you want 1 µs resolution on a 20 ms period, you need at least 20,000 counts per period. A 16-bit timer running at a few megahertz handles this comfortably. An 8-bit timer does not, and you will end up with coarse, quantized position steps — which on a micro servo shows up as a visible "notchy" motion rather than smooth travel.

Dedicated Servo Controllers and Libraries

Plenty of projects use a dedicated servo driver chip or a library that wraps the timer configuration for you. These are convenient and often excellent, but it is worth knowing what they are doing under the hood, because when something misbehaves, the fix usually lives in the timer configuration rather than in your application code.

The Details That Bite: Frequency, Jitter, and Voltage

Three practical issues come up again and again with micro servos, and all three are PWM issues at heart.

Frequency Tolerance Is Wider Than You Think — Until It Isn't

Many digital servos and even some analog micro servos will accept frequencies well above 50 Hz, sometimes up to 300 Hz or more, and higher refresh rates can make them feel more responsive and hold position more stiffly. But this is not universal. Older analog micro servos may misbehave or overheat at elevated refresh rates, and mixing servos with different frequency tolerances on the same signal line is asking for trouble. When in doubt, 50 Hz is the safe default, and it is what the datasheet almost certainly specifies.

Jitter Is the Enemy

A micro servo's control loop is a position regulator, and position regulators amplify noise. A pulse that varies by even a few microseconds from cycle to cycle will cause the servo to make small corrections continuously. You may hear it as a faint buzz; you may see it as a slight shimmer in the horn. Eliminating jitter means using hardware timers, avoiding long interrupt-disabled sections, and keeping your signal line short and clean. It also means not sharing a timer between servo generation and something that reconfigures it mid-flight.

Logic Levels and Power Are Separate Problems

The signal line expects a logic-level pulse, typically 3.3 V or 5 V depending on the servo. But the servo's power draw comes from a separate supply, and micro servos can pull surprising current spikes when they start moving or stall. A common failure mode is a servo that behaves perfectly until it moves, at which point the supply sags, the microcontroller browns out or resets, and the PWM signal disappears. The fix is almost never in the PWM code — it is decoupling, a beefier supply, or separating the servo power rail from the logic rail. Keep the grounds tied together, though, or the signal has no reference.

Reading the Signal Back

One underappreciated skill is verifying your PWM output. A cheap logic analyzer turns servo debugging from guesswork into observation: you can see the actual pulse width, the actual period, and any jitter or dropped cycles. If you do not have one, a simple approach is to route the signal into a second microcontroller input and measure pulse width in software, though that measurement is itself subject to the jitter you are trying to detect. For serious work, a scope or logic analyzer is worth the modest cost.

Putting It Together

PWM signal generation for micro servo motors is a small, well-defined problem: produce a repeating pulse, roughly every 20 ms, whose high time encodes position in the neighborhood of 1 to 2 ms, with enough timing precision and stability that a tiny geared motor with a potentiometer does not spend its life hunting. The concepts are simple. The execution is where projects succeed or fail, and the failure modes — jitter, wrong frequency, power sag, out-of-range pulse widths — are all diagnosable once you know what the signal is supposed to look like.

Micro servos are a great teacher for exactly this reason. They respond to PWM with motion you can see and hear, they punish sloppiness immediately, and they reward a clean, hardware-generated signal with smooth, quiet, repeatable positioning. Get the pulse right, and the little motor does exactly what you tell it.