Using Pre-Built Nodes

The HORUS Philosophy: Don't reinvent the wheel. Use comprehensive, battle-tested nodes from the registry and horus_library, then configure them to work together.

Why Use Pre-Built Nodes?

Advantages of pre-built nodes:

Production-ready and tested
Configure instead of coding
Focus on application logic, not infrastructure
Nodes use standard HORUS interfaces for interoperability

Quick Example

Instead of writing a PID controller from scratch, just install and configure:

# Install from registry
horus install pid-controller

use pid_controller::PIDNode;
use horus::prelude::*;

fn main() -> Result<()> {
    let mut scheduler = Scheduler::new();

    // Configure the pre-built node
    let pid = PIDNode::new(1.0, 0.1, 0.01);  // kp, ki, kd
    scheduler.add(pid).order(5).build()?;

    scheduler.run()?;
    Ok(())
}

That's it! Production-ready PID control in 3 lines.

Discovering Pre-Built Nodes

From the Registry

Web Interface:

# Visit the registry in your browser
https://registry.horusrobotics.dev

Browse by category:

Control - PID controllers, motion planners
Perception - Camera, LIDAR, sensor fusion
Drivers - Motor controllers, sensor interfaces
Safety - Emergency stop, watchdogs
Utilities - Loggers, data recorders

CLI Search:

# Search for specific functionality
horus list sensor
horus list controller
horus list motor

From Standard Library

The horus_library crate includes standard message types used across nodes:

use horus::prelude::*;

// Motion messages
CmdVel, Twist, Pose2D, Odometry

// Sensor messages
LaserScan, Imu, BatteryState, PointCloud

// Input messages
KeyboardInput, JoystickInput

// And many more...

Note: Hardware-interfacing nodes (sensor drivers, motor controllers, etc.) are available as registry packages or Python nodes -- they are not built into horus_library. Search the registry for ready-made nodes.

Installation Patterns

Installing from HORUS Registry

# Latest version
horus install motion-planner

# Specific version
horus install sensor-fusion -v 2.1.0

# Multiple packages
horus install pid-controller motion-planner sensor-drivers

Installing from crates.io

# Rust packages are auto-detected
horus install serde
horus install tokio -v 1.35.0

Installing from PyPI

# Python packages are auto-detected
horus install numpy
horus install opencv-python

Using Standard Library

The standard library is available automatically with horus run:

horus run main.rs
# horus_library is included by default

Or explicitly in your Cargo.toml:

[dependencies]
horus = { path = "..." }
horus_library = { path = "..." }

The Idiomatic Pattern

1. Discover What You Need

Example Goal: Build a mobile robot with keyboard control

Required Nodes:

Input: Keyboard control
Control: Velocity command processing
Output: Motor driver

2. Search and Install

# Check what's available
horus list keyboard
horus list motor

# Install what you need
horus install keyboard-input
horus install differential-drive

3. Configure and Compose

use keyboard_input::KeyboardNode;
use differential_drive::DiffDriveNode;
use horus::prelude::*;

fn main() -> Result<()> {
    let mut scheduler = Scheduler::new();

    // Keyboard input node (order 0 - runs first)
    let keyboard = KeyboardNode::new("keyboard.input")?;
    scheduler.add(keyboard).order(0).build()?;

    // Differential drive controller (order 5)
    let drive = DiffDriveNode::new(
        "keyboard.input",   // Input topic
        "motor.left",       // Left motor output
        "motor.right",      // Right motor output
        0.5                 // Wheel separation (meters)
    )?;
    scheduler.add(drive).order(5).build()?;

    scheduler.run()?;
    Ok(())
}

That's it! A functional robot in ~20 lines, no custom nodes needed.

Common Workflows

Mobile Robot Base

# Install components
horus install keyboard-input
horus install differential-drive
horus install emergency-stop

use keyboard_input::KeyboardNode;
use differential_drive::DiffDriveNode;
use emergency_stop::EStopNode;
use horus::prelude::*;

fn main() -> Result<()> {
    let mut scheduler = Scheduler::new();

    // Input
    scheduler.add(KeyboardNode::new("keyboard")?).order(0).build()?;

    // Safety (runs first!)
    scheduler.add(EStopNode::new("estop", "cmd_vel")?).order(0).build()?;

    // Drive control
    scheduler.add(DiffDriveNode::new("cmd_vel", "motor.left", "motor.right", 0.5)?)
        .order(1).build()?;

    scheduler.run()?;
    Ok(())
}

Sensor Fusion System

horus install lidar-driver
horus install imu-driver
horus install kalman-filter

use lidar_driver::LidarNode;
use imu_driver::ImuNode;
use kalman_filter::EKFNode;
use horus::prelude::*;

fn main() -> Result<()> {
    let mut scheduler = Scheduler::new();

    // Sensors (order 2)
    scheduler.add(LidarNode::new("/dev/ttyUSB0", "scan")?).order(2).build()?;
    scheduler.add(ImuNode::new("/dev/i2c-1", "imu")?).order(2).build()?;

    // Fusion (order 3 - runs after sensors)
    scheduler.add(EKFNode::new("scan", "imu", "pose")?).order(3).build()?;

    scheduler.run()?;
    Ok(())
}

Vision Processing Pipeline

# Install vision packages from registry
horus install camera-driver
horus install image-processor
horus install object-detector

use camera_driver::CameraNode;
use image_processor::ImageProcessorNode;
use object_detector::ObjectDetectorNode;
use horus::prelude::*;

fn main() -> Result<()> {
    let mut scheduler = Scheduler::new();

    // Using registry packages
    let camera = CameraNode::new("/dev/video0", "camera.raw", 30)?;
    let processor = ImageProcessorNode::new("camera.raw", "camera.processed")?;
    let detector = ObjectDetectorNode::new("camera.processed", "objects")?;

    scheduler.add(camera).order(2).build()?;
    scheduler.add(processor).order(3).build()?;
    scheduler.add(detector).order(3).build()?;

    scheduler.run()?;
    Ok(())
}

Configuration Best Practices

Use Builder Patterns

Many registry packages support fluent configuration:

// Example: camera-driver package from registry
let camera = CameraNode::new("/dev/video0")?
    .with_resolution(1920, 1080)
    .with_fps(60)
    .with_format(ImageFormat::RGB8);

scheduler.add(camera).order(2).build()?;

Parameter-Based Configuration

Configure nodes via the parameter system:

use horus::prelude::*;

// Set parameters via RuntimeParams
let params = RuntimeParams::init()?;
params.set("motor.max_speed", 2.0)?;
params.set("motor.acceleration", 0.5)?;

// Node reads from parameters
let motor = MotorNode::from_params()?;
scheduler.add(motor).order(1).build()?;

Adjust at runtime via monitor!

Environment-Based Setup

# Save your configuration
horus env freeze -o robot-config.yaml

# Deploy to another robot
horus env restore robot-config.yaml

Composing Complex Systems

Pipeline Pattern

Chain nodes together via topics:

Loading diagram...

// Each node subscribes to previous, publishes to next
scheduler.add(sensor).order(2).build()?;       // Publishes "raw"
scheduler.add(filter).order(3).build()?;       // Subscribes "raw", publishes "filtered"
scheduler.add(controller).order(4).build()?;   // Subscribes "filtered", publishes "cmd"
scheduler.add(actuator).order(5).build()?;     // Subscribes "cmd"

Parallel Processing

Multiple nodes at same priority run concurrently:

// All run in parallel (order 2)
scheduler.add(lidar).order(2).build()?;
scheduler.add(camera).order(2).build()?;
scheduler.add(imu).order(2).build()?;

Safety Layering

Critical nodes run first:

// Order 0 - Safety checks (runs first)
scheduler.add(watchdog).order(0).build()?;
scheduler.add(estop).order(0).build()?;

// Order 1 - Control
scheduler.add(controller).order(1).build()?;

// Order 2 - Sensors
scheduler.add(lidar).order(2).build()?;

// Order 4 - Logging (runs last)
scheduler.add(logger).order(4).build()?;

When to Build Custom Nodes

Use pre-built nodes when:

Functionality exists in the registry or horus_library
Node can be configured to your needs
Performance is acceptable

Build custom nodes when:

No existing node matches your hardware
Unique algorithm or business logic
Extreme performance requirements

Pro tip: Even then, consider:

Starting with a similar pre-built node
Forking and modifying it
Publishing your improved version back to the registry

Finding the Right Node

By Use Case

I need to...

Control a motor motor-driver, differential-drive, servo-controller
Read a sensor lidar-driver, camera-node, imu-driver
Process data kalman-filter, pid-controller, image-processor
Handle safety emergency-stop, safety-monitor, watchdog
Log data data-logger, rosbag-writer, csv-logger

By Hardware

# Search by device type
horus list lidar
horus list camera
horus list imu

By Category

Browse registry by category:

control - Motion control, PID, path following
perception - Sensors, computer vision, SLAM
planning - Path planning, motion planning
drivers - Hardware interfaces
safety - Safety systems, fault tolerance
utils - Logging, visualization, debugging

Package Quality Indicators

When choosing packages, look for:

High Download Count

Downloads: 5,234 (last 30 days)

Recent Updates

Last updated: 2025-09-28

Good Documentation

Documentation: 98% coverage

Active Maintenance

Issues: 2 open, 45 closed (96% resolution rate)

Complete Example: Autonomous Robot

Goal: Build an autonomous mobile robot that avoids obstacles

1. Install Components:

horus install lidar-driver
horus install obstacle-detector
horus install path-planner
horus install differential-drive
horus install emergency-stop

2. Compose System:

use lidar_driver::LidarNode;
use obstacle_detector::ObstacleDetectorNode;
use path_planner::LocalPlannerNode;
use differential_drive::DiffDriveNode;
use emergency_stop::EStopNode;
use horus::prelude::*;

fn main() -> Result<()> {
    let mut scheduler = Scheduler::new();

    // Safety (order 0 - runs first)
    scheduler.add(EStopNode::new("estop", "cmd_vel")?).order(0).build()?;

    // Sensors (order 1)
    scheduler.add(LidarNode::new("/dev/ttyUSB0", "scan")?).order(1).build()?;

    // Perception (order 2)
    scheduler.add(ObstacleDetectorNode::new("scan", "obstacles")?).order(2).build()?;

    // Planning (order 3)
    scheduler.add(LocalPlannerNode::new("obstacles", "cmd_vel")?).order(3).build()?;

    // Control (order 4)
    scheduler.add(DiffDriveNode::new("cmd_vel", "motor.left", "motor.right", 0.5)?).order(4).build()?;

    scheduler.run()?;
    Ok(())
}

That's a full autonomous robot in ~40 lines of configuration!

Next Steps

Package Management - Discover and manage packages
node! Macro - When you need custom functionality
Examples - See complete working systems