Find Robot Operating System Projects

PCB design and firmware for a safety sensor. PCB needs to have deep deep sleep capabilities, very low power consumption, wanting to have bluetooth abilities, but will not use the bluetooth until a later version of the design, but would like to design with the intent to use bluetooth. Firmware will be fairly simple. if a switch is on and the accelerometer detects motion, a buzzer will go off until switch is turned off, or motion stops.

We are a specialized AI/ML engineering team working on a high volume of complex projects across diverse industries (including Health Tech, AgTech, and Industrial Automation). As our project pipeline grows, we are looking to expand our core team with a highly skilled and hands-on Computer Vision Engineer.
This is an ongoing, long-term opportunity to join a collaborative environment and work alongside other senior AI professionals to tackle real-world vision problems, from 2D object detection to 3D image segmentation and feature extraction.

Core Responsibilities:

- Collaborate with our existing engineering team on the design and implementation of computer vision pipelines (Object Detection, Semantic Classification, Image Segmentation).
- Train, fine-tune, and evaluate deep learning models using PyTorch and TensorFlow.
- Perform data preprocessing, augmentation, and handling of large-scale image/video datasets.
- Optimize models for inference and assist in integrating computer vision APIs into our broader software architecture.
- Write clean, well-documented, and production-ready Python code while participating in code reviews with the team.

Mandatory Skills & Expertise:

- Strong proficiency in Python and core computer vision libraries (OpenCV).
- Proven hands-on experience with PyTorch (preferred) or TensorFlow.
- Solid background in implementing architectures like YOLO, SSD, or similar for object detection/segmentation.
- Experience with deep learning model evaluation and performance tuning.

Nice to Have:

- Experience with 3D Reconstruction, Stereo Matching, or Multi-view Geometry.
- Knowledge of C++ and CUDA optimization.
Familiarity with SLAM, Robot Operating System (ROS), or autonomous vehicle applications.

am a PhD student working on an aircraft trajectory simulation project in MATLAB/Simulink. My goal is to replace the current Dubins-path-based approach with flyable clothoid trajectories using an existing MATLAB class (cloClass).

The simulator is already developed, but I need help integrating the new maneuver generation into the existing architecture. The work involves modifying Stateflow functions (ACmsgProcess, ATCmsgProcess, and fly), integrating cloClass, and resolving communication issues (send/receive) and livelock problems.

Required skills:

MATLAB
Simulink
Stateflow
Object-Oriented Programming in MATLAB
Experience with flight simulation, guidance, or control systems is a strong advantage.

The objective is to obtain a stable simulation where the aircraft follows smooth flyable clothoid-based maneuvers instead of Dubins trajectories.

We are seeking a skilled robotics engineer to design and build a customized robot that resembles Johnny 5 from the movie Short Circuit. The project involves creating a robot with a similar appearance and functionality, including movement and interaction capabilities. The ideal candidate will have experience in robotics and customization, and be able to deliver a high-quality, functional robot. Everything can be 3-d printed on demand, we need the specs and the "engine" behind it.

# Computer Vision / SLAM Engineer for Distributed Edge-to-Server Visual SLAM System

## Project Overview

We are looking for an experienced computer vision and SLAM engineer to design and implement a **SLAM / visual odometry pipeline** for a resource-constrained edge device.

The system will use a distributed architecture:

* An edge device processes the camera stream and performs feature detection.
* Detected features and the required metadata are transmitted over Wi-Fi to a more powerful server.
* The server performs visual odometry, mapping, triangulation, loop closure, localization, and tracking recovery.

The target edge hardware has limited computing power and may be based on a Cortex-A55-class processor device. It may be possible to add an NPU providing approximately 1 TOPS of acceleration.

## Key Tracking and Mapping Constraints

Tracking must be based on purpose-built floor patterns that serve as visual landmarks. Two types of patterns are available:

1. Geometric patterns created by arranging black and blue floor tiles.
2. Geometric symbols created from colored tape and attached to the floor.

See attached images for a birds-eye perspective of the floor patterns.

Reference images and recorded videos of both pattern types will be provided for development and evaluation.

The proposed solution must support at least one of these two pattern types for:

* Visual tracking
* Map creation
* Loop closure
* Localization against a stored map
* Relocalization after temporary tracking loss

Support for both pattern types is preferred but is not mandatory.

Note that when choosing the tape pattern, then the natural texture of the floor must not be relied upon for tracking or localization. Only the yellow/black pattern can be used as landmarks. The system should therefore remain functional when the surrounding floor material, texture, color, lighting, or environment changes.

Candidates should explain how their proposed approach distinguishes the intended landmarks from unrelated visual information.

## Camera Input

The supplied videos are recorded using a calibrated monochrome monocular camera with 60FPS, 1280x800 and wide angle field of view. Camera intrinsic parameters will be provided.

No stereo camera, depth sensor, or IMU data will be available during this phase.

## Offline Map Creation

Map creation will be performed offline using the supplied video recordings. This stage may use computationally intensive processing, including:

Landmark triangulation
Bundle adjustment
Pose-graph optimization
Loop closure
Map refinement

These operations are not required to run in real time.

After optimization, the completed map must be serialized and stored on disk.

## Real-Time Localization

The system must be able to reload the stored map and operate in localization-only mode.

During localization-only operation:

The stored map must remain fixed.
No new landmarks should be added.
No bundle adjustment or map optimization should be performed.
Camera pose must be estimated using only the supported floor patterns and the stored map.
The system must automatically relocalize after temporary or sporadic tracking loss.
Tracking must resume without manual initialization or rebuilding the map.

Real-time tracking and localization must operate at a minimum of 30 FPS, with 60 FPS preferred, on the agreed edge-to-server hardware architecture.


## Scope of Work

The selected engineer will be responsible for:

* Designing the complete edge-to-server SLAM architecture.
* Implementing robust detection of the features.
* Ensuring that floor texture and unrelated environmental features are excluded from tracking.
* Optimizing the feature-detection stage for resource-constrained edge hardware.
* Evaluating whether CPU-based processing is sufficient or whether the optional NPU should be used.
* Designing an efficient Wi-Fi data format and communication interface for transmitting features, descriptors, timestamps, camera information, and other required metadata.
* Implementing server-side visual odometry and SLAM.
* Implementing landmark triangulation and map optimization.
* Implementing loop detection and loop closure.
* Implementing relocalization when tracking is lost.
* Implementing a map visualization of the camera, frames and detected features
* Measuring accuracy, latency, bandwidth consumption, and computational performance.
* Calculate the device’s position and orientation in real time.
* Map detected features into a persistent 3D coordinate system.
* Localize the device against the previously created 3D feature map.
* Handle motion blur, changing viewing angles, partial occlusion, and lighting variations.
* Recover from temporary tracking loss where possible.
* Run efficiently on mobile or AR-class hardware.

The solution may be developed as a new SLAM pipeline or by extending an existing open-source system such as ORB-SLAM2, OpenVSLAM, or another suitable framework.

Candidates should explain which approach they recommend and why.

## Expected Deliverables

1. **System Architecture and Technical Design**

* Complete design of the distributed edge-to-server SLAM pipeline
* Definition of the responsibilities, interfaces, data flow, and processing requirements for the edge device and server

2. **Edge-Side Feature Detection**

* Feature detector or segmentation pipeline that identifies suitable features belonging exclusively to the patterns.
* Prevention of floor texture, background objects, and unrelated environmental features from being used for tracking
* Optimized implementation for the selected edge hardware and, where applicable, the optional NPU

3. **Feature Serialization and Communication**

* Efficient serialization of detected features, descriptors, timestamps, frame metadata, and camera-calibration data
* Wi-Fi communication interface between the edge device and server
* Appropriate handling of latency, packet loss, dropped frames, and temporary communication interruptions

4. **Server-Side Visual SLAM Pipeline**

* Visual odometry and camera-pose estimation
* Landmark triangulation and map creation
* Loop detection and loop closure
* Bundle adjustment and offline map optimization
* Recovery from temporary tracking loss

5. **Map Storage and Localization**

* Serialization of the optimized map to disk
* Ability to reload and reuse a previously generated map
* Localization-only mode without adding landmarks, performing bundle adjustment, or modifying the map
* Automatic relocalization against the stored map after temporary tracking loss

6. **Visualization and Diagnostics**

* Visualization of the estimated camera trajectory
* Visualization of detected features, mapped landmarks, tracking status, and relocalization events
* Diagnostic output suitable for identifying tracking and communication problems

7. **Performance Evaluation**

* Evaluation of:

* Tracking and localization accuracy
* Tracking stability and drift
* Relocalization success rate and recovery time
* Edge-side feature-detection latency
* Server-side processing latency
* End-to-end system latency
* Processing frame rate
* Network bandwidth usage
* Behavior under packet loss, network jitter, and temporary disconnections

8. **Test and Evaluation Package**

* Repeatable test procedure for map creation, localization, tracking loss, and relocalization
* Documented acceptance-test results

9. **Source Code and Documentation**

* Clean, maintainable, and documented source code
* Build and dependency instructions
* Configuration and deployment instructions
* Hardware integration instructions
* Testing and troubleshooting documentation

10. **End-to-End Demonstration**

* A working demonstration on the agreed target hardware
* The demonstration must include:

* Edge-side stripe-feature detection
* Feature transmission over Wi-Fi
* Offline map creation and optimization
* Map serialization and reloading
* Real-time localization against the stored map
* Temporary tracking loss followed by successful relocalization
* Visualization of the estimated trajectory and mapped features


## Provided data
1. Camera intrinsics
2. Images and videos of the environment recorded using a monocular camera (the intrinsics are given)

## Acceptance Criteria
1. The final delivery must include a repeatable demonstration using the supplied video data. The demonstration must show:
* Initial map creation
* Camera trajectory estimation
* Simulated or naturally occurring tracking loss
* Successful camera relocalization
* Continued localization within the existing map


## Required Experience

Applicants must be able to demonstrate strong professional or academic experience in:

* Visual SLAM and visual odometry
* Monocular or stereo camera geometry
* Feature detection and description
* Feature matching and tracking
* Camera calibration
* Epipolar geometry and triangulation
* Pose estimation and bundle adjustment
* Loop detection and loop closure
* Place recognition and relocalization
* Robust estimation methods such as RANSAC
* C++ and Python
* OpenCV
* Real-time or embedded computer vision
* Performance optimization on ARM-based hardware

Experience with one or more of the following is highly desirable:

* ORB-SLAM2 or ORB-SLAM3, OpenVSlam, Kimera, or other related SLAM frameworks
* g2o, Ceres Solver, or GTSAM
* Learned feature detectors or segmentation models
* NPU deployment, quantization, and model optimization
* Embedded Linux or microcontroller-based vision systems
* Wi-Fi-based edge-to-server processing pipelines
* Tracking line-based or color-constrained landmarks

## Application Requirements

Please include the following in your proposal:

* Examples of previous SLAM, visual odometry, or 3D computer-vision projects.
* A description of your exact contribution to each relevant project.
* Links to source code, publications, demonstrations, or technical documentation where available.
* Your proposed technical approach for detecting and tracking only the purple stripes.
* Your recommended SLAM framework or architecture and the reasoning behind your choice.
* Your approach to relocalization and loop closure.
* Your strategy for dividing computation between the edge device and the server.
* Your experience optimizing computer-vision algorithms for limited hardware.
* Any technical risks or feasibility concerns you identify.
* Your availability and hourly rate.

Please also provide an **estimated number of hours**, preferably divided into phases such as:

1. Architecture and feasibility assessment
2. Prototype feature detection
3. Edge-device optimization
4. Server-side SLAM implementation
5. Loop closure and relocalization
6. Hardware and network integration
7. Testing, optimization, and documentation

## Engagement Model

This is a **time-and-materials project**. Work will be billed hourly.

We expect the project to be divided into measurable milestones, beginning with a technical feasibility and architecture phase. Each phase should produce testable deliverables before proceeding to the next stage.

Applicants must provide an initial estimate of the required hours. The estimate may be refined after reviewing sample camera footage, hardware specifications, camera parameters, expected movement, stripe geometry, and accuracy requirements.

## Potential Follow-On Work

Successful completion of this project may lead to a follow-on engagement.

The next phase is expected to include:

* Integration of IMU data to create a visual-inertial odometry or visual-inertial SLAM system
* Improved robustness during rapid motion, motion blur, and temporary visual tracking loss
* Sensor synchronization and camera–IMU calibration
* Optimization for the final target hardware
* Conversion of the prototype into a reliable, maintainable, and production-ready system
* Performance validation, testing, documentation, and deployment support

Candidates with experience in visual-inertial SLAM, embedded systems, hardware acceleration, and productionizing computer-vision pipelines are especially encouraged to apply.

Objective
Build a working prototype that physically moves a standard optical mouse in X/Y and actuates its left button, driven by serial commands from a host PC.

Mechanical

Cartesian XY gantry, working area approx. 300 x 250 mm
Mouse mounted on carriage, removable without tools
Positional repeatability better than 0.1 mm

Actuation

Two NEMA17 steppers, GT2 belts, TMC2209 drivers (silent, microstepping)
Solenoid or servo actuator on left mouse button
Click response time under 50 ms from command to contact
Click endurance: minimum 100,000 cycles

Control

Controller board with USB serial interface (SKR Mini or equivalent)
Firmware accepting simple command set: absolute move, relative move, click, home
Endstops on both axes with homing routine
Documented serial protocol for host-side integration

Deliverables

Assembled and calibrated unit
Firmware source and wiring diagram
Bill of materials
Basic Python example controlling the unit

We are looking for an experienced PCB designer to create a PCB layout in KiCad based on an existing schematic and the reference files that we will provide.

Please , let me know if you have any question.

I'm the founder of a humanoid robotics AI company. I need a robotics/RL engineer who can work alongside me on real problems while explaining their thinking and approach so I build deep understanding over time.

This could lean more toward hands-on engineering or more toward structured teaching depending on your strengths. Ideally both.

Scope:

• Reinforcement learning for motor control (PPO, SAC, reward shaping, curriculum learning)
• Sim-to-real transfer pipelines for legged/humanoid robots
• Physics simulation environments (MuJoCo, Isaac Sim, Isaac Lab)
• Locomotion policy training and deployment
• Control systems fundamentals (PID, impedance control, EtherCAT)
• URDF/MJCF model creation and tuning
• Real-time inference at the edge

About me:

Strong software engineering background. I work daily with a robotics team and need to go from high-level AI/ML understanding to being able to evaluate technical decisions, read papers, and contribute meaningfully to architecture discussions.

Format:

• Video calls every 1-3 days (1-2 hours per session)
• Mix of collaborative engineering work and structured learning
• Async Q&A between sessions
• Duration: 2-3 months initially, ongoing if it works well

Ideal candidate:

• Has shipped sim-to-real on real legged or humanoid hardware
• Professional experience with MuJoCo and/or Isaac Sim
• Strong communicator who can explain complex concepts clearly
• Comfortable with a collaborative working style, not just isolated task execution

Budget: Open to hourly or weekly retainer. Share your rate and availability and we can arrange a short intro call to see if we are a fit.

I have a mobile robot prototype and I need an AI agent that will let it perceive its surroundings, decide on actions, and execute them safely in real time. Because the hardware stack is still flexible, I am open to ROS, a custom embedded setup, or a commercial SDK—whatever you feel will achieve the best balance between performance and maintainability.

At a minimum the agent must:
• Fuse camera and sensor data to detect obstacles and points of interest.
• Plan a collision-free path and update it on the fly.
• Expose a clean API so I can add higher-level skills later (object pickup, voice interaction, etc.).

Please structure the code in well-documented modules, supply build instructions, and include a short demo video that shows the robot handling a simple navigation scenario without remote intervention. Let me know the toolchain you prefer for simulation and testing so I can mirror the environment on my end.

Skills: Machine Learning (ML), Computer Vision, Robot Operating System (ROS), AI Text-to-speech, AI Chatbot Development, AI Model Development, AI Development, AI Agents

My name is Kaelan and I have had an interest in robotics for quite sometime. I have multiple concepts for robot designs, but I have very little technical expertise. I have a few projects related to robots and drones which I may be interested in pursuing depending on how complex the ideas are to accomplish. Ideally, I may be interested in finding a long-term business partnership with the right individual if they are interested in and see potential in my ideas.

Develop application software using ROS2 Jazzy, Nav2 and Raspberry Pi 4/5.

- take the existing software development environment (Docker, ROS2) https://github.com/makerspet/oomwoo-install
- implement in Gazebo simulation (and test thoroughly)
1. regular/auto cleaning (plan paths to cover the entire room/maps) https://github.com/makerspet/oomwoo/tree/main/contributions/cleaning-jobs
Starter tutorial https://makerspet.com/blog/simulate-oomwoo-one-robot-vacuum-in-gazebo-with-ros-2/ and here https://makerspet.com/blog/write-your-first-oomwoo-ros-2-package/
Achieve coverage 90%, time efficiency 80%
2. localize "kidnapped" robot https://github.com/makerspet/oomwoo/tree/main/contributions/nav-localize
Localize within 30 sec, 2 meters, 90% success rate.
3. Create regression test(s) for both on 1 world, run Gazebo headless using CLI
- Strip down existing ROS2/Docker development environment to product firmware running on Raspberry Pi 4 4GB. Drop Gazebo, desktop environment, etc. Make installation script. Boot, run on Pi 4. Use real placeholder vacuum, tutorial https://makerspet.com/blog/tutorial-connect-robot-vacuum-cleaner-to-ros-2-proscenic-m6-pro/
- 8 hours of community support and tutorials/documentation
- maintainer - handle PRs, talk to contributors, Apache 2.0 license, work in the open
- write step-by-step how-to tutorials for #1, #2, #3
- capture screen recording video of the simulation for the tutorials
Follow https://github.com/makerspet/oomwoo/blob/main/docs/SOFTWARE_INTERFACES.md guidelines.

Milestones
- M1 sim implementation + headless regression tests passing defined metrics
- M2 Pi 4 4GB image + install script, booting on real hardware
- M3 tutorials + docs + initial support

Out of scope - additional scope if you succeed

- optimize product firmware to run in 2GB RAM (instead of 4GB), including SLAM
- clean-and-map (vacuum doing mapping and cleaning simultaneously) high-level spec here https://github.com/makerspet/oomwoo/tree/main/contributions/clean-and-map
- implement recovery behaviors (to get robot unstuck)
- docking, undocking
- debug and test on real (but temporary placeholder) vacuum
- debug and test on actual vacuum
- make software production grade
- implement typical vacuum modes - spot cleaning, partition map into rooms, clean a room, clean large spaces (clean, charge, resume cleaning), vacuuming vs mopping, virtual wall support
- create additional worlds, regression tests
- more spec here https://github.com/makerspet/oomwoo/tree/main/contributions and here https://github.com/makerspet/oomwoo/blob/main/docs/RFC_BACKLOG.md
- implement cleaning blocked spaces (try slipping under couch covered by a cover that looks like obstacle)
- community support

Location: Remote
Type: Part-Time / Contract

Responsibilities
Develop and maintain applications using ROS/ROS2.
Integrate sensors, cameras, LiDAR, and robotic hardware.
Build and debug ROS nodes, topics, services, and actions.
Implement navigation, localization, and motion control.
Work with C++ and Python on Ubuntu/Linux.
Test and deploy robotic software on real hardware and in simulation.
Requirements
2+ years of hands-on experience with ROS/ROS2.
Strong proficiency in C++ and Python.
Experience with Linux, Git, and Gazebo/RViz.
Knowledge of SLAM, Navigation Stack/Nav2, TF, and sensor integration.
Experience working with mobile robots or robotic arms.
Ability to work independently and deliver on milestones.
Nice to Have
OpenCV or PCL
MoveIt
NVIDIA Jetson
Docker
AI/Computer Vision integration

To Apply: Share your resume along with GitHub, ROS projects, or videos demonstrating robots you've worked on.

i need a music box , please check the enclosed file , my requirement is in it ~
Please evaluate the R&D fee based on this simple architecture. Thanks!

I have a wheeled robot model inside CoppeliaSim and I need it to track a set of predefined waypoints using two complementary approaches: a classic PID controller and a Q-learning policy. Your job is to build both control loop of the python code for both pid and q learning

Skills: JavaScript, Python, Software Architecture, C++ Programming, Robotics, Lua, Data Analysis, Simulation, Robot Operating System (ROS), Reinforcement Learning

I have a mobile robot running inside CoppeliaSim and I need a clean, well-commented Python script that closes the loop on its position with a classic PID controller. The goal is simple: the robot must follow a predefined path accurately and smoothly, keeping tracking errors to a minimum while coping with CoppeliaSim’s real-time dynamics.

You are free to choose any sensible tuning method, but I want the gains justified and easy for me to tweak afterwards. Make sure the code exposes the proportional, integral and derivative terms clearly, logs position error over time, and plots or prints a brief performance summary so I can see how well the controller converges.

Deliverables:
• Python script (.py) ready to load in CoppeliaSim’s remote API or ZeroMQ interface
• Brief README or inline comments explaining setup, gain tuning procedure and how to change the reference path
• Proof-of-run: small video capture or screenshot series showing the robot completing the path within a reasonable tolerance (≈2 cm lateral error max)

Acceptance criteria:
– Robot completes the full path without oscillation or overshoot that causes it to leave the virtual floor area
– Average position error under 1 cm once steady tracking is reached
– All external libraries used must be standard Python or clearly listed for pip install

If you have tackled CoppeliaSim PID work before, feel free to mention it; otherwise, a concise demo will speak for itself.

Skills: PHP, JavaScript, Python, Software Architecture, Robotics, Data Visualization, Simulation, Robot Operating System (ROS)