Simulation

horus install horus-sim3d

horus run          # real hardware
horus run --sim    # simulated sensors via horus-sim3d

horus new my_robot
cd my_robot

[robot]
name = "turtlebot"
description = "robot.urdf"

[hardware]
lidar = { use = "rplidar", port = "/dev/ttyUSB0", sim = true, noise = 0.01 }
imu = { use = "bno055", bus = "/dev/i2c-1", sim = true }

horus run --sim

horus run

[robot]
name = "turtlebot"            # used in topic naming
description = "robot.urdf"    # URDF file path (passed to the simulator)
simulator = "sim3d"            # which simulator plugin (optional, default: sim3d)

[hardware]
lidar = { use = "rplidar", port = "/dev/ttyUSB0", sim = true, noise = 0.01 }
imu = { use = "bno055", bus = "/dev/i2c-1", sim = true }
camera = { use = "realsense" }
# camera has no sim = true -- stays real even in --sim mode

horus run --sim lidar          # only lidar is simulated, IMU + camera stay real
horus run --sim lidar camera   # lidar + camera simulated, IMU stays real
horus run --sim                # all devices with sim = true are simulated

[hardware.arm]
use = "dynamixel"
port = "/dev/ttyUSB0"
baudrate = 1000000
servo_ids = [1, 2, 3, 4, 5, 6]
sim = true

turtlebot.front_lidar.scan       # 2D LiDAR scan data
turtlebot.imu_sensor.imu         # IMU readings
turtlebot.rgb_camera.image       # RGB camera image
turtlebot.rgb_camera.depth       # Depth from an RGB-D camera
turtlebot.rgb_camera.camera_info # Camera intrinsics
turtlebot.odom                   # Robot-level odometry (no sensor_name)
turtlebot.cmd_vel                # Velocity commands (no sensor_name)
turtlebot.joint_state            # Joint positions (no sensor_name)

use horus::prelude::*;
use horus_library::messages::simulation::*;

// Create request/response topics
let req: Topic<SpawnRequest> = Topic::new("sim.spawn.request")?;
let resp: Topic<SpawnResponse> = Topic::new("sim.spawn.response")?;

// Spawn a box at position (2, 0.5, 0) with size 1x1x1
req.send(SpawnRequest {
    model: "box".into(),
    name: "obstacle_1".into(),
    position: [2.0, 0.5, 0.0],
    scale: [1.0, 1.0, 1.0],
    ..Default::default()
});

// Wait for response
std::thread::sleep(std::time::Duration::from_millis(50));
if let Some(response) = resp.recv() {
    if response.success {
        println!("Spawned entity {} with ID {}", response.name, response.entity_id);
    }
}

# simplified
# NOTE: SpawnRequest/SpawnResponse are not yet available in Python bindings.
# Use dict-based topics for simulation control from Python:
import horus

spawn_req = horus.Topic("sim.spawn.request")
spawn_req.send({
    "model": "box",
    "name": "obstacle_1",
    "position": [2.0, 0.5, 0.0],
    "scale": [1.0, 1.0, 1.0],
})

horus sim3d --config sim.toml --robot robot.urdf

[physics]
dt = 0.001                      # timestep in seconds (default: 1/240)
solver = "newton"                # "newton", "lcp", or "smooth"
integrator = "semi_implicit_euler" # "semi_implicit_euler", "rk4", "velocity_verlet", "implicit_euler"
max_iterations = 100
substeps = 1

[physics.contact]
damping = 0.5
stiffness = 100000.0

[world]
ground = true                    # enable ground plane
gravity = [0.0, -9.81, 0.0]     # gravity vector [x, y, z] in m/s^2
scene = "warehouse.yaml"         # optional scene file

[[world.objects]]
name = "wall_1"
model = "box"
position = [5.0, 1.0, 0.0]
scale = [0.2, 2.0, 10.0]
is_static = true

[world.terrain]
type = "heightfield"
source = "terrain.png"
size = [100.0, 100.0]
height_scale = 5.0

[sensors.front_lidar]
type = "lidar"
link = "lidar_link"              # URDF link to attach to
rate_hz = 10                     # publish rate (overrides URDF value)
rays = 360
range = [0.1, 30.0]
fov = 360.0
noise = { type = "gaussian", std = 0.01 }

[sensors.imu_sensor]
type = "imu"
link = "imu_link"
rate_hz = 100
noise = { type = "gaussian", std = 0.005 }

[actuators.drive]
type = "differential_drive"
topic = "cmd_vel"
wheel_radius = 0.033
wheel_separation = 0.16
max_speed = 1.0
max_torque = 2.0

[actuators.drive.motor_model]
type = "dc"                       # DC motor model for sim-to-real fidelity

[actuators.drive.latency]
command_ms = 5                    # simulated command latency
sensor_ms = 2                    # simulated sensor feedback latency

<robot name="turtlebot">
  <link name="lidar_link">
    <!-- link geometry -->
  </link>

  <gazebo reference="lidar_link">
    <sensor type="ray" name="front_lidar">
      <ray>
        <scan>
          <horizontal>
            <samples>360</samples>
            <min_angle>-3.14159</min_angle>
            <max_angle>3.14159</max_angle>
          </horizontal>
        </scan>
        <range>
          <min>0.1</min>
          <max>30.0</max>
        </range>
      </ray>
      <update_rate>10</update_rate>
    </sensor>
  </gazebo>
</robot>

# Override just the rate and add noise -- geometry comes from the URDF
[sensors.front_lidar]
type = "lidar"
rate_hz = 20                     # override URDF's 10 Hz to 20 Hz
noise = { type = "gaussian", std = 0.02 }

[package]
name = "my-robot"
version = "0.1.0"

[robot]
name = "turtlebot"
description = "robot.urdf"

[hardware]
lidar = { use = "rplidar", port = "/dev/ttyUSB0", sim = true, noise = 0.01 }
imu = { use = "bno055", bus = "/dev/i2c-1", sim = true }
camera = { use = "realsense", sim = true }

use horus::prelude::*;

fn main() -> anyhow::Result<()> {
    let scan: Topic<LaserScan> = Topic::new("turtlebot.front_lidar.scan")?;
    let imu_data: Topic<Imu> = Topic::new("turtlebot.imu_sensor.imu")?;
    let cmd: Topic<CmdVel> = Topic::new("turtlebot.cmd_vel")?;

    Scheduler::new()
        .add("navigator", |ctx| {
            // Read latest sensor data
            if let Some(scan) = scan.recv() {
                let min_range = scan.ranges.iter().copied().fold(f32::MAX, f32::min);

                if min_range < 0.5 {
                    // Obstacle close -- turn
                    cmd.send(CmdVel { linear_x: 0.0, angular_z: 0.5, ..Default::default() });
                } else {
                    // Clear path -- drive forward
                    cmd.send(CmdVel { linear_x: 0.3, angular_z: 0.0, ..Default::default() });
                }
            }
        })
        .rate(10.hz())
        .build()?;

    Ok(())
}

# Test in simulation first
horus run --sim

# Deploy to real hardware
horus run