Driver API

use horus::prelude::*;
use horus::drivers;

// horus.toml provides port, baudrate, servo_ids
let mut hw = drivers::load()?;
let handle = hw.dynamixel("arm")?;

scheduler.add(ArmDriver::new(handle))
    .rate(500_u64.hz())
    .on_miss(Miss::SafeMode)
    .build()?;

use terra::dynamixel::DynamixelBus;

let bus = DynamixelBus::open("/dev/ttyUSB0", 1_000_000)?;
scheduler.add(ArmDriver::new(bus))
    .rate(500_u64.hz())
    .build()?;

let mut hw = drivers::load()?;

let mut hw = drivers::load_from("tests/test_drivers.toml")?;

let handle = hw.dynamixel("arm")?;
let port: String = handle.params().get("port")?;
let terra_name: Option<&str> = handle.terra_name(); // "dynamixel"

[drivers.imu]
terra = "mpu6050"
bus = "i2c-1"
topic = "sensors/imu"           # sensor data output

[drivers.arm]
terra = "dynamixel"
port = "/dev/ttyUSB0"
topic_state = "arm/joint_states"     # state output
topic_command = "arm/joint_commands"  # command input

if let Some(mapping) = hw.topic_mapping("arm") {
    if let Some(state_topic) = &mapping.topic_state {
        println!("State published on: {}", state_topic);
    }
}

use horus::prelude::*;
use horus::drivers::{DriverParams, register_driver};

struct ConveyorDriver {
    port: Box<dyn serialport::SerialPort>,
    belt_length: u32,
    pub_state: Topic<ConveyorState>,
}

impl ConveyorDriver {
    fn from_params(params: &DriverParams) -> HorusResult<Self> {
        let port_name = params.get::<String>("port")?;
        let baud = params.get_or("baudrate", 57600u32);
        Ok(Self {
            port: serialport::new(&port_name, baud).open()?,
            belt_length: params.get_or("belt_length_mm", 2400),
            pub_state: Topic::new("conveyor.state")?,
        })
    }
}

impl Node for ConveyorDriver {
    fn tick(&mut self) {
        let pos = self.read_encoder();
        self.pub_state.send(&ConveyorState { position_mm: pos });
    }
    fn enter_safe_state(&mut self) {
        self.write_speed(0.0);
    }
}

// One line — registers the factory
register_driver!(ConveyorDriver, ConveyorDriver::from_params);

[drivers.conveyor]
node = "ConveyorDriver"
port = "/dev/ttyACM0"
baudrate = 57600
belt_length_mm = 2400

let mut hw = drivers::load()?;
scheduler.add(hw.local("conveyor")?)
    .order(100)
    .rate(50_u64.hz())
    .build()?;

match hw.driver_type("arm") {
    Some(DriverType::Terra(name))   => println!("Terra: {}", name),
    Some(DriverType::Package(pkg))  => println!("Package: {}", pkg),
    Some(DriverType::Local(node))   => println!("Local: {}", node),
    Some(DriverType::Legacy)        => println!("Legacy feature flag"),
    None                            => println!("Not configured"),
}

// Concrete type — most common
scheduler.add(ArmDriver::new(handle)).build()?;

// Box<dyn Node> — from hw.local() or hw.package()
scheduler.add(hw.local("conveyor")?).build()?;

// Both use the same .add() — full builder API available
scheduler.add(hw.local("sensor")?)
    .order(5)
    .rate(500_u64.hz())
    .on_miss(Miss::Skip)
    .failure_policy(FailurePolicy::restart(3, 100_u64.ms()))
    .build()?;

# horus.toml
[package]
name = "my-robot"
version = "0.1.0"

[drivers.arm]
terra = "dynamixel"
port = "/dev/ttyUSB0"
baudrate = 1000000
servo_ids = [1, 2, 3, 4, 5, 6]

[drivers.lidar]
terra = "rplidar"
port = "/dev/ttyUSB1"

[drivers.imu]
terra = "bno055"
bus = "i2c-1"
address = 0x28

use horus::prelude::*;
use horus::drivers;

fn main() -> HorusResult<()> {
    let mut hw = drivers::load()?;

    let mut sched = Scheduler::new()
        .tick_rate(1000_u64.hz())
        .prefer_rt()
        .watchdog(200_u64.ms());

    sched.add(ArmDriver::new(hw.dynamixel("arm")?))
        .order(0).rate(500_u64.hz())
        .on_miss(Miss::SafeMode)
        .build()?;

    sched.add(LidarDriver::new(hw.rplidar("lidar")?))
        .order(10).rate(40_u64.hz())
        .on_miss(Miss::Skip)
        .build()?;

    sched.add(ImuDriver::new(hw.i2c("imu")?))
        .order(5).rate(100_u64.hz())
        .build()?;

    sched.add(Planner::new())
        .order(50).rate(10_u64.hz()).compute()
        .build()?;

    sched.run()
}

# tests/test_drivers.toml
[drivers.arm]
terra = "virtual"
joints = 6

[drivers.lidar]
terra = "virtual"
type = "lidar"

#[test]
fn robot_initializes() {
    let mut hw = drivers::load_from("tests/test_drivers.toml").unwrap();
    let mut sched = Scheduler::new().deterministic(true);

    sched.add(ArmDriver::new(hw.dynamixel("arm").unwrap()))
        .build().unwrap();

    sched.tick_once().unwrap();
}