AI Context — Complete Framework Reference

use horus::prelude::*;

fn shutdown(&mut self) -> Result<()> {
    self.motor.set_velocity(0.0);
    Ok(())
}

fn tick(&mut self) {
    // ALWAYS recv, cache result
    if let Some(msg) = self.sub.recv() {
        self.cached = Some(msg);
    }
    // Then use cached value
}

// BAD: std::thread::sleep(Duration::from_millis(100));
// GOOD: Use scheduler rate control instead

// BAD: let data = std::fs::read_to_string("file.txt")?;
// GOOD: Read in init(), use cached data in tick()

// CORRECT: Topic::new("sensors.lidar")
// WRONG:   Topic::new("sensors/lidar")

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());
    }
}

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);
        }
    }
}

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));
                }
            }
        }
    }
}

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()
}

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(())
    }
}

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);
        }
    }
}

import horus

def my_tick(node):
    node.send("temperature", 25.5)

sensor = horus.Node(
    name="temp_sensor",
    pubs="temperature",
    tick=my_tick,
    rate=10
)
horus.run(sensor, duration=30)

import horus
from horus import CmdVel

class DriveState:
    def tick(self, node):
        node.send("cmd_vel", CmdVel(linear=0.5, angular=0.0))

    def shutdown(self, node):
        node.send("cmd_vel", CmdVel(linear=0.0, angular=0.0))

drive = DriveState()
node = horus.Node(name="drive_node", tick=drive.tick,
                  shutdown=drive.shutdown, pubs=["cmd_vel"],
                  rate=50, order=0)

horus.run(node)

horus.run(sensor_node, controller_node, duration=60)

from horus import Topic, CmdVel

pub = Topic("cmd_vel", CmdVel)
pub.send(CmdVel(linear=1.0, angular=0.0))

sub = Topic("cmd_vel", CmdVel)
msg = sub.recv()  # Returns None if empty

def process(node):
    if node.has_msg("scan"):
        scan = node.recv("scan")
        all_scans = node.recv_all("scan")

[package]
name = "my-robot"
version = "0.1.0"
description = "My robot project"
authors = ["Name <email>"]

[dependencies]
# Rust deps (auto-detected as crates.io)
serde = { version = "1.0", source = "crates.io", features = ["derive"] }
nalgebra = "0.32"

# Python deps (specify source = "pypi")
numpy = { version = ">=1.24", source = "pypi" }
torch = { version = ">=2.0", source = "pypi" }

# System deps
libudev = { version = "*", source = "system" }

# Path deps
my_lib = { path = "../my_lib" }

# Git deps
some_crate = { git = "https://github.com/user/repo", branch = "main" }

[dev-dependencies]
criterion = { version = "0.5", source = "crates.io" }
pytest = { version = ">=7.0", source = "pypi" }

[scripts]
sim = "horus sim start --world warehouse"
deploy = "horus deploy pi@robot --release"
test-hw = "horus run tests/hardware_check.rs"

[drivers]
realsense = { version = "0.3" }
dynamixel = { version = "0.2" }

[hooks]
pre_run = ["fmt", "lint"]
post_build = ["test"]

use horus::prelude::*;
// Provides: Node, Topic, Scheduler, DurationExt, Frequency, Miss,
// all message types, error types, macros, services, actions, etc.
// 165+ types in one import.

use serde::{Serialize, Deserialize};

#[derive(Clone, Serialize, Deserialize)]
struct MyMessage {
    x: f32,
    y: f32,
    label: String,
}

let topic: Topic<MyMessage> = Topic::new("my.data")?;

use horus::prelude::*;
// Error, Result<T>, HorusError
// Variants: CommunicationError, ConfigError, MemoryError, NodeError,
// NotFoundError, ParseError, ResourceError, SerializationError,
// TimeoutError, TransformError, ValidationError
// Helpers: retry_transient(), RetryConfig