RobotGuide

Glossary

In interviews the giveaway is not ignorance — it is hearing every word and not knowing what the other person means. Each term gets three things: what it actually is, why it matters, and one line worth memorizing.

End-to-end / layered

The two framings are often written as opposites. In reality: high-level decisions are slow and low-level control is fast, so physics forces layering; 'end-to-end' means the high layer uses one large model to go straight from perception to actions, while the low layers stay layered.

The brain taking 100ms is tolerable; the cerebellum 1ms slow and it falls.

High-school versionThe big model does the 'thinking', but the fine work of moving arms and legs is still done by layered programs — you think about the answer, but the muscles holding the pen don't take your slow instructions.

Real-time

Not 'fast' but 'deterministic'. A fixed 1ms delay can be compensated by prediction; a system averaging 0.5ms with ±2ms jitter can never be tuned stable.

Always ask for the worst case, not the average.

High-school versionNot fast — steady. A starting gun fired at exactly 0.1s intervals reassures athletes more than one averaging 0.05s but erratic.

Jitter

The same instruction takes a different time on every execution. It's deadlier than latency because you can't compensate a random quantity.

'Average latency 1ms' means almost nothing in robotics.

High-school versionThe interval between shots varies; nobody can hit the rhythm.

1kHz control loop

Compute and send commands once every millisecond. Force control of humanoid joints is generally at this scale.

Period 1000µs; jitter must be squeezed to tens of microseconds.

High-school versionThe robot's cerebellum makes one decision every millisecond, 1000 times a second — in the time you blink once it has decided 100 times.

PREEMPT_RT

The patch set that makes Linux 'predictable', merged into mainline with Linux 6.12 in December 2024. No separate patching needed since then.

It can squeeze jitter to 10–50µs, but 20kHz work still belongs to an MCU.

QoS

The per-topic communication rules in ROS 2: reliable or best effort, how many frames to keep when dropped, what counts as timeout.

Using RELIABLE for a control topic turns 'one frame lost' into 'one frame late' — worse.

EtherCAT

An industrial real-time bus. Slaves forward frames in hardware with distributed clocks; cycles down to 125–1000µs with sync jitter under 1µs.

It's not 'a pricier CAN' — it's a different order of magnitude.

High-school versionThe high-speed shuttle carrying data between robot joints: scheduled one departure per millisecond, and not one is ever late.

CAN

A bus common in cars and robots. At 1Mbps an 8-byte frame takes about 130µs; 10 axes queuing is 1.3–1.6ms.

That's why the practical CANopen sync cycle only reaches about 500Hz.

High-school versionThe most common two-wire communication in cars and robots — cheaper than EtherCAT, more reliable than USB.

Inertia matching

The 'heaviness ratio' between the motor rotor and the load. If the ratio is too large, the velocity loop gain can't go up and all the bandwidth upstream is wasted.

Direct drive: <= 5:1 recommended; with a gearbox (reflected) up to 20–30:1.

Backlash

The small dead travel when gears reverse direction. It behaves like a velocity-dependent delay, reaching tens of milliseconds at low speed.

Shows up as a 'clunk' on reversal and inconsistent bidirectional positioning.

Harmonic reducer

Compact, large reduction ratio, near-zero backlash (under 1 arc-minute); the mainstream choice for humanoid joints.

The price is 30–80Hz resonance from its compliance, capping force-control bandwidth at 10–20Hz.

Impedance / admittance control

One controls position and yields to force; the other controls force and yields to position. The difference is 'who adapts to whom'.

Assembly, polishing, and human-robot collaboration all rest on this.

WBC (whole-body control)

Write balance, end-effector pose, posture, and other tasks into one optimization problem, satisfied simultaneously by priority.

The underlying mechanism that keeps humanoids from falling.

ZMP / capture point

Two criteria for 'will it fall'. ZMP watches the center of pressure; the capture point asks 'if it stopped now, could it still stand'.

The former suits slow planning; the latter suits disturbance assessment.

Sim2Real

Trained in simulation, transferred to the real robot. The gap comes from friction, latency, compliance, and noise.

Randomizing only visuals and not dynamics is a common way to die.

High-school versionHow much of what it learned in simulation survives the move to the real robot.

VLA

Vision-language-action model: look at the image and the instruction, output actions directly.

It only makes high-level decisions; the low level still needs a 1kHz control loop.

High-school versionA big model that can see, listen, and act directly — vision, language, and action in one.

HIL

Hardware-in-the-loop: the controller is real, the controlled object is simulated. Lets you test fault handling without a full robot.

HIL without fault injection is HIL not done.

WCET

Worst-case execution time. Real-time systems schedule by it, not by averages.

Averages are for reports; WCET is what keeps the system alive.

Boot chain / bootloader

The whole chain from power-on to main(): BootROM → SPL/U-Boot → device tree → kernel → init. A board that won't boot, OTA upgrades, boot parameter changes — all live on this chain.

When asked 'the board powers on with no response, how do you debug', the answer is to walk this chain checking output at each stage.

Device tree

Write a board's hardware info (peripheral addresses, pins, interrupts) as a data file, so drivers and kernel code don't change with the board.

Change hardware without recompiling the kernel — the only reason it exists.

BSP / Yocto

A BSP is all the low-level software that makes a given board run. Yocto and Buildroot are build frameworks that assemble a BSP into a whole system: the former suits long-term maintenance of multiple product lines, the latter suits going fast on a single product.

When a JD mentions Yocto, it's usually asking: can you produce a bootable image from scratch.

Dual-system architecture (brain / cerebellum)

The brain is a large model like VLA doing understanding and decisions at 1–10Hz; the cerebellum is a real-time controller doing trajectory tracking and balance at 500Hz–1kHz. Skills or trajectories bridge them — the current mainstream combination for humanoids.

Same division of labor as the human nervous system: slow thinking, fast reflexes.

High-school versionRobots also have a brain and a cerebellum: the one thinking can be slow; the one managing balance, 1ms slow and it falls.

World model

Lets the model 'imagine' internally how the world changes, predict the consequences of actions, then act. Seen as a candidate form of the next-generation robotics foundation model.

Compared to VLA it has more prediction and less immediate deployability.

High-school versionThe physical sand table the robot draws inside its own head — with it you can 'rehearse in your head before doing it for real'.

Arduino

A way for beginners to plug in USB and go: board + simplified libraries + one-click upload. Strength: something that moves in three days. Weakness: loop() has no real-time guarantee (millisecond-level jitter), and no memory or version management.

It's an entrance, not a destination. Below a 10ms control period, switch to STM32.

High-school versionA microcontroller board for beginners — the most common board in high-school labs; plug in the USB cable and start writing programs.

ESP-IDF

Espressif's official ESP32 development framework, essentially a FreeRTOS project running on two cores. The Arduino core is its simplified shell.

To control the dual-core split or see the low-level tasks, you must use IDF.

RTOS

A real-time operating system. It doesn't make programs faster; it makes 'multiple tasks each running on their period' predictable: who runs first, for how long, how they queue for resources.

Bare metal fakes it with state machines; add enough tasks and they drag each other down.

High-school versionA small OS dedicated to programs that 'must keep their appointments'.

FreeRTOS

The most common RTOS on MCUs; runs in a dozen-odd KB. Its core is just four things: tasks, queues, semaphores, mutexes.

When an interview asks about RTOS, eight times out of ten it's this one.

Priority inversion

A high-priority task waits for a lock held by a low-priority task, a medium-priority task cuts in and squeezes out the low-priority one, and the high-priority task is blocked indefinitely. Mars Pathfinder tripped on this in 1997.

The fixes are priority inheritance or priority ceiling.

High-school versionAn urgent matter waits for the lock in a slow one's hands, while the slow one gets cut in line by an idle one — a three-way traffic jam.

Watchdog

An independent timer: the program must 'feed' it once before it times out, or it force-resets. It's embedded's last line of defense.

Feeding the dog inside an interrupt equals not feeding it — the main loop can die and it still gets fed.

High-school versionAn alarm clock: the program must press it every few seconds or it reboots — the cure for hangs.

Differential signaling

Send one signal over two wires; the receiver takes the difference. Common-mode noise picked up on both wires cancels out, so it resists interference; small swing and fast transitions let it run at high speed.

USB, CAN, Ethernet, and MIPI are all differential.

Termination resistors

Matching resistors at both ends of the bus to absorb the energy arriving at the end and suppress reflections. CAN uses two 120 Ω in parallel into 60 Ω.

With only one, a short line may look fine; lengthen it and it collapses.

Eye diagram

Overlay many waveform segments; the empty shape in the middle looks like an eye. The wider the eye opens, the larger the decision margin and the lower the bit-error rate.

Eye height is eaten by rise time and reflections; eye width is eaten by jitter.

High-school versionStack a waveform frame by frame — like overlaying the whole class's copybooks: the more aligned the strokes, the better the letters.

NRZI and bit stuffing

NRZI encodes 0 and 1 by 'whether there is a transition'; bit stuffing forces a 0 after six consecutive 1s so the receiver always has a clock to recover.

USB and EtherCAT both use this scheme.

Open drain and pull-up

The device can only pull the line low; high level comes from an external resistor. I2C uses this for 'wired-AND' so multiple masters don't burn each other.

Without a pull-up the line stays low forever; pull up too weak and the rising edge can't climb.

CPOL / CPHA

SPI's two clock parameters; their combinations form four modes deciding 'idle level' and 'which edge to sample on'. Mismatched modes on the two ends read back all 0s or all 1s.

First thing when debugging SPI: verify the mode.

Baud rate error

The two ends' clocks aren't exactly identical; the error accumulates along a frame. A frame is about 10 bits; combined error beyond ±2%~3% starts causing occasional framing errors.

For occasional garbled data, measure the crystal first — don't suspect the code first.

MIPI / GMSL

Two camera interfaces. MIPI is short in-board ribbon cables with multi-lane differential pairs; GMSL runs a dozen-plus meters on coax and can supply power over coax too.

Crossing a joint requires GMSL; ribbon cables don't leave the chassis.

PCB prototyping

Hand design files to a board house for physical boards, usually 5–7 days. You must pass DRC / DFM before ordering, or the boards come back unsolderable.

On the first prototype, always leave test points and jumpers.

USB transfer types

Control (enumeration and configuration), bulk (guaranteed correct, not timely), interrupt (guaranteed interval), isochronous (guaranteed bandwidth, not correctness). Cameras use isochronous, so they drop frames without erroring.

This also explains why USB can't do hard real time.

Executor

The thing in ROS 2 that actually 'runs callbacks': it takes due callbacks from the queue and dispatches them to threads. Single-threaded is enough but blocks; multi-threaded runs concurrently but the scheduling itself adds jitter.

When latency is unstable, check the executor first — don't suspect the network first.

Callback group

The concurrency boundary inside a node. Callbacks in a mutually exclusive group run one at a time; in a reentrant group they can run simultaneously. The default is mutually exclusive, so one slow callback blocks the whole chain.

'Controls start jittering the moment the camera turns on' — seven times out of ten it's here.

Lifecycle node

A node with a state machine: configure before activating, activate before sending and receiving data; it can be deactivated and cleaned up. Production environments use it for safe startup, hot switching, and graceful shutdown.

A node that just does everything in one go inside init can't be stopped safely when things go wrong.

rmw

The ROS middleware abstraction layer. Above it are rclcpp / rclpy; below it are concrete DDS implementations. Switch implementations by changing one environment variable — no business code changes.

RMW_IMPLEMENTATION=rmw_cyclonedds_cpp and it's switched.

Zero copy (iceoryx)

Publisher and subscriber share the same memory with no copying. It only holds on the same machine, same middleware, correct configuration; never across machines.

Thinking zero copy makes you fast while messages are still serialized — measure the copy count first.

micro-ROS

Runs ROS 2 nodes on an MCU, connected to the host over XRCE-DDS on serial or UDP. Suits 'sensor nodes speaking ROS directly', not high-frequency control.

It solves wiring and protocol unification, not real-time performance.

DDS domain ID

A logical partition within the same physical network. Two ROS 2 systems with different domain IDs can't see each other — the laziest way to isolate 'two systems on one machine'.

Can't connect? Check the domain id first — faster than checking the firewall.

colcon

ROS 2's build tool: compiles in package dependency order, puts artifacts in the install directory, and multiple workspaces can stack (overlay).

Without sourcing install/setup after a change, you're still running the old code.