A small referee-to-robot interface for RoboCupJunior Soccer. A referee controls the module over Bluetooth Low Energy (BLE) from the mobile app, and the module relays the live match state — PLAY, STOP, penalty, half-time, game over — to the robot over simple digital outputs or UART.
The current module (board V7 / 2026) is built around an ESP32-C5 and includes an OLED display, three buttons, an RGB LED, a buzzer, a USB-C port for power & flashing, and an on-board supercapacitor backup. It does not count toward the robot weight limit.
📦 Got an older 2024 board? That one uses an ESP32-C6 — see Legacy 2024 (ESP32-C6) modules below.
1. Install the referee app — Android, free on Google Play:
➡️ RCJ Soccer app on Google Play
2. Flash the module — easiest is the web flasher, nothing to install:
➡️ Web flasher — connect the module over USB-C and flash straight from your browser.
The web flasher uses the Web Serial API, so use desktop Chrome or Edge.
3. Wire it to your robot — power the module from the robot battery and read one start/stop signal (see below).
The app connects to the module over BLE and drives the whole match. The interaction pattern:
- Double-click for actions — e.g. double-click a robot to start/stop it, or to issue a penalty.
- Hold for settings — e.g. hold a robot button for connection settings.
- Start/stop resets all timers and starts/stops all robots at once.
- Score: double-click a score to add a point; hold the score number for −1.
The app's source code lives in its own repository: robocup-junior/soccer-referee-app.
The robot must respond to the start/stop signal for the entire game. Connect one of the following to a digital input and react whenever the state changes:
| Method | Pin | PLAY / GO | STOP |
|---|---|---|---|
| Output pin | OUT1 or OUT2 |
3.3 V (HIGH) | 0 V (LOW) |
| UART | TX0 (UART0 on the U3 header) |
sends PLAY |
sends STOP |
Both outputs carry the same 3.3 V logic-level signal. For 5 V robot inputs, add a level shifter before the robot. Always share GND with the robot controller — never connect VIN to a robot GPIO or to the 3.3 V pin.
Power the module directly from the robot battery so it stays alive for the whole match — even when the robot is switched off or removed from the field — to keep a stable BLE connection.
- Battery: connect VIN to battery + and GND to battery − (no switch in between). VIN accepts 4.5 V – 50 V (the on-board buck regulator is rated higher, but RoboCupJunior rules cap robot voltage at 50 V).
- USB-C: the module can also run from USB-C (VBUS).
- Regulated 3.3 V: you may instead feed 3.3 V to the 3V3 pin. If you do, design the supply to cover a short startup demand of ~0.5 A at 3.3 V (≈1.65 W); steady-state draw is far lower.
The back-side supercapacitor rides through short voltage dips during play (e.g. a battery sag). Switch the supercapacitor switch ON before the match, and OFF when the module is not in use so it doesn't stay charged in storage.
Mount the module where the display stays visible and the connector is easy to reach — typically on top of the robot via a hub, either on your own PCB or on protoboard/breadboard. We can also provide a limited number of hub boards you can permanently attach to your robot (hub photo).
To penalize a robot, double-press the large button on the module. The module sends a penalty request to the referee app, so the right robot is identified and the penalty timer starts — no shouting robot designators across the field. The firmware detects the double-press and sends the request only while the robot is in the PLAY state.
The OLED shows a countdown for the duration of a robot's penalty. Teams may return robots to play, per the rules, once the penalty time is up on the display.
Direct robot-to-robot communication is planned for a future firmware release. The current firmware relays the referee's match state (start/stop, penalty, half-time, game over) only — via the output pins or UART described above.
The old 2024 board's channel-select
A0/A1pins and theLOGVUART-level pin are not present on this hardware.
For most users the web flasher is all you need. Under the hood:
The firmware is an ESP-IDF project (Arduino runs as an IDF component). Releases are built automatically from Git tags matching fw-* or v* — pushing a tag makes GitHub Actions build the ESP32-C5 firmware, publish a GitHub Release with the .bin files, and deploy the latest web flasher to GitHub Pages:
git tag fw-v0.97
git push origin fw-v0.97The release includes a single merged image (bootloader + partition table + app) plus the individual bins for idf.py/esptool users.
The older 2024 board uses an ESP32-C6 (no USB-C connector) instead of the current ESP32-C5. It is still supported with a final, maintained firmware on the legacy/esp32-c6 branch. Those builds are published as GitHub Release assets (tags legacy-c6-*); there is no web flasher for them.
Flashing (native USB — recommended): the C6's USB D+/D− are broken out on the programming header. Wire them to a USB port (the module enumerates as a serial device), then flash the merged image with full erase:
esptool --chip esp32c6 -p <PORT> write_flash --erase-all 0x0 rcj_comm_module-<ver>-merged.binA UART path also exists via the level-shifted RX/TX header pins, but it needs the LOGV pin powered at 3.3 V and manual download-mode entry (hold IO9/BOOT low, pulse EN), so native USB is easier. Either path can use the special flashing jig PCB.
Check the open issues first and — if nobody has posted yours yet — open a new GitHub issue, post on the forum, or ask on the RoboCupJunior Discord.
- An adapter hub for EV3 / SPIKE
- More component libraries (footprint / schematic / 3D) for Altium, Eagle, KiCad, EasyEDA, OrcaCAD, …
- Reporting errors & testing
- Robot-to-robot communication
- RGB LED & buzzer feedback
- App by Mato Faltus
- Altium lib by Youssef Shaalan
A printable one-page (A5) summary of the pinout, signals, power, and wiring:
