EMBEDDED RUST · no_std → WASM

Option: No Null, No Silent Bug

Model a sensor's 'no reading' sentinel as Option<f32> and handle it with match, so a missing measurement can never be used as if it were a real distance.

01Challenge

The range finder returns -1.0 when the path is clear. Used carelessly, that magic number reads as a distance of minus one metre. Model the reading as Option, handle both cases, and ease off only when something is genuinely close.

Predict firstA range finder returns -1.0 to mean ‘path clear.’ If you treat that reading as a plain number in your control law, what goes wrong?

02Model

Rust has no null. A value that might be absent has the type Option: either Some(value) or None, and you cannot read the value without saying what happens when it is missing. This is not bureaucracy; it is the bug that a sensor's -1.0 sentinel invites, made impossible. On a robot, treating 'no reading' as a real number is how a machine drives into a wall it thought was a metre behind it. Wrap the reading in Option, match on it, and the compiler will not let you forget the empty case.

03Guided practice

1. Implement reading. Return None for the sentinel, Some(m) otherwise: if m < 0.0 { None } else { Some(m) }. 2. Match on it. Replace the fixed cap with let cap = match reading(p.range.read()) { Some(d) if d < 0.3 => 0.15, _ => 0.6 }; 3. Read the match. Some(d) if d < 0.3 handles a close obstacle; _ covers both a far reading and None. 4. Drive. The path reads clear most of the way, so you reach the pad; the point is that a missing reading can never masquerade as a distance.

04Feedback

PASS WHEN The reading is modelled as Option<f32>, both Some and None are handled, and the rover reaches the pad.

If your run fails, check:

Build fails: `reading` must return the same type on both branches. `None` and `Some(m)` are both `Option<f32>`; make sure every path returns one.
Rover crawls or times out: your cap is low even when the path is clear. Only cap low on `Some(d) if d < 0.3`; use 0.6 otherwise.
You compared the raw `p.range.read()` to a distance again. Route it through `reading(...)` and match, so the -1.0 sentinel becomes None.

05Retrieve & space

What are the two variants of `Option<f32>`, and why can you not read the value without handling both?
Why is a -1.0 'no reading' sentinel dangerous on a robot, and how does Option remove the danger?
In `Some(d) if d < 0.3`, what does the `if` part add to the pattern? (a match guard).

06Mastery & project

Represent a possibly-absent sensor reading as Option and handle it exhaustively: the type system standing in for a check you would otherwise forget.

The habit every safety-relevant sensor path in the course uses: absence is a type, not a magic number.

← Borrowing: Share Without Giving Away Enums: States You Cannot Get Wrong →

EMBEDDED RUST · no_std → WASM

Option: No Null, No Silent Bug

Handle a fallible sensor with Option<f32> and match. Fill in the two TODOs 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