Learning Embedded Rust: A C/Python Developer's Rosetta Stone

fn process_data() {
    let buffer = vec![0u8; 256]; // heap-allocated, owned by `buffer`
    do_something(&buffer);       // borrowed — no ownership transfer
}   // `buffer` dropped here automatically, memory freed

void process_data() {
    uint8_t *buffer = malloc(256);
    if (!buffer) return;          // must check for NULL!
    do_something(buffer, 256);
    free(buffer);                 // forget this = memory leak
}

def process_data():
    buffer = bytearray(256)      # heap-allocated, GC-managed
    do_something(buffer)          # passed by reference
    # no cleanup needed — GC handles it

fn read_sensor() -> Result<u16, SensorError> {
    let raw = i2c.read(SENSOR_ADDR, &mut buf)?;  // `?` propagates error
    Ok(parse_value(raw))
}

int read_sensor(uint16_t *value) {
    uint8_t buf[2];
    int err = i2c_read(SENSOR_ADDR, buf, sizeof(buf));
    if (err < 0) return err;    // manual propagation
    *value = parse_value(buf);
    return 0;
}

def read_sensor() -> int:
    try:
        raw = i2c.read(SENSOR_ADDR, 2)
        return parse_value(raw)
    except IOError as e:
        raise SensorError(f"Read failed: {e}")

enum SensorState {
    Ready(u16),
    Calibrating { progress: u8 },
    Error(SensorError),
}

let message = match state {
    SensorState::Ready(value) => format!("HR: {} bpm", value),
    SensorState::Calibrating { progress } => format!("Cal: {}%", progress),
    SensorState::Error(e) => format!("Err: {:?}", e),
};  // compiler ensures ALL variants are covered

switch (state.type) {
    case SENSOR_READY:
        sprintf(msg, "HR: %d bpm", state.value);
        break;                   // forget this = fall-through bug
    case SENSOR_CALIBRATING:
        sprintf(msg, "Cal: %d%%", state.progress);
        break;
    case SENSOR_ERROR:
        sprintf(msg, "Err: %d", state.error);
        break;
    // no compiler warning if you forget a case
}

match state:
    case SensorState(status="ready", value=v):
        message = f"HR: {v} bpm"
    case SensorState(status="calibrating", progress=p):
        message = f"Cal: {p}%"
    case SensorState(status="error", error=e):
        message = f"Err: {e}"
    # no enforcement if you miss a case

trait Sensor {
    fn read(&mut self) -> Result<u16, SensorError>;
    fn name(&self) -> &str;
}

impl Sensor for Max30100 {
    fn read(&mut self) -> Result<u16, SensorError> { /* ... */ }
    fn name(&self) -> &str { "MAX30100" }
}

fn log_reading(sensor: &mut impl Sensor) {  // static dispatch
    if let Ok(val) = sensor.read() {
        println!("{}: {}", sensor.name(), val);
    }
}

typedef struct {
    int (*read)(void *ctx, uint16_t *value);
    const char *(*name)(void *ctx);
} sensor_vtable_t;

void log_reading(const sensor_vtable_t *vtable, void *ctx) {
    uint16_t val;
    if (vtable->read(ctx, &val) == 0) {
        printf("%s: %d\n", vtable->name(ctx), val);
    }
}

class Max30100:
    def read(self) -> int: ...
    def name(self) -> str: return "MAX30100"

def log_reading(sensor):  # duck typing — any object with read() and name()
    try:
        val = sensor.read()
        print(f"{sensor.name()}: {val}")
    except Exception:
        pass

// Safe wrapper around unsafe hardware access
fn read_register(addr: u32) -> u32 {
    unsafe {
        core::ptr::read_volatile(addr as *const u32)
    }
}

// Application code stays safe
let status = read_register(STATUS_REG);

// No safety boundary — you just do it
uint32_t status = *(volatile uint32_t *)STATUS_REG;
// hope you got the address right!

# Usually not applicable — you'd use a library
import ctypes
status = ctypes.c_uint32.from_address(STATUS_REG).value

#[embassy_executor::task]
async fn sensor_task(mut sensor: Max30100) {
    loop {
        let hr = sensor.read().await;  // yields to other tasks
        Timer::after(Duration::from_millis(100)).await;
    }
}

void sensor_task(void *params) {
    max30100_t *sensor = (max30100_t *)params;
    while (1) {
        uint16_t hr;
        max30100_read(sensor, &hr);    // blocks this thread
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

async def sensor_task(sensor):
    while True:
        hr = await sensor.read()       # yields to event loop
        await asyncio.sleep(0.1)