hubap2/ros2_hutalia

1. Repository shape

- This is a ROS 2 workspace (ros2_ws) containing one package, droneload.

- The repo is currently very small on disk: only camera_node.py is present in the package tree, while the README describes a broader multi-node system that is likely planned or partially implemented.

2. System purpose

- The project targets an autonomous drone delivery platform (“DroneLoad 2026”).

- The architecture is centered on sensor ingestion, perception, and autonomous navigation for an indoor/outdoor drone stack.

3. Core runtime environment

- The primary runtime is ROS 2 Humble.

- The system integrates with MAVROS and ArduCopter for flight control, which makes the drone stack depend on a PX4/ArduPilot-style autopilot bridge rather than direct motor control from ROS.

4. Sensor ingestion layer

- camera_node is the entry point for the vision pipeline.

- It converts Intel RealSense D4xx video into a ROS image stream on camera/image_raw, making camera data available to downstream perception nodes.

5. Perception / computer vision layer

- aruco_node consumes camera imagery and detects ArUco markers, publishing detections on aruco/markers.

- reconnaissance_node performs object recognition with ORB, publishing state or classification results on camera/object_status.

- These two nodes are separate perception branches: one for fiducials / localization cues, one for general object recognition.

6. Navigation / autonomy layer

- navigation_node is the control-orchestration boundary for autonomous movement.

- It fuses or coordinates inputs from MAVROS, Marvelmind indoor positioning, and LiDAR (via MatekSys 3901-L0X) to produce navigation decisions.

- This node is the main consumer of perception and localization outputs, and likely the main producer of flight commands to the autopilot bridge.

7. Main data flow

- The high-level flow is: RealSense camera → camera_node → image topics → aruco_node / reconnaissance_node → navigation decisions → MAVROS/ArduCopter.

- Parallel to that, Marvelmind + LiDAR feed the navigation stack for positioning and obstacle-aware motion.

8. Important architectural boundaries

- Sensor drivers / adapters: hardware-specific access to RealSense, Marvelmind, and LiDAR.

- Perception: image interpretation and marker/object detection.

- Autonomy / control: route planning, state management, and command generation.

- Flight-control bridge: MAVROS isolates ROS 2 logic from the autopilot implementation.

9. Communication model

- The architecture is topic-driven, which is standard ROS 2 pub/sub.

- The topic names in the README indicate explicit contracts between modules, especially camera/image_raw, aruco/markers, and camera/object_status.

10. Implementation language / package layout

- The visible file camera_node.py suggests at least part of the package is implemented in Python.

- The package layout under ros2_ws/src/droneload/droneload indicates a standard ROS 2 Python package structure rather than a monolithic application.

11. External dependencies that matter

- Intel RealSense D4xx: primary visual input.

- MAVROS / ArduCopter: flight control integration.

- Marvelmind: indoor localization input.

- MatekSys 3901-L0X: combines LiDAR and optical flow for navigation support.

12. What an architecture diagram should show

- At minimum: four logical blocks — sensor acquisition, vision perception, navigation/autonomy, and autopilot bridge.

- Show camera_node feeding both perception nodes, and show navigation_node consuming perception plus localization/safety sensors, then controlling the drone through MAVROS/ArduCopter.