Introduction to robotics: types of motors

A motor is what turns code into motion. Everything else depends on the choice of motor: what power supply is needed, which controller, which bus to communicate with it, how much a joint will cost, and whether the robot can even stand up. This article is an overview map: how the main types of motors are built, how to power and control them, where to buy them, and what to choose for three typical tasks—a power platform from 100 kg, a walking robot up to 100 kg, and a wheeled robot up to 30 kg.

Prices are approximate as of September 2026, taken from store websites via the links. In different regions, shipping, VAT, and duties are added.

1. Basic concepts: torque, KV, gearbox, FOC
2. Map of motor types
3. Brushed DC motors
4. Hobby servos and smart servos
5. Brushless (BLDC) for drones
6. Gimbal motors (direct drive)
7. BLDC + encoder + planetary gearbox + ODrive
8. QDD and integrated actuators
9. Stepper motors
10. Hub motors
11. Power: AC servos, worm, linear
12. Summary table
13. Software control
14. Many motors: buses and wiring
15. Power supply
16. Scenarios: 100+ kg, walking, wheeled

Basic concepts

To read datasheets, a dozen terms are enough.

Motor type map

Roughly all motors for robots are divided along two axes: whether there are brushes (brushed or brushless), and how much integration is in the housing (bare motor → motor with gearbox → motor with gearbox, encoder, and driver, communicating over a bus). The more integration, the more expensive the unit, but the fewer wires and less debugging.

Brushed DC motors

Brushes switch the current, not the field rotation with the shaft

The stator magnets are stationary: the field in the gap is directed from N to S. The windings and copper commutator plates rotate with the shaft, but the brushes remain on the housing. When another plate comes under the brush, the current path changes. Therefore the total field of the windings remains roughly perpendicular to the stator field, even though the coils themselves have already turned. The torque continues to pull the shaft in one direction.

The oldest and simplest type. Connect it to a battery—it spins, reverse the polarity—it spins the other way. A bare brushed motor is too fast (5–15 thousand rpm) and weak, so for robots you almost always buy a gear motor: motor + metal gearbox + optionally a Hall encoder on the shaft.

• Voltage 6–24 V
• Current 0.1–10 A (stall current up to 20+ A)
• Gear ratio 10:1 – 300:1
• Torque 0.1–10 N·m at output
• Efficiency 40–70% with gearbox
• Brush lifespan ~1000–3000 h

Controllers and libraries

• H-bridge drivers: DRV8871 / TB6612FNG (up to ~1-3 A), Cytron MDD10A / MDD20A (10 / 20 A per channel), RoboClaw (2x15 - 2x160 A, counts encoders and handles PID itself, has Python and ROS drivers), Sabertooth. It's better not to use the old L298N: it loses 2-4 V across itself and gets hot.
• Software: on Arduino/ESP32 it's just analogWrite() + two direction pins; encoders - the Encoder library or ESP32 hardware counter (PCNT). For ROS 2 - ros2_control with diff_drive_controller.

Where to buy

• Pololu 37D - classic: 12 or 24 V, from 6.3:1 to 150:1, with encoder; 30:1 gives 330 rpm and ~14 kg·cm at 12 V. About $40-60.
• goBILDA Yellow Jacket - planetary gearmotors with built-in encoder, $54.99; convenient mounting ecosystem.
• AliExpress: JGB37-520, JGA25-370 series with encoder - 8-15 €, but quality varies greatly.

Hobby servos and smart servos

A servo is a brushed (less often brushless) motor with a gearbox and an angle sensor in a single housing. You say “move to 90°” — it moves and holds. The gearbox is usually very large, from 30:1 in fast servos to 300:1 in high-torque ones, so the torque is decent, but you can't turn the output by hand, and the gears are noisy.

Analog and digital

Analog servos control the motor at the input signal frequency (50 Hz): softer, quieter, but with a “dead zone” and worse holding.Digital process the same PWM signal with a microcontroller and send pulses to the motor hundreds of times per second: more precise, hold position better, but consume more power and have a characteristic whine. From a software perspective, there is no difference — both are controlled the same way.

Smart servos via bus (serial bus servo)

The next level: instead of PWM — half-duplex UART or RS-485, each servo has its own ID, all are connected in a daisy chain on a single cable. You can not only set the angle, but also read the current angle, current, temperature, voltage; there is a wheel mode and a torque limit mode. Popular open-source robotic arms are built on such servos LeRobot SO-ARM100/101.

• Hobby: 4.8-8.4 V
• Bus: 7.4-14.8 V
• Torque 0.2-6 N·m (2-60 kg·cm), brushless up to 50+ N·m
• Angle 180°, 270° or 360° + wheel mode
• Current up to 2-3 A per servo at stall

Where to buy

• Feetech STS3215 (12 V, 30 kg·cm, magnetic encoder) - about $16; the same one from Waveshare as ST3215 - $21.90. There are also brushless versions there with 450-1000 kg·cm for $399-650.
• ROBOTIS Dynamixel - the benchmark for smart servos with excellent documentation: XL430 from ~€50-60, X/XM series hundreds of dollars, Pro - thousands.
• Hobby servos: MG996R (clone, €3-5), Savöx, Hitec, KST - from €20 to €100+.

Controllers and libraries

• Hobby servos directly: Arduino Servo, ESP32 ESP32Servo. More than 4-6 servos - PCA9685 board (16 channels via I²C, ~€5) + Adafruit PWM Servo Driver or adafruit-circuitpython-servokit on Raspberry Pi.
• Dynamixel: Dynamixel SDK (C++, Python, ROS 2), U2D2 adapter.
• Feetech: SCServo SDK from the manufacturer, driver in LeRobot; adapter - Waveshare Bus Servo Driver Board or any USB-UART with half-duplex circuit.

Brushless (BLDC) motors for drones

A brushless motor is an 'inside-out' brushed motor: the windings are stationary, the magnets rotate, and the controller switches the current. This results in high efficiency (80-90%), no brush wear, and huge specific power. Drone motors are optimized for high RPM with a propeller, so they have a high KV (900-2500), and for robots they are used either with a gearbox or low-KV 'fat' models are chosen (5010, 6374, 8308, 8318).

• Designation 2207, 5010, 8308 = stator diameter × height in mm
• KV 50-2500
• Voltage 2S-12S LiPo (7.4-44 V)
• Current 10-80 A
• Power 100 W - 3+ kW

How three sine waves rotate the magnetic field

A coil on a stator tooth is an electromagnet. The controller applies voltage to it (actually a fast PWM, whose average is a sine), and due to inductance, the current in the coil rises smoothly and follows this sine wave. Current in one direction makes the tooth tip an S pole, in the other direction an N pole, and the pole strength is proportional to the current. Three coils are placed 120° apart, their fields add up as vectors—and if the currents are also phase-shifted by 120°, the sum is a single field of constant strength, which rotates smoothly. The rotor magnet follows it.

Press 'Pause' and move the angle slider to examine individual moments. Switch the mode to compare FOC with a simple ESC.

Controllers

• ESC for drones(firmwares BLHeli_32, Bluejay, AM32) – controlled by PWM, DShot, PWM. Speed only, no position. 10-40 €.
• VESC- open-source controller for electric skateboards and robotics: FOC, Hall sensors or encoder, CAN, UART; 50-200 € at Flipsky, Trampa, MakerX. Excellent for wheels.
• FOC drivers for joints- ODrive, moteus, Tinymovr, SimpleFOC: see the following sections.

Where to buy: T-Motor(including the series for robots), iFlight, BrotherHobby, Flipsky (63xx motors for skateboards), AliExpress (Eaglepower 8308/8318, Maytech).

Gimbal motors: direct drive without gearbox

These are BLDCs wound with thin wire and a high number of turns: phase resistance 5-15 Ohm instead of 0.05-0.2 Ohm for drone motors. They are slow and weak (usually 0.05-0.3 N·m), but can be powered with low current, smoothly hold any angle, and rotate without a single gear. The combination of “motor directly on the joint” is called direct drive.

• Typical: GM2804, GM3506, GM4108, GM5208
• Phase resistance 5-15 Ohm
• Current 0.3-2 A
• Torque 0.05-0.5 N·m
• 12-24 V

Controllers and prices

• Tinymovr R5.4(now the Motionlayer brand) - FOC controller the size of a motor, mounts directly on the rear cover, built-in encoder, CAN; €88, starter kit - €124. Python library tinymovr and GUI Studio.
• SimpleFOC - open-source FOC library for Arduino/STM32/ESP32 and cheap SimpleFOC Shield / Mini boards (10-30 €). The best way to get hands-on experience with FOC.
• Motors themselves: iFlight iPower GM series, T-Motor GB series, AliExpress - 20-60 €.

BLDC + magnetic encoder + planetary gearbox + ODrive

The classic approach for DIY walking robots since the MIT Mini Cheetah: take a thick low-KV BLDC, glue a diametrically magnetized magnet to the shaft, place a magnetic encoder board opposite, add a 3D-printed or purchased planetary gearbox 6:1 - 10:1, and control everything via an FOC driver. You get a joint similar to a commercial QDD, but 1.5-3 times cheaper and fully under your control. A classic breakdown of such a design is Ben Katz's master's thesis «A low cost modular actuator for dynamic robots» (MIT, 2018).

What makes up the price

QDD and fully integrated actuators

Quasi-direct drive (quasi-direct drive) is a compromise between direct drive and servo: a powerful flat BLDC with a small gearbox 6:1 - 10:1. This is enough to multiply the torque to the required values, but the gear ratio is still low enough that the joint remains backdrivable: you can turn it by hand, and the driver "feels" the external force through the current—without a separate torque sensor. For walking robots, this is critical: the leg softly absorbs the impact with the ground, instead of breaking gears like a servo.

A fully integrated actuator is a QDD (or planetary with a higher gear ratio), in which the motor, gearbox, encoder, sometimes a second output encoder, driver, and temperature sensor are all assembled into one "thick cylinder." Only two power wires and a pair of CAN wires come out. All motors on the leg are daisy-chained to a single bus.

Planetary gearbox, gear ratio, and joint transparency

The sun gear is mounted on the motor shaft, the ring is stationary, and the output is taken from the carrier: i = 1 + Zring / Zsun. The load is shared by three planet gears, so one stage is compact and can handle high torque. Change the gear ratio and push the output "by hand": you can see how the force increases and how sensitivity to the outside world disappears.

• Power supply 24-48 V
• Nominal 3-40 N·m, peak 9-120+ N·m
• Mass 0.3-2.5 kg
• Speed 100-500 rpm at output
• CAN 1 Mbit/s or CAN-FD, sometimes RS-485 / EtherCAT
• Modes: position, speed, torque, 'MIT mode' (impedance)

Popular manufacturers and prices

RobStride prices in yuan - the official manufacturer price list; European resellers are noticeably more expensive. RobStride also offers the RS04 at 120 N·m for large humanoids. Also worth checking out are MyActuator (RMD-X series, CAN/EtherCAT) and SteadyWin (GIM). CubeMars notes that the AK series (integrated driver) and AKE series (QDD without driver, 'bare' module for your own controller) are different product lines.

CAN: how to communicate with them

Almost all integrated actuators communicate via CAN. This is a differential pair CANH/CANL, up to 1 Mbit/s (CAN-FD - up to 5-8 Mbit/s in the data phase), up to ~110 nodes on the bus, with two 120 Ohm terminators at the ends. Each motor is assigned its own ID, and all are connected to the same cable.

• USB-CAN adapter: CANine from Motionlayer - €34.50, USB-C, CAN 2.0A/B up to 1 Mbit/s, built-in switchable terminator, firmware slcan or candleLight (then in Linux it is a regular can0 via SocketCAN). Compatible with Jetson Orin Nano, Raspberry Pi, laptop. Alternatives: CANable, PEAK PCAN-USB, Waveshare USB-CAN.
• Built-in CAN on Jetson Orin: Orin modules have a CAN controller (driver mttcan), but you need an external transceiver like SN65HVD230 and pinmux configuration. The USB adapter is usually faster to set up.
• CAN-FD (for moteus): mjbots fdcanusb or pi3hat for Raspberry Pi with several independent buses - convenient to assign a bus to each leg.
• Unitree uses RS-485 - requires a USB-RS485 adapter and their SDK.

Stepper motors

Full step, half step, microstep, and position loss

Two phases create a field with A and B components. Full step sharply changes its direction, half step adds intermediate positions. In microstepping, the currents IA = cos(θ), IB = sin(θ) break this transition into small increments. The toothed rotor follows the field, but only as long as there is enough torque.

A stepper motor moves in discrete steps. The driver receives two signals: STEP (one pulse = one step) and DIR (direction). The number of steps is the position, so no encoder is needed. Sizes are standardized: NEMA 17 (42 mm, 3D printers), NEMA 23 (57 mm, CNC), NEMA 34 (86 mm, machines).

• 1.8° (200 steps) or 0.9°
• Microstepping up to 1/256
• NEMA 17: 0.4-0.6 N·m
• NEMA 23: 1-3 N·m
• NEMA 34: 4-12 N·m
• Driver 12-48 V (and higher for NEMA 34)

Drivers and libraries

• TMC2209 (BigTreeTech and others, 5-10 €) – up to 2 A RMS, 4.75-28 V, StealthChop (almost silent), StallGuard (stall detection without limit switch), UART configuration. Library TMCStepper.
• For NEMA 23/34 – DM542 / DM556 or closed loop StepperOnline CL57T ($33-51): encoder on the motor, steps are not lost.
• Pulse generation: AccelStepper (acceleration and deceleration), FastAccelStepper (hardware timers ESP32/AVR, up to tens of kHz), Klipper / grblHAL / FluidNC firmware for multi-axis systems.

Where to buy: StepperOnline - everything from NEMA 8 to 34, NEMA 17 closed loop kit + driver $46.64; LDO Motors, Moons', Trinamic/ADI.

Hub motors

BLDC outrunner, where the bell is actually the wheel rim with the tire. The most affordable source is hoverboards: 6.5" wheel, 36 V, ~250-350 W, Hall sensors, a pair of used wheels from the market costs next to nothing. New 6.5-10" hub motors with encoder for AGV are sold on AliExpress for about $120-130 per unit with a claimed load capacity of up to 200 kg per wheel.

• Drivers: ODrive (S1 per wheel, Pro for heavy loads; ODrive has a guide for hoverboard motors), VESC, or the native hoverboard board with hoverboard-firmware-hack-FOC firmware (FOC, UART control)—an almost free driver for two wheels.

Power drives: AC servos, worm gears, linear actuators

When you need to lift or carry hundreds of kilograms, reliability, brakes, and safety take precedence over dynamics and responsiveness.

Summary table

* With a TMC driver in StealthChop mode, a stepper is almost silent at low speeds.

Software control

From a programmer's perspective, there are five interface levels. The higher the level, the less real-time is needed in your code.

Hobby servo on Arduino

#include 
Servo s;
void setup() { s.attach(9); }          // signal wire to pin 9
void loop() {
  s.write(0);   delay(1000);           // 1.0 ms pulse
  s.write(180); delay(1000);           // 2.0 ms pulse
}

Stepper with TMC2209 and AccelStepper

#include 
AccelStepper st(AccelStepper::DRIVER, 2, 3);  // STEP=2, DIR=3
void setup() {
  st.setMaxSpeed(4000);       // steps/s (including microstepping)
  st.setAcceleration(8000);
  st.moveTo(3200);            // 1 revolution at 1/16 microstep
}
void loop() { st.run(); }     // call as often as possible

ODrive from Python (firmware 0.6)

import odrive
from odrive.enums import AxisState, ControlMode

odrv = odrive.find_any()                      # USB
ax = odrv.axis0
ax.controller.config.control_mode = ControlMode.POSITION_CONTROL
ax.requested_state = AxisState.CLOSED_LOOP_CONTROL
ax.controller.input_pos = 2.5                 # in motor revolutions
print(ax.pos_vel_mapper.pos_rel, ax.motor.foc.Iq_measured)

On the robot, CAN is used instead of USB (CANSimple protocol, there is a package odrive_can for ROS 2).

moteus via CAN-FD

import asyncio, math, moteus

async def main():
    c = moteus.Controller(id=1)
    await c.set_stop()                        # reset errors
    while True:
        state = await c.set_position(position=math.nan, velocity=0.5,
                                     maximum_torque=2.0, query=True)
        print(state.values[moteus.Register.POSITION])
        await asyncio.sleep(0.01)

asyncio.run(main())

"MIT mode" (CubeMars, Damiao and many clones)

The most common protocol for QDD came from Mini Cheetah. In a single 8-byte CAN frame, you send the desired position, speed, stiffness Kp, damping Kd, and direct torque. The driver itself calculates τ = Kp·(p_des - p) + Kd·(v_des - v) + τ_ff at its own frequency. This is impedance control: small Kp - soft "springy" leg, large - stiff.

import can

def f2u(x, lo, hi, bits):                     # float -> unsigned int
    x = min(max(x, lo), hi)
    return int((x - lo) * ((1 << bits) - 1) / (hi - lo))

# Take ranges from your model's datasheet! Here is an example for AK70-10.
P, V, T, KP, KD = 12.5, 50.0, 25.0, 500.0, 5.0

def mit_frame(p, v, kp, kd, t):
    p_i, v_i = f2u(p, -P, P, 16), f2u(v, -V, V, 12)
    kp_i, kd_i, t_i = f2u(kp, 0, KP, 12), f2u(kd, 0, KD, 12), f2u(t, -T, T, 12)
    return bytes([p_i >> 8, p_i & 0xFF, v_i >> 4,
                  ((v_i & 0xF) << 4) | (kp_i >> 8), kp_i & 0xFF,
                  kd_i >> 4, ((kd_i & 0xF) << 4) | (t_i >> 8), t_i & 0xFF])

bus = can.Bus(interface="socketcan", channel="can0", bitrate=1_000_000)
ENTER = bytes([0xFF] * 7 + [0xFC])            # enter control mode
bus.send(can.Message(arbitration_id=1, data=ENTER, is_extended_id=False))
bus.send(can.Message(arbitration_id=1, data=mit_frame(0.5, 0, 20, 1, 0),
                     is_extended_id=False))
print(bus.recv(0.01))                          # response: position, speed, current

Bring up CANine in candleLight mode on Linux: sudo ip link set can0 up type can bitrate 1000000. For slcan firmware use interface="slcan" in python-can.

Libraries and frameworks

• python-can - universal CAN from Python (SocketCAN, slcan, PCAN, Kvaser).
• ros2_control - standard ROS 2 layer: you write (or use a ready-made) hardware interface for your motors, and get trajectory controllers, diff drive, gravity compensation, etc. Ready-made interfaces exist for Dynamixel, ODrive, moteus, CubeMars, Feetech.
• LeRobot - policy learning on arms with Feetech/Dynamixel.
• SimpleFOC, moteus, ODrive docs, CubeMars guide, RobStride on Seeed Wiki.

Many motors: how convenient is connection

Power supply

A power scheme that won't let you down

1. Battery → fuse → emergency stop button (e-stop), which physically breaks the motor power line → anti-spark connector (XT90-S) or precharge circuit → motor bus.
2. Thick wires: 48 V × 20 A total—already 12-14 AWG. XT30/XT60/XT90 connectors according to current.
3. Logic (Jetson, Raspberry Pi, sensors)—via a separate DC-DC. Voltage drops when motors start should not reboot the computer.
4. Common ground for logic and drivers, but without 'ground loops' through thick power wires.
5. For QDD: the peak current of all joints during a jump can be 3-5 times higher than average—the battery and BMS must handle this.

Scenarios

1. Power drives: platform or lift from 100 kg

Example: a 150 kg cart (with load) must travel at 1.5 m/s and climb a 10% incline. With wheels of 10 cm radius: resistance force ≈ m·g·(sin α + Crr) = 150 × 9.81 × (0.1 + 0.02) ≈ 176 N, plus acceleration of 0.5 m/s² adds +75 N. Total ~250 N, i.e., ~25 N·m on all drive wheels, about ~12.5 N·m per each of two. Check the required torque when choosing the motor and gearbox.

2. Walking robots up to 100 kg

The main requirement – a transparent, impact-resistant joint with torque control, that is, QDD. A rough estimate of peak knee torque: the weight on one leg during running, multiplied by the lever arm (for a heavily bent leg – ~0.7-0.8 of the segment length) and by a dynamics coefficient of 1.5-3.

• For reference: the MIT Mini Cheetah (~9 kg) uses actuators with a peak of ~17 N·m with a 6:1 gearbox, and the knee has an additional transmission.
• Motors are placed as close to the body (hip) as possible, and the knee is driven by a belt or linkage – this reduces leg inertia.
• Control: MIT mode at 500-1000 Hz, via CAN bus per leg, Jetson Orin / Raspberry Pi 5 / x86 with RT patch, ROS 2 + ros2_control or a custom C++ loop. The policy is often trained in a simulator (Isaac Lab, MuJoCo).
• Power supply 24-48 V, battery with high peak current, mandatory e-stop and "safe landing" (switch to damping) in case of connection loss.

3. Wheeled robots up to 30 kg

Here, the simplest solutions are sufficient. For 30 kg, 150 mm wheels, and a speed of 1 m/s, you need about 2-4 N·m per each of the two drive wheels, taking into account slope and acceleration.

Omnidirectional platforms (mecanum, omni) require 4 motors with encoders and closed-loop speed control—steppers perform worse here than geared motors with encoders.

Where to start

1. Wheeled robot: two 24 V gearmotors with encoders, RoboClaw, Raspberry Pi 5, ROS 2 diff_drive_controller. Everything will be up and running over the weekend.
2. Understand FOC: gimbal motor + SimpleFOC or Tinymovr. Try out position, speed, and torque modes, and feel the “virtual spring” effect by hand.
3. Tabletop arm: 6 × STS3215 (SO-ARM101 kit) + LeRobot—bus servos and policy training.
4. First QDD joint: one Damiao J4310 or CubeMars AK60-6 + CANine + python-can. Once a single joint responds in MIT mode, scaling to 12 joints is just a matter of expansion.
5. Large platform: hoverboard wheels + ODrive or VESC, with e-stop from day one.