AI Context — Complete Framework Reference

// simplified
use horus::prelude::*;

struct TempSensor {
    pub_topic: Topic<f32>,
}

impl TempSensor {
    fn new() -> Result<Self> {
        Ok(Self { pub_topic: Topic::new("sensor.temperature")? })
    }
}

impl Node for TempSensor {
    fn name(&self) -> &str { "TempSensor" }
    fn tick(&mut self) {
        self.pub_topic.send(self.read_temperature());
    }
}

// simplified
use horus::prelude::*;

struct Logger {
    sub: Topic<f32>,
}

impl Logger {
    fn new() -> Result<Self> {
        Ok(Self { sub: Topic::new("sensor.temperature")? })
    }
}

impl Node for Logger {
    fn name(&self) -> &str { "Logger" }
    fn tick(&mut self) {
        if let Some(temp) = self.sub.recv() {
            hlog!(info, "Temperature: {:.1}C", temp);
        }
    }
}

// simplified
use horus::prelude::*;

struct Filter {
    scan_sub: Topic<LaserScan>,
    cmd_pub: Topic<CmdVel>,
}

impl Filter {
    fn new() -> Result<Self> {
        Ok(Self {
            scan_sub: Topic::new("scan")?,
            cmd_pub: Topic::new("cmd_vel")?,
        })
    }
}

impl Node for Filter {
    fn name(&self) -> &str { "Filter" }
    fn tick(&mut self) {
        if let Some(scan) = self.scan_sub.recv() {
            if let Some(min) = scan.min_range() {
                if min < 0.5 {
                    self.cmd_pub.send(CmdVel::zero());
                } else {
                    self.cmd_pub.send(CmdVel::new(1.0, 0.0));
                }
            }
        }
    }
}

// simplified
use horus::prelude::*;

fn main() -> Result<()> {
    let mut scheduler = Scheduler::new()
        .tick_rate(1000.hz())
        .watchdog(500.ms());

    scheduler.add(ImuSensor::new()?).order(0).rate(100.hz()).build()?;
    scheduler.add(PidController::new()?).order(10).rate(50.hz())
        .budget(500.us()).on_miss(Miss::Skip).build()?;
    scheduler.add(PathPlanner::new()?).order(50).rate(10.hz())
        .compute().build()?;
    scheduler.add(TelemetryLogger::new()?).order(200).rate(1.hz())
        .async_io().build()?;

    scheduler.run()
}

// simplified
use horus::prelude::*;

struct StateMachine {
    cmd_sub: Topic<CmdVel>,
    motor_pub: Topic<MotorCommand>,
    state: State,
    last_cmd: Option<CmdVel>,
}

enum State { Idle, Moving, Stopping }

impl Node for StateMachine {
    fn name(&self) -> &str { "StateMachine" }

    fn tick(&mut self) {
        // ALWAYS recv first, regardless of state
        if let Some(cmd) = self.cmd_sub.recv() {
            self.last_cmd = Some(cmd);
        }

        match self.state {
            State::Idle => {
                if let Some(ref cmd) = self.last_cmd {
                    if cmd.linear.abs() > 0.01 {
                        self.state = State::Moving;
                    }
                }
            }
            State::Moving => {
                if let Some(ref cmd) = self.last_cmd {
                    self.motor_pub.send(MotorCommand::from_cmd_vel(cmd));
                    if cmd.linear.abs() < 0.01 {
                        self.state = State::Stopping;
                    }
                }
            }
            State::Stopping => {
                self.motor_pub.send(MotorCommand::stop());
                self.state = State::Idle;
                self.last_cmd = None;
            }
        }
    }

    fn shutdown(&mut self) -> Result<()> {
        self.motor_pub.send(MotorCommand::stop());
        Ok(())
    }
}

// simplified
use horus::prelude::*;

struct Aggregator {
    imu_sub: Topic<Imu>,
    odom_sub: Topic<Odometry>,
    fused_pub: Topic<Pose2D>,
    last_imu: Option<Imu>,
    last_odom: Option<Odometry>,
}

impl Node for Aggregator {
    fn name(&self) -> &str { "Aggregator" }

    fn tick(&mut self) {
        // Always drain both topics
        if let Some(imu) = self.imu_sub.recv() {
            self.last_imu = Some(imu);
        }
        if let Some(odom) = self.odom_sub.recv() {
            self.last_odom = Some(odom);
        }

        // Fuse when both are available
        if let (Some(ref imu), Some(ref odom)) = (&self.last_imu, &self.last_odom) {
            let fused = self.fuse(imu, odom);
            self.fused_pub.send(fused);
        }
    }
}