EMBEDDED RUST · no_std → WASM

Traits: Reusable Control, Zero Cost

Define a Controller trait, implement it on a Pursuit struct, and call it through a generic function, seeing that the abstraction adds no runtime overhead on the metal.

01Challenge

A Controller trait and a generic drive() are set up for you. Fill in Pursuit::step with the steer-and-ease law so drive() can run it, and reach the pad. The same drive() would run any other Controller you write.

Predict firstYou write drive() generically so it runs ANY Controller (Pursuit now, others later). In Rust, what does that abstraction cost at runtime?

02Model

Good firmware is reusable without being slow. In many languages that trade-off is real: an interface call costs a pointer chase at runtime. Rust's traits and generics are different. A generic function over a trait is compiled separately for each concrete type it is used with, so calling ctrl.step(...) through the trait compiles to exactly the same instructions as writing the math inline. You get the reuse of an interface and the speed of hand-written code at once. That is why a single control policy, written once behind a trait, can run unchanged on a laptop and on a microcontroller with cycles to spare.

03Guided practice

1. Fill in step. Inside Pursuit::step, compute let turn = self.turn_gain * bearing; and let forward = (self.fwd_gain * dist).min(self.cap); then return (forward - turn, forward + turn). 2. See the reuse. drive<C: Controller> takes any type that implements Controller; it never names Pursuit. 3. Note the cost. This generic call compiles to the same code as inlining the math: no runtime penalty. 4. Drive. control() builds a Pursuit with the gains and hands it to drive(); the rover reaches the pad.

04Feedback

PASS WHEN Pursuit implements Controller, the generic drive() runs it, and the rover reaches the pad with a reusable, zero-cost abstraction.

If your run fails, check:

Rover sits still: `Pursuit::step` still returns `(0.0, 0.0)`. Compute turn and forward from the fields and return the pair.
Rover veers off: check the sign, left motor is `forward - turn`, right is `forward + turn`, with turn = `self.turn_gain * bearing`.
Overshoots the pad: keep the `.min(self.cap)` so forward eases down as distance shrinks.

05Retrieve & space

What does the generic `drive<C: Controller>` know about Pursuit? (only that it implements Controller).
Why does calling `ctrl.step(...)` through a trait cost nothing extra at runtime here? (monomorphisation: the generic is compiled per concrete type).
How would you run a second, different controller through the same drive() function? (implement Controller on another struct).

06Mastery & project

Express a control policy as a trait implemented on a struct and invoke it generically at zero runtime cost: reuse without a speed penalty.

The abstraction the capstone assembles, and the reason one Rust policy can target both a workstation and an MCU.

← Enums: States You Cannot Get Wrong One Source, Two Targets →

EMBEDDED RUST · no_std → WASM

Traits: Reusable Control, Zero Cost

Build a controller behind a trait and call it through a generic. Fill in Pursuit::step and drive to the pad.

You read

You change

the firmware you write in the control loop

Fixed

the emulated chip, its peripherals, and the wiring