Skip to content

PWM servo setup

Back to the getting-started path

This page is the other route entry, alongside Bus servo setup, for exact models that the formal documents confirm as PWM-controlled. A PWM servo has no communication to establish, and no bus ID or baud rate, so power-up preparation and the first motion both happen on this page.

Programmability, the way parameters are written and the neutral calibration for PWM servos are in "Programmable models: set travel limits first" below; tools and software are in Debug Boards and Adapters.

Gather parts

For the power supply, harnesses and terminal cables see the checklist in Power and Wiring; this page lists only the PWM-specific items.

  • One PWM servo with an exact, confirmed model (compare looks and specifications in PWM series specifications)
  • A signal source that can output the model's period and pulse width (an MCU's PWM output or an RC receiver)

Wiring composition and supply capacity are covered in Power and Wiring.

Programmable models: set travel limits first

Whether a model is programmable is read from the factory documents and the model page — a model whose page says "comes with the FRS dual-mode switching board" is programmable; the criteria and tools are in Debug Boards and Adapters. For a programmable model, set the travel limits before fitting it into the mechanism. Two tools, pick one:

  • FE-FRS1-C001 offline button calibration: no computer needed — press L at the start point, R at the end point and P to confirm
  • FE-SCPC-C003 connected to a computer, set up with the bundled host software

The neutral position follows the factory calibration. Non-programmable models skip this step: the controller limits travel by limiting the pulse width instead.

Information to gather before power-up

Required information What to confirm
Documentation · Exact model and behaviour Suffix, position or speed control, applicable document revision
Physical layer · Supply and connection Allowed input range, current requirement, connector orientation, pinout, common ground
Physical layer · Mechanical boundaries Permitted travel, direction, clearing the motion envelope, load condition and how power is disconnected
Signal layer · Control signal Voltage level, period, pulse-width limits, neutral/stop value, signal-loss behaviour (how the servo moves when the signal wire is disconnected)

Find your model in Product Selection, then open the model page: "Official model specifications" holds the period and pulse width, and "Resources and document status" shows whether the pinout and the other documents are complete. Model documents usually give the pulse width in µs (1 ms = 1000 µs); convert before comparing with the ms notation used here.

0.5 ms 1.5 ms Neutral / stop 2.5 ms T (period) Pulse width sets position — widths not to scale; values follow the model's documentation

Figure 1 (PWM · Pulse-width timing): the pulse width sets the position; neutral and the stop value are the same step, and the exact values follow the model's documentation.

Where the signal comes from

This route has no host software generating the signal for you: the PWM wave comes from one of the two sources below. Both share the same key points — the period is fixed and only the pulse width changes (duty cycle = pulse width ÷ period) — and the pulses must keep repeating: sending one and stopping is the same as disconnecting the signal wire, and the servo's behaviour is in step 5 of "First motion check" below.

  • MCU PWM output: an Arduino, ESP32, STM32 and so on outputs through a PWM peripheral; take the period from the documents and change only the pulse width while running.
  • RC receiver: the servo channel of an RC receiver already outputs servo pulses, so no programming is needed; just connect the signal wire and the power wires. A receiver channel usually has limited current capability, so a high-power servo needs its own supply, sharing ground with the receiver.

Either way, the signal level and the common ground must meet the model's requirements.

First motion check

The 7 steps below fall into three blocks: steps 1–3 are no-load and non-driving — wiring, no-load setup and signal configuration are finished with the servo not moving; steps 4–6 are small live tests — starting from one small offset, verifying direction, range, signal-loss behaviour and the pulse-width limits one by one; step 7 is installation — fit the servo into the mechanism only after every test passes.

  1. Wire with the power off, keeping the MCU's PWM output disabled; confirm polarity, common ground and signal level from the formal documents.
  2. Run the servo with no load (remove the load), leave room for any power-up movement, and make sure you can cut the motor power immediately.
  3. Configure the signal source with the confirmed period and neutral/stop value. The neutral/stop value is only the signal reference step: for a position-control servo it holds the neutral position, not "zero angle"; for a speed-control servo this step is what stops the motor.
  4. Output the neutral/stop step first and confirm the servo is still, then deviate slightly to one side and check whether the direction and range match the documents.
  5. Confirm the signal-loss behaviour from the documents and test it once: disconnect the signal wire and watch whether the servo holds, returns to neutral, or switches the output off.
  6. Make small changes within the documented pulse-width limits and record direction, response and anomalies.
  7. Once every test passes, fit the servo into the mechanism — after installation, if the signal wire comes loose you must already know how it will move.
1 Hold 2 Return to neutral 3 Output off SIGNAL OUTPUT Behaviour after signal loss — confirm by testing your own model

Figure 2 (PWM · Signal-loss behaviour): the three common outcomes after the signal wire is disconnected (hold / return to neutral / output off); handle whichever one you actually measure.

How to send the signal in code

Whichever MCU and platform you use, the program does the same thing: output a pulse matching the target position within a fixed period, and keep repeating it. A PWM servo receives no commands and reads back no status — control is open loop, and whether the position was reached can only be confirmed by observation or an external sensor. That is also why it needs no SDK: with no protocol, there is no library to wrap.

Only two values are set in code, both taken from the model's documents:

  • Period: the interval between pulses. A common ≈20 ms with a 0.5–2.5 ms pulse width (≈1.5 ms neutral) can serve as a reference for understanding and initial values; the values differ between models, and the official values follow the model's documentation.
  • Pulse width: the neutral/stop value and the limits; changing the pulse width while running changes the position.

On the MCU side, anything that produces a stable periodic pulse will do; pick the peripheral or library that suits your platform (most platforms ship a servo library, such as Arduino's Servo, or you can drive a timer PWM output directly). Whichever library you use, compare the period and pulse-width range it covers against the model's documents before deciding whether it can be used.

One timing point that is easy to overlook: at power-up, reset or program start the MCU may not be outputting pulses yet, and that gap is the same as disconnecting the signal wire — the servo behaves per the signal-loss behaviour in step 5. Before fitting it into the mechanism, run one full start-up on the bench with no load.

Records to keep afterwards

Record the model and suffix, the controller and toolchain, the power supply, the pinout drawing revision, the actual period / pulse width, the signal-loss behaviour, the no-load result, the stop method and the date. Defaults from another model or from a general-purpose library are not a validation record for this model. A PWM model's validation record stays on this page and is not merged into the bus SDK flow; when you switch to a bus model, start again from Bus servo setup.

Next steps