seb/saltylab-firmware
1
0
Fork 0
Code Issues Pull Requests 5 Actions Packages Projects Releases Wiki Activity
697 Commits 390 Branches 0 Tags
Commit Graph

324 Commits

Author SHA1 Message Date
sl-jetson
039355d5bb feat: full_stack.launch.py — one-command autonomous stack bringup 
Adds saltybot_bringup/launch/full_stack.launch.py: a single launch file
that brings up the entire SaltyBot software stack in dependency order,
with mode selection (indoor / outdoor / follow).

Launch sequence (wall-clock delays):
  t= 0s  robot_description (URDF + TF)
  t= 0s  STM32 bidirectional serial bridge
  t= 2s  sensors (RPLIDAR A1M8 + RealSense D435i)
  t= 2s  cmd_vel safety bridge (deadman + ramp + AUTONOMOUS gate)
  t= 4s  UWB driver (MaUWB DW3000 anchors on USB)
  t= 4s  CSI cameras — 4x IMX219 (optional, enable_csi_cameras:=true)
  t= 6s  SLAM — RTAB-Map RGB-D+LIDAR (indoor only)
  t= 6s  Outdoor GPS nav (outdoor only)
  t= 6s  YOLOv8n person detection (TensorRT)
  t= 9s  Person follower (UWB primary + camera fusion)
  t=14s  Nav2 navigation stack (indoor only)
  t=17s  rosbridge WebSocket server (port 9090)

Modes:
  indoor  — SLAM + Nav2 + full sensor suite + follow + UWB (default)
  outdoor — GPS nav + sensors + follow + UWB (no SLAM)
  follow  — sensors + UWB + perception + follower only

Launch arguments:
  mode, use_sim_time, enable_csi_cameras, enable_uwb, enable_perception,
  enable_follower, enable_bridge, enable_rosbridge, follow_distance,
  max_linear_vel, uwb_port_a, uwb_port_b, stm32_port

Also updates saltybot_bringup/package.xml:
  - Adds exec_depend for all saltybot_* packages included by full_stack
  - Updates maintainer to sl-jetson

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-03-01 00:56:39 -05:00
sl-perception
e0987fcec8 feat: outdoor nav — OSM routing + GPS waypoints + geofence (#59) 
Implements Phase 2d outdoor autonomous navigation for SaltyBot.
GPS source: SIM7600X /gps/fix from PR #65 (saltybot_cellular).

saltybot_outdoor package:
- osm_router_node: Overpass API + A* haversine graph + Douglas-Peucker
  simplification, /outdoor/route (Path) + /outdoor/waypoints (PoseArray)
- gps_waypoint_follower_node: GPS->Nav2 navigate_through_poses bridge,
  quality-adaptive tolerances (2m cellular / 0.30m RTK)
- geofence_node: ray-casting polygon safety, emergency stop on violation
- outdoor_nav.launch.py: dual-EKF + navsat_transform + all nodes
- outdoor_nav_params.yaml: 1.5m/s, no static_layer, 2m GPS tolerance
- ekf_outdoor.yaml: robot_localization dual-EKF + navsat_transform
- geofence_vertices.yaml: template with usage instructions

docker-compose.yml: fix malformed saltybot-surround block; add
saltybot-outdoor service (depends on saltybot-nav2, OSM NVMe cache)

SLAM-SETUP-PLAN.md: Phase 2d done

RTK upgrade: SIM7600X (+-2.5m) -> ZED-F9P (+-2cm), set use_rtk:=true

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-03-01 00:52:54 -05:00
seb
64d411b48a Merge pull request 'feat: UWB follow-me system (#57)' (#66) from sl-jetson/uwb-follow-me into main 2026-03-01 00:51:20 -05:00
sl-jetson
a00dbe6429 feat: UWB follow-me system (#57) — saltybot_uwb package + sensor fusion 
New packages
------------
saltybot_uwb_msgs (ament_cmake)
  • UwbRange.msg     — per-anchor range reading (anchor_id, range_m, raw_mm, rssi)
  • UwbRangeArray.msg — array of UwbRange published on /uwb/ranges

saltybot_uwb (ament_python)
  • ranging_math.py    — pure triangulate_2anchor() (height-compensated TWR
                         geometry, 2-anchor intersection) + KalmanFilter2D
                         (constant-velocity, numpy-free, 16 tests pass)
  • uwb_driver_node.py — SerialReader threads poll MaUWB ESP32-S3 DW3000
                         anchors via AT+RANGE?, triangulate, Kalman-smooth,
                         publish /uwb/target (PoseStamped/base_link) + /uwb/ranges
  • config/uwb_config.yaml, launch/uwb.launch.py
  • test/test_ranging_math.py — 16 unit tests (triangulation + Kalman), all pass

Updated saltybot_follower
-------------------------
  • person_follower_node.py — adds fuse_targets() pure helper + /uwb/target
    subscriber (primary, weight=0.7); /person/target secondary (weight=0.3);
    weighted blend when both fresh, graceful fallback to single source; new
    params uwb_weight + uwb_timeout
  • person_follower_params.yaml — uwb_weight: 0.7, uwb_timeout: 1.0s
  • test_person_follower.py — 7 new TestFuseTargets cases; total 60 pass

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-03-01 00:48:03 -05:00
sl-controls
de9a835cc2 feat: SIM7600X 4G cellular + GPS driver (#58) 
Adds saltybot_cellular ROS2 package for the Waveshare SIM7600X 4G HAT
(SIMCom SIM7600A-H) providing GPS telemetry, modem monitoring, and
MQTT relay over cellular for remote operation.

gps_driver_node:
  - Opens /dev/ttyUSB2 (NMEA), optionally sends AT+CGPS=1 on /dev/ttyUSB0
  - Parses GGA (position) + RMC (velocity) from any NMEA talker (GP/GN/GL/GA)
  - Validates NMEA checksum before parsing
  - Publishes /gps/fix (NavSatFix, covariance from HDOP × ±2.5m CEP)
  - Publishes /gps/vel (TwistStamped, ENU vE/vN from course-over-ground)
  - Publishes /diagnostics (fix quality, sat count, HDOP)

cellular_manager_node:
  - Polls AT+CSQ, AT+CREG?, AT+COPS? every 5s over /dev/ttyUSB0
  - Publishes /cellular/status (DiagnosticArray: rssi, network, connected)
  - Publishes /cellular/rssi (Int32, dBm) and /cellular/connected (Bool)
  - Auto-reconnect via nmcli or pppd when data link drops

mqtt_bridge_node:
  - paho-mqtt client (graceful degradation if not installed)
  - ROS2→MQTT QoS 0: /saltybot/imu, /gps/fix, /gps/vel, /uwb/ranges,
      /person/target, /cellular/status
  - MQTT→ROS2 QoS 1: saltybot/cmd→/saltybot/cmd, saltybot/estop→/saltybot/estop
  - Per-topic rate limiting (imu:5Hz, gps:1Hz, person:2Hz) → <<50KB/s budget
  - Optional TLS, configurable broker/port/prefix/auth

Deliverables:
  saltybot_cellular/gps_driver_node.py      — 402 lines
  saltybot_cellular/cellular_manager_node.py — 362 lines
  saltybot_cellular/mqtt_bridge_node.py      — 317 lines
  config/cellular_params.yaml               — full config documented
  launch/cellular.launch.py                 — all nodes, all params as args
  test/test_cellular.py                     — 60 pytest tests, no ROS2

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-03-01 00:42:18 -05:00
sl-firmware
6420e07487 feat: rosbridge WebSocket server for web UI (port 9090) 
Adds rosbridge_suite to the Jetson stack so the browser dashboard can
subscribe to ROS2 topics via roslibjs over ws://jetson:9090.

docker-compose.yml
  New service: saltybot-rosbridge
  - Runs saltybot_bringup/launch/rosbridge.launch.py
  - network_mode: host → port 9090 directly reachable on Jetson LAN
  - Depends on saltybot-ros2, stm32-bridge, csi-cameras

saltybot_bringup/launch/rosbridge.launch.py
  - rosbridge_websocket node (port 9090, params from rosbridge_params.yaml)
  - 4× image_transport/republish nodes: compress CSI camera streams
    /camera/<name>/image_raw → /camera/<name>/image_raw/compressed (JPEG 75%)

saltybot_bringup/config/rosbridge_params.yaml
  Whitelisted topics:
    /map  /scan  /tf  /tf_static
    /saltybot/imu  /saltybot/balance_state
    /cmd_vel
    /person/*
    /camera/*/image_raw/compressed
  max_message_size: 10 MB (OccupancyGrid headroom)

saltybot_bringup/SENSORS.md
  Added rosbridge connection section with roslibjs snippet,
  topic reference table, bandwidth estimates, and throttle_rate tips.

saltybot_bringup/package.xml
  Added exec_depend: rosbridge_server, image_transport,
  image_transport_plugins (all already installed in Docker image).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-03-01 00:22:02 -05:00
seb
fcd59ead80 Merge pull request 'feat: person-following control loop' (#55) from sl-controls/person-follower into main 2026-02-28 23:25:40 -05:00
seb
9014b6738d Merge pull request 'feat: person detection + tracking (YOLOv8n TensorRT)' (#54) from sl-jetson/person-detection into main 2026-02-28 23:25:22 -05:00
sl-controls
432d5cb267 feat: person-following control loop (Phase 2b) 
Adds saltybot_follower ROS2 package — proportional person-following
controller that bridges sl-jetson's /person/target detections to Nav2
/cmd_vel, with the cmd_vel_bridge_node (PR #46) providing safety wrapping.

Controller features:
  - Proportional control: linear.x ∝ distance error, angular.z ∝ bearing
  - Follow distance: 1.5m default with ±0.3m dead zone (no jitter at target)
  - Max speed: 0.5 m/s linear, 1.0 rad/s angular (conservative for balance)
  - Obstacle override: zeroes forward cmd_vel when Nav2 local costmap
    detects obstacle in forward corridor; turning still allowed
  - Lost-target state machine:
      FOLLOWING  → person visible
      STOPPING   → lost > 2s, publish zero
      SEARCHING  → lost > 5s, slow rotation (0.3 rad/s) to re-acquire
  - Mode integration: follow_enabled param (toggle via ros2 param set)
    independently gates the controller; cmd_vel bridge gates on md=2

Deliverables:
  saltybot_follower/person_follower_node.py   — ROS2 node (314 lines)
  config/person_follower_params.yaml          — all params documented
  launch/person_follower.launch.py            — all params as launch args
  test/test_person_follower.py                — 53 pytest tests, no ROS2
  package.xml / setup.py / setup.cfg          — package metadata

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-02-28 23:22:49 -05:00
sl-jetson
c44a30561a feat: person detection + tracking (YOLOv8n TensorRT) 
New package: saltybot_perception

person_detector_node.py:
- Subscribes /camera/color/image_raw + /camera/depth/image_rect_raw
  (ApproximateTimeSynchronizer, slop=50ms)
- Subscribes /camera/color/camera_info for intrinsics
- YOLOv8n inference via TensorRT FP16 engine (Orin Nano 67 TOPS)
  Falls back to ONNX Runtime when engine not found (dev/CI)
- Letterbox preprocessing (640x640), YOLOv8n post-process + NMS
- Median-window depth lookup at bbox centre (7x7 px)
- Back-projects 2D pixel + depth to 3D point in camera frame
- tf2 transform to base_link (fallback: camera_color_optical_frame)
- Publishes:
    /person/detections  vision_msgs/Detection2DArray  all persons
    /person/target      geometry_msgs/PoseStamped     tracked person 3D
    /person/debug_image sensor_msgs/Image              (optional)

tracker.py — SimplePersonTracker:
- Single-target IoU-based tracker
- Picks closest valid person (smallest depth) on first lock
- Re-associates across frames using IoU threshold
- Holds last known position for configurable duration (default 2s)
- Monotonically increasing track IDs

detection_utils.py — pure helpers (no ROS2 deps, testable standalone):
- nms(), letterbox(), remap_bbox(), get_depth_at(), pixel_to_3d()

scripts/build_trt_engine.py:
- Converts ONNX to TensorRT FP16 engine using TRT Python API
- Prints trtexec CLI alternative
- Includes YOLOv8n download instructions

config/person_detection_params.yaml:
- confidence_threshold: 0.40, min_depth: 0.5m, max_depth: 5.0m
- track_hold_duration: 2.0s, target_frame: base_link

launch/person_detection.launch.py:
- engine_path, onnx_path, publish_debug_image, target_frame overridable

Tests: 26/26 passing (test_tracker.py + test_postprocess.py)
- IoU computation, NMS suppression, tracker state machine,
  depth filtering, hold duration, re-association, track ID

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-02-28 23:21:24 -05:00
sl-perception
dc01efe323 feat: 4x IMX219 surround vision + Nav2 camera obstacle layer (Phase 2c) 
New ROS2 package saltybot_surround:

surround_costmap_node
  - Subscribes to /camera/{front,left,rear,right}/image_raw
  - Detects obstacles via Canny edge detection + ground projection
  - Pinhole back-projection: pixel row → forward distance (d = h*fy/(v-cy))
  - Rotates per-camera points to base_link frame using known camera yaws
  - Publishes /surround_vision/obstacles (PointCloud2, 5 Hz)
  - Catches chairs, glass walls, people that RPLIDAR misses
  - Placeholder IMX219 fisheye calibration (hook for real cal via cv2.fisheye)

surround_vision_node
  - IPM homography computed from camera height + pinhole model
  - 4× bird's-eye patches composited into 240×240px 360° overhead view
  - Publishes /surround_vision/birdseye (Image, 10 Hz)
  - Robot footprint + compass overlay

surround_vision.launch.py
  - Launches both nodes with surround_vision_params.yaml
  - start_cameras arg: set false when csi-cameras container runs separately

Updated:
- jetson/config/nav2_params.yaml   add surround_cameras PointCloud2 source
                                    to local + global costmap obstacle_layer
- jetson/docker-compose.yml        add saltybot-surround service
                                    (depends_on: csi-cameras, start_cameras:=false)
- projects/saltybot/SLAM-SETUP-PLAN.md  Phase 2c ✅ Done

Calibration TODO (run after hardware assembly):
  ros2 run camera_calibration cameracalibrator --size 8x6 --square 0.025 \
    image:=/camera/front/image_raw camera:=/camera/front
  Replace placeholder K/D in surround_costmap_node._undistort()

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-02-28 23:19:23 -05:00
seb
5008e03cc4 Merge pull request 'feat: Orin Nano Super platform update + 4x IMX219 CSI cameras' (#51) from sl-jetson/orin-platform-cameras into main 2026-02-28 23:08:49 -05:00
seb
54d3e12c78 Merge pull request 'feat: Phase 2a URDF robot description + static TF for SLAM/Nav2' (#50) from sl-firmware/robot-urdf into main 2026-02-28 23:08:46 -05:00
sl-jetson
3755e235aa feat: Orin Nano Super platform update + 4x IMX219 CSI cameras 
Task A — Orin Nano Super platform update:
- docker-compose.yml: update header/comments, switch all service image tags
  to jetson-orin, update devices to udev symlinks (/dev/rplidar,
  /dev/stm32-bridge, i2c-7), add NVMe volume mounts (/mnt/nvme/saltybot),
  update stm32-bridge to saltybot_bridge launch, add csi-cameras service
- docs/pinout.md: full rewrite for Orin Nano Super — i2c-7, ttyTHS0,
  CSI-A/B connectors, M.2 NVMe slot, IMX219 15-pin FFC pinout, V4L2 nodes,
  GStreamer test commands, updated udev rules
- docs/power-budget.md: full rewrite — 25W TDP, 8GB LPDDR5, 67 TOPS,
  4-camera CSI bandwidth analysis, nvpmodel modes, Nano vs Orin comparison,
  5V 6A PSU recommendation, 4S LiPo architecture
- scripts/setup-jetson.sh: full rewrite — JetPack 6 / Ubuntu 22.04,
  nvidia-container-toolkit new keyring method, NVMe partition/format/fstab,
  CSI driver check (imx219 modprobe), video group, jtop install, 8GB swap

Task B — saltybot_cameras ROS2 package:
- launch/csi_cameras.launch.py: 4x v4l2_camera nodes, namespace per camera
  (front/left/rear/right), 640x480x30fps, includes TF launch automatically
- launch/camera_tf.launch.py: static TF for 4 cameras at 90deg intervals
  on sensor_head_link (r=5cm offset), yaw 0/90/180/-90 deg
- package.xml, setup.py, setup.cfg, __init__.py, resource marker
- config/cameras_params.yaml: per-camera device/frame/offset configuration

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-02-28 22:59:13 -05:00
seb
3f627ac3c8 Merge pull request 'feat: Nav2 path planning + obstacle avoidance (Phase 2b)' (#49) from sl-perception/nav2-integration into main 2026-02-28 22:58:49 -05:00
sl-firmware
b4bb6a44e0 feat: Phase 2a URDF robot description for SLAM and Nav2 
Add saltybot_description ROS2 package with full kinematic model:

urdf/saltybot.urdf.xacro
  - base_footprint → base_link (axle_height = 0.310m, from AXLE_HEIGHT SCAD)
  - wheel_left/right_link (continuous, separation=0.600m, radius=0.1015m)
  - imu_link (FC/MPU-6000 at x=+50mm forward, z=+12mm)
  - stem_link (visual: 38.1mm EMT, 1.050m — from stem_battery_clamp.scad)
  - sensor_head_link at top of stem
    - laser (RPLIDAR A1M8, z=COL_H=36mm — frame matches slam_toolbox config)
    - camera_link (RealSense D435i, ARM_R=50mm — matches realsense2_camera)
    - camera_{front,left,rear,right}_link (IMX219, 10° down tilt, ARM_R=50mm
      — positions match camera_tf.launch.py; that file superseded when live)

config/saltybot_properties.yaml
  All dimensions from chassis/chassis_frame.scad + ASSEMBLY.md Rev A.

launch/robot_description.launch.py
  Compiles xacro at launch time, runs robot_state_publisher.
  Publishes /robot_description + /tf_static for all fixed joints.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-02-28 22:57:58 -05:00
sl-perception
772a70b545 feat: Nav2 path planning + obstacle avoidance (Phase 2b) 
Integrates Nav2 autonomous navigation stack with RTAB-Map SLAM on Orin
Nano Super. No AMCL/map_server needed — RTAB-Map provides /map + TF.

New files:
- jetson/config/nav2_params.yaml                           DWB controller,
  NavFn planner, RPLIDAR obstacle layer, RealSense voxel layer;
  10Hz local / 5Hz global costmap; robot_radius 0.15m, max_vel 1.0 m/s
- jetson/ros2_ws/src/saltybot_bringup/launch/nav2.launch.py
  wraps nav2_bringup navigation_launch with saltybot params + BT XML
- jetson/ros2_ws/src/saltybot_bringup/behavior_trees/
    navigate_to_pose_with_recovery.xml  BT: replan@1Hz, DWB follow,
    recovery: clear maps → spin 90° → wait 5s → back up 0.30m

Updated:
- jetson/docker-compose.yml             add saltybot-nav2 service
                                        (depends_on: saltybot-ros2)
- jetson/ros2_ws/src/saltybot_bringup/setup.py   install behavior_trees/*.xml
- jetson/ros2_ws/src/saltybot_bringup/package.xml add rtabmap_ros + nav2_bringup
- projects/saltybot/SLAM-SETUP-PLAN.md  Phase 2b ✅ Done

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-02-28 22:54:24 -05:00
sl-controls
a50f22d56b feat: Nav2 cmd_vel to STM32 autonomous drive bridge 
Adds cmd_vel_bridge_node — a standalone ROS2 node that subscribes to
Nav2 /cmd_vel and drives the STM32 over USB CDC with:
  - Hard velocity limits (max_linear_vel=0.5 m/s, max_angular_vel=2.0 rad/s)
  - Smooth ESC ramp (500 ESC-units/s, 50 Hz control loop)
  - Deadman switch: zeros targets if /cmd_vel silent >500 ms
  - Mode gate: sends drive only when STM32 reports md=2 (AUTONOMOUS)
  - Telemetry RX → /saltybot/imu, /saltybot/balance_state, /diagnostics
  - Heartbeat TX every 200 ms (H\n)

Deliverables:
  saltybot_bridge/cmd_vel_bridge_node.py   — node implementation
  config/cmd_vel_bridge_params.yaml        — tunable parameters
  launch/cmd_vel_bridge.launch.py          — standalone launch file
  test/test_cmd_vel_bridge.py              — 37 pytest unit tests (no ROS2)
  setup.py                                 — register node + new data files

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-02-28 22:50:15 -05:00
sl-perception
c5d6a72d39 feat: update SLAM stack for Jetson Orin Nano Super (67 TOPS, JetPack 6) 
Platform upgrade: Jetson Nano 4GB → Orin Nano Super 8GB (March 1, 2026)
All Nano-era constraints removed — power/rate/resolution limits obsolete.

Dockerfile: l4t-jetpack:r36.2.0 (JetPack 6 / Ubuntu 22.04 / CUDA 12.x),
  ROS2 Humble via native apt, added ros-humble-rtabmap-ros,
  ros-humble-v4l2-camera for future IMX219 CSI (Phase 2c)

New: slam_rtabmap.launch.py — Orin primary SLAM entry point
  RTAB-Map with subscribe_scan (RPLIDAR) + subscribe_rgbd (D435i)
  Replaces slam_toolbox as docker-compose default

New: config/rtabmap_params.yaml — Orin-optimized
  DetectionRate 10Hz, MaxFeatures 1000, Grid/3D true,
  TimeThr 0 (no limit), Mem/STMSize 0 (unlimited)

Updated: config/realsense_d435i.yaml — 848x480x30, pointcloud enabled
Updated: config/slam_toolbox_params.yaml — 10Hz rate, 1s map interval
Updated: SLAM-SETUP-PLAN.md — full rewrite for Orin: arch diagram,
  Phase 2c IMX219 plan (4x 160° CSI surround), 25W power budget

docker-compose.yml: image tag jetson-orin, default → slam_rtabmap.launch.py

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-02-28 21:46:27 -05:00
sl-jetson
22aaeb02cf feat: Jetson→STM32 command protocol — /cmd_vel to serial (Phase 2) 
STM32 firmware (C):
- include/jetson_cmd.h: protocol constants (HB_TIMEOUT_MS=500,
  SPEED_MAX_DEG=4°), API for jetson_cmd_process/is_active/steer/sp_offset
- src/jetson_cmd.c: main-loop parser for buffered C<spd>,<str> frames;
  setpoint offset = speed/1000 * 4°; steer clamped ±1000
- lib/USB_CDC/src/usbd_cdc_if.c: add H (heartbeat) and C (drive cmd) to
  CDC_Receive ISR — follows existing pattern: H updates jetson_hb_tick in
  ISR, C copied to jetson_cmd_buf for main-loop sscanf (avoids sscanf in IRQ)
- src/main.c: integrate jetson_cmd — process buffered frame, apply setpoint
  offset around balance_update(), inject steer into motor_driver_update()
  only when heartbeat alive (fallback: steer=0, setpoint unchanged)

ROS2 (Python):
- saltybot_cmd_node.py: full bidirectional node — owns serial port, handles
  telemetry RX → topics AND /cmd_vel TX → C<spd>,<str>\n + H\n heartbeat
  200ms timer; sends C0,0\n on shutdown; speed/steer_scale configurable
- serial_bridge_node.py: add write_serial() helper for extensibility
- launch/bridge.launch.py: mode arg (bidirectional|rx_only) selects node
- config/bridge_params.yaml: heartbeat_period, speed_scale, steer_scale docs
- test/test_cmd.py: 13 tests — zero, full fwd/rev, turn clamping, combined
- setup.py: saltybot_cmd_node entry point

All 21 tests pass (8 parse + 13 cmd).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-02-28 21:07:15 -05:00
seb
a89297f1d4 Merge pull request 'feat(bd-a2j): Sensor driver integration — RealSense D435i + RPLIDAR A1M8' (#17) from sl-perception/bd-a2j-sensor-drivers into main 2026-02-28 17:19:41 -05:00
sl-perception
76067d6d89 feat(bd-a2j): RealSense D435i + RPLIDAR A1M8 ROS2 driver integration 
Adds saltybot_bringup ROS2 package with four launch files:
  - realsense.launch.py  — D435i at 640x480x15fps, IMU unified topic
  - rplidar.launch.py    — RPLIDAR A1M8 via /dev/rplidar udev symlink
  - sensors.launch.py    — both sensors + static TF (base_link→laser/camera)
  - slam.launch.py       — sensors + slam_toolbox online_async (compose entry point)

Sensor config YAMLs (mounted at /config/ in container):
  - realsense_d435i.yaml  — Nano power-budget settings (15fps, no pointcloud)
  - rplidar_a1m8.yaml     — Standard scan mode, 115200 baud, laser frame
  - slam_toolbox_params.yaml — Nano-tuned (2Hz processing, 5cm resolution)

Fixes docker-compose volume mount: ./ros2_ws/src:/ros2_ws/src
(was ./ros2_ws:/ros2_ws/src — would have double-nested the src directory)

Topic reference and verification commands in SENSORS.md.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-02-28 17:14:21 -05:00
sl-jetson
7c4e46aaa1 feat: STM32-to-Jetson ROS2 serial bridge node 
saltybot_bridge ROS2 Python package (ament_python):
- serial_bridge_node.py: reads USB CDC JSON telemetry from STM32F722 at 50Hz
  Parses exact firmware format: {"p","r","e","ig","m","s","y"} (all ×10 ints)
  State enum: 0=DISARMED, 1=ARMED, 2=TILT_FAULT (matched to balance_state_t)
- Publishes sensor_msgs/Imu on /saltybot/imu (pitch/roll/yaw as angular_velocity)
- Publishes std_msgs/String on /saltybot/balance_state (full PID JSON diagnostics)
- Publishes diagnostic_msgs/DiagnosticArray on /diagnostics (OK/WARN/ERROR by state)
- Auto-reconnects on serial disconnect; IMU fault frames → ERROR diagnostic
- launch/bridge.launch.py with serial_port + baud_rate launch args
- config/bridge_params.yaml (921600 baud, /dev/ttyACM0)
- test/test_parse.py: 8 unit tests covering normal, fault, edge cases (all pass)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-02-28 17:11:02 -05:00
sl-jetson
c47ac41573 feat: Jetson Nano platform setup and Docker env (bd-1hcg) 
- Dockerfile: L4T R32.6.1 (JetPack 4.6) base + ROS2 Humble + SLAM stack
  (slam_toolbox, Nav2, rplidar_ros, realsense2_camera, robot_localization)
- docker-compose.yml: multi-service stack (ROS2, RPLIDAR A1M8, D435i, STM32 bridge)
  with device passthrough, host networking for DDS, persistent map volume
- docs/pinout.md: full GPIO/I2C/UART pinout for STM32F722 bridge (USB CDC +
  UART fallback), RealSense D435i (USB3), RPLIDAR A1M8, udev rules
- docs/power-budget.md: 10W envelope analysis with per-component breakdown,
  mitigation strategies (RPLIDAR gating, D435i 640p, nvpmodel modes)
- scripts/setup-jetson.sh: host one-shot setup (Docker, nvidia-container-runtime,
  udev rules, MAXN power mode, swap)
- scripts/build-and-run.sh: build/up/down/shell/slam/status helper

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-02-28 12:46:14 -05:00