Orion · Learn · Lesson 2 of 6

How does Orion move?

How a named movement becomes smooth motion: five joints, poses and keyframes, curves instead of straight lines, and a loop that steers the motors 50 times a second. Every animation here runs Orion's own motion software in your browser.

When Orion glances at you, nothing in it thinks “turn the head”. A file says which poses to pass through and how long to take, a program works out a smooth path between them, and five motors follow that path one small step at a time. This lesson takes those pieces in order. The lamps below run the same motion software as the real Orion.

Five joints

Orion’s body has five places where it can bend or turn. Each one is a Joint A place where two parts of a robot are connected so one can turn relative to the other. Each of Orion's joints has one servo., and each joint has its own motor. The base turns the whole arm left and right, the shoulder and elbow raise and fold the arm, and the head can nod and swivel.

That’s all the movement Orion has. Every gesture you’ll see, from a yawn to a laugh, is these five angles changing together.

On Orion Each joint stops short of its full range, at a Joint limit The furthest a joint is allowed to turn each way, set so the lamp never hits itself or strains a part. measured on the real lamp. The sliders stop there too.

Under the hood

The joints are named base_yaw_joint, shoulder_pitch_joint, elbow_pitch_joint, head_pitch_joint and head_roll_joint. “Yaw” means turning around a vertical axis, “pitch” means tipping up and down, and “roll” is the head’s swivel. Their limits live in hardware/profiles/v2-joints.json.

Reset toView
Drag a slider to move one joint; the parts it moves turn orange. Drag the lamp to look around it.

What’s a servo?

Orion’s motors are Servo A small motor with a position sensor and its own controller: you send it an angle and it turns there and holds it.. A servo isn’t told “spin”; it’s told an angle, and it turns there and holds. Inside, a Position sensor (encoder) A sensor inside the servo that measures the angle of its output. Orion's counts 4096 steps per full turn. keeps measuring where the output actually is, so the servo can correct itself and report back.

That’s what makes precise movement possible: the software only has to decide which angle each joint should be at, moment by moment.

On Orion Orion’s servos measure 4096 steps per turn, so each step is less than a tenth of a degree.

Under the hood

Orion uses Feetech STS3215 serial bus servos: all five share one cable and each has an ID from 1 to 5. Orion sets the zero of every joint with the lamp folded flat, its rest pose, and converts a reading to an angle with (raw − 2047) × 2π / 4096 Radian A unit for angles that robot software prefers. One full turn is about 6.28 radians, so one radian is about 57 degrees..

Goal 34°Horn 34°Sensor reads 2438 of 4096
Drag the orange dot to set a goal. The horn (the black arm) turns to it at the motor's own pace, and the sensor reports where it actually is. The count 2047 means zero degrees.

Poses and motions

A Pose A complete set of joint angles, one for every joint: a snapshot of how the robot is standing. is a named set of five angles: home, rest, look_left. A motion is a list of Keyframe A pose the robot should reach at a certain moment in a movement. The software fills in the movement between keyframes., each saying “reach this pose, taking this long”.

Some motions name poses directly. Others, like a nod, are small changes from wherever the lamp already is, so the same nod works whether Orion is looking left or right.

On Orion Orion has 26 named poses and 47 built-in motions, each a short text file.

Under the hood

This is look_at_left_expressive, from motion/motions/v2/:

motion:
  name: look_at_left_expressive
  space: absolute
  style: expressive_turn
  keyframes:
  - pose: look_left_anticipation
    duration: 0.25
    arrival: through
  - pose: look_left_lean
    duration: 0.4
    arrival: through
  - pose: look_left_overshoot
    duration: 0.3
    arrival: through
  - pose: look_left
    duration: 0.35
    arrival: settle
Go to pose
Play motion
  1. 1look_left_anticipation0.25 s · through
  2. 2look_left_lean0.40 s · through
  3. 3look_left_overshoot0.30 s · through
  4. 4look_left0.35 s · settle
Notice, lean toward, and settle on the predefined left target. Each keyframe names a pose.

Why doesn’t Orion jerk?

The simplest way to get from one keyframe to the next is a straight line: move at a steady speed, then stop. But a straight line starts at full speed and stops dead. That instant change in speed is a jolt: it rattles the arm and makes the motors clunk.

Orion joins its keyframes with curves instead. Each one starts gently, speeds up, and slows down before it arrives.

Guess first The two lamps reach the same poses at the same moments. Which one goes faster at its fastest?

Under the hood

Each joint’s path between two keyframes is a Quintic curve A smooth curve, from a fifth-power formula, that lets a movement start and stop at chosen speeds and accelerations, so it can begin and end gently., a fifth-power polynomial chosen so the position, Speed (velocity) How fast an angle is changing, and in which direction. Measured here in degrees per second. and Acceleration How fast the speed is changing. A sudden change in speed means a huge acceleration, which is what a jolt is. at both ends are exactly what was asked for. See runtime/src/motion/trajectory.rs.

Passing through or stopping

Each keyframe says how to arrive. Settle means stop there, with no speed left. Through means keep moving: the keyframe is a point to pass, not a place to stop.

A glance left and then right reads as two separate looks when both keyframes settle, and as one sweeping look when the first passes through.

On Orion A motion’s last keyframe must always settle, so every movement ends at rest.

At look_leftAt look_right
Click settle to make it through. Settling brings the speed to zero at the keyframe: the lamp stops there. Passing through keeps it moving, so the speed line crosses the keyframe without touching zero.

50 times a second

The smooth curve is a plan. To follow it, Orion’s Runtime The program on Orion's Raspberry Pi that owns the motors. Everything else has to ask it to move. runs a Control loop A program that repeats forever: measure, decide, act. Orion's runs 50 times a second.: read where each motor is, work out where the plan says it should be right now, and send the five new angles. Then it does it again, 20 milliseconds later.

Slow the glance down and you can see the separate steps that make up the smooth movement.

On Orion The loop runs 50 times a second. Slow work such as speech recognition runs elsewhere, so it can never hold the loop up.

Speed limits

A motor can only turn so fast. If a motion asks for a big turn in very little time, it would need a speed the motor doesn’t have.

Orion’s Compiler Here, the part of Orion's software that turns a motion file (keyframes and timings) into a full trajectory the motors can follow., the part that turns motion files into paths, checks every plan against that limit. When a move is too fast, it doesn’t fail: it makes the move take longer until the speed fits.

On Orion Orion’s servos top out around 312° per second (52 turns a minute).

Under the hood

The compiler estimates each segment’s peak speed by sampling its curve, stretches the segments that are too fast, and tries again, up to 12 times. The ceiling is STS3215_MAX_SPEED_RAD_S, about 5.45 radians per second.

Drag the time down. Past a point the motors can't keep up, and the compiler makes the move longer instead of failing.

Moving relative to where you are

Most of Orion’s small gestures, such as nods, bounces and breathing, aren’t written as poses. They’re written as small changes from the current pose, the Anchor The pose a small gesture is performed around. A nod moves a little away from the anchor and back to it.: “head up a little, then back”. That’s why one happy bounce works wherever Orion happens to be.

There’s one catch. Near a joint limit the full gesture might not fit. Rather than clip it, Orion shrinks the whole gesture evenly, so it keeps its shape.

On Orion Every relative motion has to end back at its anchor. Orion refuses one that doesn’t.

Under the hood

A relative keyframe resolves to anchor + style amplitude × scale × offsets. One scale between 0 and 1 is chosen for the whole motion, the largest that keeps every joint inside its limits.

Anchor
Gesture size 100%
The same file, speak_react_happy, works wherever the lamp happens to be: its keyframes say "a little up from here", not "go to this angle".

Styles

The same keyframes can be performed calmly or briskly. Every motion names one of eight styles, and the style sets how it moves: how fast it travels, how much it flows through keyframes, whether the joints move a little out of step, and how long it takes to settle.

This is how a thinking gesture comes out slow and drifting while a reaction comes out quick and crisp, without writing every movement twice.

Guess first Pick the thinking style. Will the glance take more time or less?

Style
speed of travel1.00
flow through keyframes0.72
joints out of step0.22
size of relative moves1.00
push past the target1.00
time to settle0.62
Peak speed –°/s. The numbers are the style's settings in Orion's runtime.

Who gets to move

Many parts of Orion want to move the lamp: idle breathing, listening, speaking, a requested motion, the Stop button. They can’t all move it at once, so movement has an order of priority. A higher priority takes over immediately; a lower one waits its turn.

The handover is smooth because the new movement starts from exactly where the old one was, and at the same speed.

On Orion Only the runtime ever sends angles to the motors. Everything else, including voice and Studio, has to ask it (Meet Orion shows the gatekeeper).

  1. Stop pressed in Studio · return_home
  2. "Look to your left" · look_at_left_expressive
  3. Orion replying · speak_calm_sway
  4. You start talking · listen_lean_in
  5. Nothing else going on · idle_breathe
  • Waiting. Pick something for Orion to do.
Start an idle, then press a higher level while it runs. Then try a lower level while something higher is moving.

Asked for vs actual

The plan is what Orion asks for, not what happens. A real motor carries a real arm, so it trails the plan slightly and doesn’t quite reach every quick peak.

That’s why a movement isn’t “done” when its timeline ends. Orion waits until the measured joints have stayed close to the final pose, which it calls settling.

On Orion In this recording the head trails the plan by about 60 milliseconds. The shoulder, which carries the whole arm, trails by about 140.

JointShow
3450s1s2s3shead nod, ° from start
Asked for (the goals sent)Actual (read back from the motor)
The motor trails the plan by about 60 ms
Recorded on the real lamp during a spoken reply (Orion servo tracking capture, 27 Sep 2026). The motor follows the plan a little late and doesn't quite reach every peak.

Make your own motion

Now put it together. Pose the lamp with the sliders, add keyframes, choose a style, and press Compile and play. Your motion goes through Orion’s own compiler, so the result is exactly what the real lamp would do, including the messages it gives when it refuses.

When you like it, open “See it as Orion’s motion file”: that text is a motion Orion can load.

On Orion The lamp starts every motion from home, just as Orion does when it wakes.

StyleStart from
See it as Orion's motion file
format_version: 2
motion:
  name: my_motion
  description: "Made in the Vulkan Research lesson."
  space: absolute
  style: attentive
  keyframes:
  - pose: my_pose_1
    duration: 0.8
    arrival: through
  - pose: my_pose_2
    duration: 0.7
    arrival: through
  - pose: my_pose_3
    duration: 0.9
    arrival: settle

# poses.yaml additions
  my_pose_1:
    positions: {base_yaw_joint: -0.8378, shoulder_pitch_joint: 0.8183, elbow_pitch_joint: -1.1530, head_roll_joint: -0.4538, head_pitch_joint: -0.4594}
  my_pose_2:
    positions: {base_yaw_joint: 0.0109, shoulder_pitch_joint: 0.7833, elbow_pitch_joint: -1.1780, head_roll_joint: -0.0072, head_pitch_joint: -0.5594}
  my_pose_3:
    positions: {base_yaw_joint: 0.0109, shoulder_pitch_joint: 0.8633, elbow_pitch_joint: -1.1380, head_roll_joint: -0.0072, head_pitch_joint: -0.3594}
The lamp starts at home. Every keyframe needs a pose and a travel time; the last one must settle. Try making it fast, or ending on "through", and see what the compiler says.