thehardwarestore.ai

Webots is an open-source robot simulator providing a complete environment for modeling, programming, and simulating robots. It consists of a C++ Qt-based main application (src/webots) that manages 3D rendering via the custom WREN engine (src/wren), physics simulation via a forked ODE engine (src/ode) with fluid dynamics extensions, and a multi-language controller API (C, C++, Python, Java, MATLAB) in src/controller. The repository includes a vast library of reusable robot models, sensors, actuators, objects, vehicles, and environments under projects/, as well as extensive documentation (docs/) and a web-based streaming interface (resources/web/wwi). The architecture is modular: the simulation world is defined in VRML-based .wbt files, robots are instantiated from PROTO definitions, and controllers run as separate processes communicating via shared memory. Webots supports ROS integration, SUMO traffic simulation, and OpenStreetMap import. The project is actively maintained with comprehensive CI/CD, test suites, and packaging scripts.

This repository is a complete ROS2 software development kit for the Unitree Go2 quadruped robot. It provides a high-level SDK (go2_robot_sdk) with clean architecture (domain, application, infrastructure, presentation) that enables connection to the robot via WebRTC (Wi-Fi) or CycloneDDS (Ethernet), reception and decoding of real-time data (LiDAR, IMU, joint states, camera, odometry), and control commands (movement, stance, joystick). It includes multiple ROS2 packages: go2_interfaces (25+ custom message types), lidar_processor (Python and C++ nodes for LiDAR point cloud decoding and aggregation), speech_processor (ElevenLabs TTS with caching and robot playback), coco_detector (object detection using PyTorch FasterRCNN), and launch files for SLAM (slam_toolbox) and autonomous navigation (Nav2). The repository also contains URDF models, calibration files, RViz configurations, Docker support, and multi-robot namespace remapping. While primarily an application for controlling and monitoring the Go2 robot, it includes data-processing components (LiDAR decoding, IMU filtering, object detection) that give it a hybrid data-research character. The codebase demonstrates professional ROS2 development practices with modular design, abstract interfaces, and multiple language implementations.

This repository provides the ROS 2 Middleware (RMW) implementation for eProsima Fast DDS, a high-performance DDS (Data Distribution Service) implementation. It translates the standard ROS 2 RMW API (publish, subscribe, services, clients, events) into Fast DDS operations, enabling ROS 2 nodes to communicate over DDS. The codebase is structured into three packages: `rmw_fastrtps_cpp` (static typesupport using compile-time code generation), `rmw_fastrtps_dynamic_cpp` (runtime introspection-based typesupport), and `rmw_fastrtps_shared_cpp` (shared logic for both variants). It supports advanced features such as content-filtered subscriptions, loaned messages, zero-copy data sharing via buffer backends (including GPU offloading), DDS security (PKI-DH, AES-GCM, access control), and comprehensive QoS mapping. The architecture follows a layered design where the shared package contains the core RMW implementations, and the two variant packages provide thin wrappers that differ only in how type support is resolved. This is a foundational infrastructure package for ROS 2, not an end-user application; it is selected at runtime via the `RMW_IMPLEMENTATION` environment variable.

A ROS 2 node that performs real-time metric depth estimation and point cloud generation using Depth Anything V3 accelerated with TensorRT. The system subscribes to camera image and camera info topics, synchronizes them via approximate time, runs GPU-accelerated preprocessing and inference, then publishes a 32-bit float depth image and a colorized or monochrome point cloud. The pipeline includes GPU-side bicubic upscaling, focal-length-based metric scaling, sky detection with percentile-based fill, and optional debug visualization with FPS overlay. The repository provides a complete build system (ament_cmake, CUDA, TensorRT), a standalone engine generation tool, a Docker image, and an ONNX export script for the underlying PyTorch model. It is designed for autonomous driving and robotics perception applications requiring high frame rates (claimed 50 FPS on Quadro RTX 6000). The architecture is a monolithic ROS 2 component with a clean separation between the node, the TensorRT wrapper, and the GPU kernels.

Super-LIO is a LiDAR-Inertial Odometry (LIO) system implemented as a ROS2 application. It fuses IMU and LiDAR data using an Error-State Kalman Filter (ESKF) for state estimation and a novel OctVoxMap for efficient point cloud mapping and nearest-neighbor search. The system supports multiple LiDAR types (Livox, Hesai, Velodyne, Ouster, NCLT) and includes a relocation mode using pre-built maps with ICP/NDT initialization. The architecture is a monolithic ROS2 node with a state machine (KF initialization, map initialization, then continuous processing). Key data flows: IMU propagation, LiDAR scan motion undistortion, downsampling, point-to-plane residual optimization, map update, and odometry publication. The codebase demonstrates strong engineering with C++20, TBB parallelism, and well-structured Lie group math (SO3, SE3, S2) in a separate 'basic' library. The OctVoxMap component is a standout contribution with precomputed search orders for fast KNN queries.

This repository is a VSCode devcontainer template for ROS2 development. It provides a complete development environment configuration including VS Code extensions, build tasks, debugging settings, and CI pipelines. The core functionality is orchestrated through shell scripts (setup.sh, build.sh, test.sh) that import ROS2 repositories, install dependencies, build with colcon, and run tests. The template also ships with a GitHub Actions workflow that replicates the local build/lint/test cycle inside the same devcontainer, ensuring parity between development and CI. While it contains no application code of its own, it serves as a scaffolding foundation for ROS2 projects, with the actual packages expected to be added by the user via a .repos file or directly in the src/ directory. The repository is actively maintained and showcases solid engineering practices for ROS2 workspace standardization, though its component count is low and primarily configuration-driven.

GELLO is a general, low-cost teleoperation framework for robot manipulators. It uses a Dynamixel-based leader device to control various follower robots (Franka FR3, YAM, UR, xArm, Panda) in real-time via ZMQ-based distributed architecture. The system supports both simulation (MuJoCo) and real hardware, includes gravity compensation (FACTR) for YAM robots, and provides data collection pipelines for imitation learning. It also offers ROS2 integration for Franka FR3 with custom joint impedance controllers and gripper managers. The codebase is configuration-driven via YAML files and demonstrates strong engineering practices with pre-commit hooks, CI workflows, and reusable abstractions for robots, agents, and cameras.

This repository is the complete open-source hardware and software stack for the Roboto Origin bipedal robot, formerly known as Atom01. It is a hybrid monorepo covering mechanical design (CAD files, 3D printing, BOMs), electronics (PCB designs, firmware for a USB2CAN board), low-level ROS2 control (motor drivers, IMU, camera, inference), simulation and reinforcement learning training (roboparty_train with Isaac Sim/MuJoCo and PPO/AMP algorithms), navigation (LiDAR localization, UWB, path planning), and XR teleoperation. The repository is organized into multiple modules, each with its own build system (CMake, Zephyr, Python). The dominant character is an application (a robot system), but it includes a substantial data_research component in the training module where RL policies are trained using motion capture data. The codebase is well-structured, actively maintained, and provides a complete recipe for building and deploying a humanoid robot from scratch.

Despite being classified as application-oriented, henki_ros2_best_practices contains no executable software. It is a documentation/standards repository: a single, carefully authored Markdown document (henki_ros2_best_practices.md) codifying architecture and clean-code guidelines for ROS 2 development, plus a README explaining how to integrate the document into AI coding workflows (e.g., Claude Code via CLAUDE.md) and a pointer to a companion examples repo comparing agent-generated ROS 2 packages with and without the practices applied. The actual deliverable is a concise, opinionated standards document covering node single-responsibility, separation of application logic from ROS 2 communication, launch file conventions (XML preferred), YAML config-based parameter handling, throttled logging, semantic custom message interfaces in '_msgs' packages, service-vs-action selection with enum-style error codes, C++ for performance-critical loops, SingleThreadedExecutor preference, rosdep/vcs-tool dependency management, package documentation requirements, and unit-test-first strategies that avoid flaky ROS communication sleeps. In production, this repository functions as a knowledge artifact rather than a running system: humans read it as a reference, and AI coding agents consume it as an enforced standard when generating ROS 2 packages. There are no API endpoints, data flows, or runtime dependencies; its 'architecture' is the structure and specificity of the guidelines themselves. The document is self-contained and could be dropped into any ROS 2 team's repository or agent configuration with minimal adaptation, making it a genuinely reusable engineering asset despite the complete absence of code.

robot_localization is a ROS 2 package providing nonlinear state estimation for mobile robots using Extended (EKF) and Unscented Kalman Filters (UKF). It fuses multiple sensor inputs—including odometry, IMU, GPS, pose, and twist measurements—into a consistent, filtered pose estimate (position, orientation, velocities, accelerations) published as `/odometry/filtered` and broadcast as TF transforms following REP-105 conventions. The architecture is centered around a templated `RosFilter<T>` class that wraps the core `FilterBase` abstract class, handling measurement queuing, differential/relative modes, Mahalanobis outlier rejection, and diagnostic monitoring. Key entry points are `ekf_node`, `ukf_node`, and `navsat_transform_node` (for GPS-to-local Cartesian conversion), all instantiated from `ros_filter.cpp` and `navsat_transform.cpp`. The package also provides services like `SetPose`, `SetDatum`, `ToLL`, and `GetState`, and includes lifecycle node support for managed operation. The codebase is well-known for its extensive parameterization—each sensor input can be individually configured with update vectors, differential/relative flags, noise terms, and rejection thresholds—making it adaptable to diverse robot platforms. It depends on Eigen for linear algebra, GeographicLib for geodetic conversions, and standard ROS 2 infrastructure (tf2, diagnostic_updater). The core filter logic (`FilterBase`) and coordinate conversion utilities (`navsat_conversions.hpp`) are clean, isolated components that can be reused outside the ROS ecosystem. Despite its popularity and solid engineering, the repository shows signs of technical drift: incomplete ROS 1→ROS 2 migration, deprecated API usage (`rclcpp::Duration::from_seconds`), commented-out bag-based tests, and a monolithic `RosFilter` implementation that mixes configuration, callbacks, and filter logic. Issue templates explicitly state that the package will soon be deprecated and feature requests will not be addressed, indicating transition to a maintenance-only state.

micro_ros_setup is a ROS 2 package providing shell scripts and configuration to automate the creation, configuration, build, and flashing of micro-ROS firmware for embedded platforms. It orchestrates the cross-compilation of the micro-ROS client library (rclc, rmw_microxrcedds, etc.) against multiple RTOS targets (FreeRTOS, Zephyr, Android, host Linux) using colcon and platform-specific toolchains. The package acts as a build system integration layer: it creates a development workspace cloned from ROS 2 and micro-ROS repositories, applies platform-specific colcon metadata, handles transport selection (UART, UDP, USB), and builds/flashes the firmware binaries. It is not a running application but a set of tools that must be invoked from a ROS 2 workspace after building the package itself.

This repository is a collection of ROS 2 tutorial files for learning URDF (Unified Robot Description Format). It contains a series of URDF files that progressively introduce concepts such as visual shapes, joints, physical properties, materials, flexibility, physics properties, and Xacro macros. The package includes meshes for a gripper model, an RViz configuration file, and a launch file to visualize the robots in RViz using the urdf_launch package. The system does not run as a standalone application but provides resources to be used with ROS 2 for educational purposes. The launch file serves as a simple entry point to load and visualize any of the provided URDF models.

This repository is a comprehensive ROS2 (Robot Operating System 2) tutorial hosted as a static website built with GitBook. It covers ROS2 fundamentals including installation, communication mechanisms (topics, services, actions, parameters), essential tools (launch files, rosbag2, RViz2), coordinate transformations (TF2), and robot modeling (URDF/xacro). Content is presented in structured chapters with detailed explanations, code examples in both C++ and Python, and visual aids (images, GIFs). The site uses GitBook plugins for search (Lunr.js), expandable chapters, font settings, and social sharing. While the educational content is thorough and well-suited for newcomers to ROS2, the underlying technical stack relies on outdated versions of GitBook and jQuery (3.1.1), presenting known security vulnerabilities and indicating significant technical debt despite recent content updates. The repository does not contain standalone software components suitable for extraction, as its primary value lies in aggregated educational content rather than reusable code libraries.