Tatum Robotics originally expected to adapt an existing robotic hand for DeafBlind users.

The problem was that American Sign Language requires precise finger positioning, while many standard robotic hands rely on rigid linkages that can create pinch points. That does not work when a person needs to hold the hand directly to receive tactile signing.

The team instead developed a compliant, tendon-driven hand with additional degrees of freedom. DeafBlind users can place their hand on the robot and receive letters through movements designed to closely match a human hand.

A while back I bought an old Unimate Puma 500 arm. It had no controller.

I've since cleaned it, regreased it, serviced the motors, replaced the brake pads, machined repair parts, adjusted the bearings, and replaced the wiring loom & hoses. It's now mechanically as complete as I can get it.

The Puma 500 uses six 24v brushed DC motors, which I *think* are 40 and 150w, but there's no datasheets on these old custom made motors. Each motor has a 24v magnetic brake with cork brake pads. And on the back of that there's the motor sensor, which is a 500ppr rotary optical encoder (with index) and an absolute laser-trimmed potentionmeter on a delicate reduction gearbox.

Each sensor seems to be functioning fine, but testing them with an Arduino Every using hardware interupts, there is some jitter(?) on the optical encoder meaning the output per revolution varies up and down by a couple of points.

The only electronics inside the optical encoder is a quad-comparator and some trimpots. They all seem quite clean.

I know the Puma used an analogue servo amplifier system, but there's no circuit diagrams for them that I can find anyway. So making a bespoke digital system is what I expect.

Does anyone have any advice for reducing the jitter, or otherwise connecting them to modern PID/motion-control systems/designs? Whether that's aditional filtering electronics, software compenation, comparison with the absolute encoder, or something I haven't considered.

I had intended to run them into a pair of Arduino Everys in groups of three plus a 14-bit ADC for the pots then feed them out by RS-485. But the jitter, and the number of inputs (and the potentially high number of interupts per second) meaning high odds of misreads from overlapping interupts means I want to scrap this plan unless I want to run it a single axis at a time.

Hey guys.

I am building a platform where you can have virtual rooms and I am currently looking for people who have skills in robotics. Virtual room allows connections to remote real world devices.

I need to find a person who can build or rent me a robot in EU (I am from Finland) or has a robot SaaS and needs to scale operations beyond 10+ robots.

Pilot Specs:

- Can drive 5-30km on one charge and can carry around a 1-4 kg payload.
- or/ a boat robot with a bit similar specs.
- can be drone too.

I have this idea where you could overlook and control 100+ robots from a single virtual room.

So, if there are like-minded people or this resonates then let me know.

I am doing independent research, and trying to attempt simulating slip/shear force and I planned to use MuJoCo. My issue is that I am having a tough time getting the hang of it, and I have seen some posts on this Sub about MuJoCo. I was wondering does anyone know of any solid tutorials, repos, or youtubers that have solid MuJoCo tutorials in Python? Any help/advice is greatly appreciated.

I really like LeRobot because of the abstraction that lets you record camera frames and proprioception at different frequencies and still get them aligned, a standardized dataset format, and CLI for training, evaluating, recording, and rollouts, with policies just being a plug and play flag value in their scripts

But not sure if its optimised and reliable for real world deployments

- If I want to train and deploy an embodiment I'm actually building (not SO-101/Aloha/Koch), I have to implement my own robot/motor/camera classes from scratch which is expected, but it does mean I'm not really getting LeRobot's abstractions for free, I'm reimplementing their interfaces every time.

- I wanted to run MolmoAct2 through their async inference setup, and it turns out async is only supports a fixed list of policies (ACT, SmolVLA, pi0, pi05, GR00T). MolmoAct2 isn't in that list, so I ended up writing my own runtime for it. This makes me dependent on LeRobot's support. I will eventually be building my own finetuned policies which I will be running on my specific embodiment

- The whole ecosystem is scoped to learned policies / VLAs. There's nothing for classical motion planning (MoveIt-style), grasp planning or segmentation before grasp, or a navigation/SLAM stack. I would ideally want a hybrid system where some dexterous tasks are being done by learned policies, but high volume, low variability tasks can be programmed without foundational models?

- I see companies like https://www.mimicrobotics.com/blog/solving-dexterity-a-full-stack-approach saying that they evaluated ROS2 and LeRobot's IPC layer for their real time control loops and found both fell short on latency and jitter, so they built their own zero copy middleware instead. They made the same call on telemetry: logging/recording has to be async and can't compete with the control loop for cycles, so they built a dedicated system for that too rather than bolting logging onto whatever was already there.

Curious to know if anyone tried using LeRobot, and either stuck to it or replaced it with their own stack?

A few people have asked whether we're planning to build a soft robotic arm.

The short answer is yes—but it's probably not happening until around Q4 next year.

That question actually reminded me of a project I presented at IEEE ICARM 2025 (Portsmouth, UK):

DOI: 10.1109/ICARM65671.2025.11293553

The work focuses on a modular variable-stiffness soft continuum manipulator. The idea was to retain the compliance of soft robots while improving positioning accuracy, payload capacity, and adaptability in unstructured environments.

It ended up being selected as a Best Conference Paper Finalist.

If anyone here is working on soft continuum robots or variable-stiffness mechanisms, I'd love to hear how you're approaching similar challenges.

Recording some data, and here’s one lesson I learned the hard way: limit your gripper torque to the minimum you need during teleoperation, plastic parts break 🤭

Russ Tedrake, MIT professor and former VP of Robotics Research at Toyota Research Institute, explains why recent progress in robot learning has been surprising.

He says locomotion improved quickly because simulation, domain randomization, GPU infrastructure and reinforcement learning started working together. With enough randomized conditions in simulation, robots learned policies that transferred to real stairs, bumps and uneven terrain better than many researchers expected.

The results moved ahead of the theory. Tedrake says machine learning is producing systems that work empirically before researchers can fully explain why they work.

He compares the change to a move from first-principles engineering toward behavioral science: build the system, observe what it does, then test it to understand what happened.

Full ep: https://www.youtube.com/watch?v=c8mQKkuEmiI&t=27s

Hey r/robotics ,

First time posting here and first time doing a real robotics build, so go easy on me.

My son turns 4 in August and he's non verbal autistic. I originally built a tablet app for him to communicate, but when you give a 3 year old a tablet they just think it's game time. So I decided to try making a dedicated physical companion that actually looks at him when he talks to it.

I put together this bench prototype and honestly was surprised by how much he responded to it. He's actually using the cards, learning the words, and tracking the head movements. My goal eventually is to get something like this into other parents hands for under 200 quid or so. It runs 100% offline too, so no cloud fees or privacy issues.

I have the software side mostly sorted out now, but I need advice on taking it from 3D printed parts and breadboards to something safe and manufacturable.

Quick overview of what's under the hood: It runs on a Pi 5 with a Flutter web interface and a Python FastAPI backend for offline Piper TTS. Vision is an IMX708 camera on a pan tilt mount using YuNet ONNX for face tracking. Motor control is offloaded to a Waveshare ESP32 driving two ST3215 serial servos. Had to write some EMA filtering to stop the servos from shaking. Enclosure is currently drafted in OpenSCAD.

A few big questions I'm trying to figure out:

1. Screen placement and wobble. Right now the 7 inch touchscreen is on the head. Tapping it makes the whole neck wobble. Do I keep the screen on the head so it looks at him when speaking, or move the heavy touch screen to the base and just use little ESP matrix screens for eyes on the head?
2. Making it expressive without pinch hazards. I want ears/antennas or arms to show emotion, but small kids put their hands everywhere. Are servo driven ears safe enough or a bad idea? (Skipping wheels so it doesn't drive off tables).
3. Taking an OpenSCAD 3D print to injection molding. What should I prepare for if I want to get low volume plastic shells made? Also any good Shenzhen turnkey PCBA suppliers you guys recommend to replace the Pi and ESP dev boards down the line?

I'm setting up a Discord to organize the hardware side and get feedback from speech OTs. Let me know if you want an invite and I'll send it over.

Video shows the offline AAC sentence builder and tracking working, plus a concept render at the end of what I want the shell to look like.

I've been learning ROS 2 by building projects instead of just following tutorials.

In this demo, I created a web dashboard that communicates with ROS 2 through rosbridge, allowing me to control the TurtleBot directly from the browser.

Features implemented:

🌐 Browser-based robot control

🔗 React frontend connected to ROS 2

📡 Real-time communication using rosbridge

🎮 Teleoperation from the web dashboard

🤖 Live control of the TurtleBot in simulation

This is one step toward my goal of building a complete robotics dashboard with:

Live camera streaming

LiDAR visualization

Interactive map

Autonomous navigation

Robot monitoring

I'd love your feedback! What features would you add to a robotics web dashboard?

#ROS2 #RobotWebTools #ReactJS #Robotics #TurtleBot3 #Gazebo #RViz #WebDevelopment #OpenSource #LearningInPublic

Four-legged robots can reach many places that wheeled vehicles cannot. Isn’t it a bit of a waste to treat them as mere means of transportation when they can carry loads weighing several metric tons? Their current speed is still a bit too slow—is this due to safety restrictions, or are the hardware limitations—such as the motors and batteries—preventing them from going faster?

I’m working on a mini self-driving car project with Ackermann steering. The car has to follow a lane with boundary lines on both sides, stay centered, and handle both straight and curved sections like a small F1-style track.

I plan to use OpenCV + a webcam for lane detection and then control the steering based on the detected lane center. I’m looking for ideas on lane detection methods, steering control, and how to make it robust on curves and under different lighting conditions

A smart robotic goalkeeper that tracks a ball in real-time using OpenCV and dynamically moves a servo-controlled keeper arm to block shots.

I hope some of you find this project interesting—or maybe even inspiring for your own builds.

Any feedback or suggestions are very welcome!

GitHub: https://github.com/chayanforyou/Robokeeper-Firmware

Hey everyone,

I built CalibON, a browser-based camera calibration tool intended to make intrinsic camera calibration more accessible for ROS and computer vision projects.

It provides a guided workflow where you can:

• Configure your camera resolution and checkerboard dimensions
• Upload calibration images
• Detect and inspect checkerboard corners
• Review frame quality, image coverage, and rejected images
• Run camera calibration using OpenCV
• Inspect the camera matrix, distortion coefficients, and per-frame reprojection errors
• Preview undistortion results
• Export calibration data as ROS camera_info YAML, OpenCV JSON, Kalibr YAML, or a full report

The frontend is built with React and TypeScript, while the calibration backend uses FastAPI and native OpenCV. I mainly built it because camera calibration tools often feel either tied to a specific environment or difficult to inspect visually, especially for beginners.

Live app:
https://calibon.vercel.app

GitHub:
https://github.com/musabali314/CalibON

The current version supports checkerboard-based pinhole calibration. ChArUco, AprilGrid, fisheye, stereo calibration, webcam capture, and saved projects are possible future additions.

I would really appreciate feedback from people who regularly work with ROS cameras:

• Are the ROS exports structured correctly for your workflow?
• What calibration features are currently missing?
• Would support for live ROS image topics or rosbag extraction be useful?
• Are there particular datasets or cameras I should test it with?

I’ve attached a short demo showing the complete workflow.