Smart machines cost $1,900+ and lock every drill behind their cloud. RallAIMate is different: an ESP32 brain, a fully open REST + WebSocket API, and a web-first drill designer — no subscription, no app store, no lock-in. Ever.
Dark chassis, blue LED accent lines, an open hopper, and dual-wheel drive — the long-term design target for the retrofitted machine. Full concept sheet below, honest Phase 1 numbers beneath it.
The render above is where the platform is headed. Day one runs on a stock donor machine with an ESP32 swapped in — and we publish the real numbers, because that's the whole point of an open build.
| Spec | Concept target | Phase 1 (stock donor + ESP32) |
|---|---|---|
| Ball capacity | 120 balls | 50 balls — the donor's physical hopper |
| Ball speed | up to ~75 mph | ~20–37 mph on stock motors; brushless upgrade is a later stretch |
| Spin control | ±9 continuous levels | pending teardown — depends on whether the wheels are independently driven |
| Elevation | 20–60°, motorized | 20–60°, motorized — confirmed donor spec, real on day one |
| Battery life | 6–8 hrs | 1–2 hrs — stock pack, per the listing |
| Mobility | all-terrain wheels | stationary — smooth surfaces; Mecanum base is Phase 4 |
| App, stats & AI coaching | full app suite | raw REST + WebSocket control — web client is Phase 3, vision is Phase 5 |
Phase 1's win condition, stated plainly: build our own brain for a dumb machine and prove full programmatic control. Everything else on the poster is a later phase — and every phase ships its real numbers.
Each session ships as a video walkthrough plus the exact drill file that produced it. Watch the drill, tap once, and your machine runs the identical feed — same speed, same spin, same placement.
Three rotating soft targets at the NVZ line. Consistency under fatigue.
Body-targeted drives at ascending speed. Block, reset, counter.
Alternating spin profiles from independent dual wheels. Learn the flight cues.
Random left-center-right feeds force honest court coverage.
Survive the no-man's-land: low balls at your feet while you advance.
Deep returns into called zones. Session heatmap scores every ball.
The library grows with the build — every prototype session is being recorded from day one, doubling as the training dataset for the computer-vision phase. Follow the build to catch each drop.
Commercial "smart" machines hide a cheap microcontroller behind a locked app. RallAIMate rips that out and rebuilds the entire control stack in the open — every motor, every message, every line of firmware.
The stock control board comes out. In goes a dual-core ESP32 driving five independent channels — with hard-realtime safety where it counts.
REST for commands, WebSocket for live telemetry. If you can write JSON, you can program the machine — from a browser, a script, a Raspberry Pi, or anything else on your network. No cloud round-trip. No account. It works in a garage with no internet at all.
// one step of a drill — that's the whole schema { "position": "cross-court-left", "speed": 34, // mph "spinTop": 1.00, // wheel A throttle "spinBottom": 0.62, // wheel B → topspin "elevation": 12, // degrees "intervalSec": 2.5 } # run it from anywhere on your network curl -X POST http://rallaimate.local/drill \ -d @third-shot-drop-ladder.drill.json
Two counter-rotating wheels grip the ball. Run them at the same speed and the ball flies flat. Run the top wheel faster and you get topspin; bottom faster, backspin. If the donor's wheels are independently driven — the first thing the teardown will confirm — spin becomes a continuous, scriptable variable, and drills can morph spin ball-by-ball.
The mobility base rides on Mecanum wheels — four independently driven rollers that let the machine strafe sideways, glide diagonally, or rotate in place. Between drill steps it repositions itself to preset court spots, so one drill can feed from the left sideline, the center, and the right without you touching it.
A fixed camera and an OpenCV pipeline map every one of your return shots to real court coordinates: where it bounced, how fast it traveled. After each session you get a placement heatmap scored against the target zone the machine was feeding — a closed training loop, running entirely on local hardware.
Every other machine on the market is a rental of its own features. RallAIMate is built on three non-negotiables.
The full REST/WebSocket spec and firmware are yours to read, fork, and extend. Build your own client. Script drills in Python. Wire it into anything.
The machine runs on your WiFi — or its own access point with no internet at all. No account, no cloud dependency, no feature paywalled next quarter.
Documented wiring, 3D-printable parts, a published BOM. Upgrade motors, add sensors, port it to a tennis or table-tennis donor — the platform is the product.
The market splits into cheap launchers that just spit balls, and $1,900+ app machines that rent you your own drills. Nothing is open — at any price.
| Basic launchers | "Smart" machines | RallAIMate | |
|---|---|---|---|
| Typical price | $300–900 | $1,900–3,900 | ~$595 target |
| Programmable drills | ✕ remote only | ✓ via locked app | ✓ open JSON files |
| Independent spin control | ✕ or presets | ✓ | ✓ continuous, scriptable |
| Open API | ✕ | ✕ closed ecosystem | ✓ REST + WebSocket |
| Works without cloud | ✓ (no smarts) | ✕ app + account | ✓ fully local |
| Subscription | — | often, for full features | never |
| User-repairable / moddable | ✕ | ✕ warranty-voiding | ✓ that's the point |
Every phase is documented — wiring photos, firmware commits, drill session videos, and the mistakes included.
Gut the donor machine's stock board, wire in the ESP32 brain, bench-test all five motor channels with a hardware e-stop.
REST + WebSocket control layer, drill JSON schema, OTA updates. Machine-agnostic — the same firmware will drive future sports.
Court-diagram UI: drop pins, sequence shots, save and share drills. Live control panel with manual override.
Omnidirectional drive: the machine repositions itself to preset court spots between drill steps.
Fixed-camera OpenCV pipeline: return placement heatmaps and speed measurement, processed locally.
Port the firmware to a table-tennis robot donor — same API, different motor scaling. One platform, every racquet sport.
Get the build log, new training videos, firmware releases, and the open drill library as they drop. No spam — just the machine coming to life.
Open hardware project · in active development · documented end to end
