Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
57 commits
Select commit Hold shift + click to select a range
06a7cd3
docs: refresh the roadmap against the code, and the stale notes it po…
isaac0804 Oct 21, 2026
9f2fe59
docs: fix the roadmap refresh's errors; cite roadmap entries by title
isaac0804 Oct 21, 2026
c84556e
fix(engine): skip the pinned goalkeeper when its robot is not on the …
isaac0804 Oct 21, 2026
b1516df
fix(tactics): hysteresis on the shot aim in LeadAndSupport and GiveAndGo
isaac0804 Oct 21, 2026
09cbcd6
feat(examples): one attacker vs one defender on real robots or in sim
isaac0804 Oct 21, 2026
d6eb4f4
fix(engine): no goalkeeper row in debug_status when its robot is absent
isaac0804 Oct 21, 2026
30d8574
feat(run): field check on camera runs, auto-HALT on real robots
isaac0804 Oct 21, 2026
88e34a0
feat(run): robot profiles: push without a kicker, gentle carry withou…
isaac0804 Oct 21, 2026
f0b25e4
feat(examples,dashboard): per-robot hardware and RULES switch; tidier…
isaac0804 Oct 21, 2026
ecc87ae
feat(run,analysis): record field tests as SSL game logs; measure robo…
isaac0804 Oct 21, 2026
1fbce32
feat(dashboard): match timeline in the Replay and Live tabs; 15x smal…
isaac0804 Oct 21, 2026
92ba5f9
feat(dashboard): Play list of situations; possession band, switch tic…
isaac0804 Oct 21, 2026
f25b1eb
fix(refiners): an unseen ball rolls to a stop inside vision's area
isaac0804 Oct 21, 2026
693fda1
docs(examples): a test day's measurements: calibration twice, floor f…
isaac0804 Oct 21, 2026
3a164f6
fix(examples): run as documented, `pixi run python examples/<name>.py`
isaac0804 Oct 21, 2026
12f96b1
feat(dashboard): ball placement by right-click; phone layout; lighter…
isaac0804 Oct 21, 2026
898d0a1
perf(dashboard): send a replay's ticks as columns of whole numbers
isaac0804 Oct 21, 2026
d9e6f2e
fix(dashboard): a client that stops reading no longer freezes the con…
isaac0804 Oct 21, 2026
ac30fb2
fix(runner): an auto-HALT is the command of the tick that forced it
isaac0804 Oct 21, 2026
15a33d2
fix(dashboard): the auto-HALT banner clears once play resumes; HALT i…
isaac0804 Oct 21, 2026
42adde9
fix(dashboard): a columnar replay's last Play row ends at its last tick
isaac0804 Oct 21, 2026
499bc88
fix(dashboard): a robot's heading is mirrored with the view
isaac0804 Oct 21, 2026
bb3049c
fix(dashboard): a dropped stream client is closed, so its browser rec…
isaac0804 Oct 21, 2026
3d80454
fix(dashboard): a ball placement must be inside the field and the are…
isaac0804 Oct 21, 2026
a6391e4
feat(dashboard): Live shows refused commands and a stalled stream; Ha…
isaac0804 Oct 21, 2026
18762aa
feat(dashboard): a held touch opens the ball-placement menu (iPhone)
isaac0804 Oct 21, 2026
ca4e5fa
fix(refiners): with smoothing off, a second ball loss starts where th…
isaac0804 Oct 21, 2026
40629db
fix(engine): a tactic's overlay is cleared once it stops being traced
isaac0804 Oct 22, 2026
026ea4a
feat(dashboard): bigger robot labels, and a role label no longer cove…
isaac0804 Oct 22, 2026
4b8716b
feat(dashboard): the replay shows the referee's match clock; a key fo…
isaac0804 Oct 22, 2026
a68416b
fix(dashboard): a command from the Live tab is stamped on the referee…
isaac0804 Oct 22, 2026
9669652
feat(dashboard): choose or restart each side's strategy from the Live…
isaac0804 Oct 22, 2026
2266a64
docs: the Live tab's Strategy panel
isaac0804 Oct 22, 2026
cbcb1e3
fix(run,dashboard): an operator's HALT lasts in the simulators; a tak…
isaac0804 Oct 22, 2026
e514eb9
fix(run): on camera runs our robots stop at the edge of the area in play
isaac0804 Oct 22, 2026
20ab69f
docs,tools: the real-robot test-day procedure; a vision check
isaac0804 Oct 22, 2026
34c3f1b
examples(real_attacker_defender): the lab field, 3 m x 2.25 m
isaac0804 Oct 22, 2026
c577b79
tools(vision_check): each robot and ball where each camera puts it, a…
isaac0804 Oct 22, 2026
eb8c3d2
fix(vision): weight each camera by how steeply it sees a robot; drop …
isaac0804 Oct 22, 2026
357e102
examples: real_score_goal, one robot alone takes the ball and scores
isaac0804 Oct 22, 2026
0c146de
fix(run): a team alone in real mode tracks only its own mapped robots…
isaac0804 Oct 22, 2026
08e2acf
examples: real_dribble_and_shoot; fix(dribble): letting go backs away…
isaac0804 Oct 22, 2026
a17d4d2
fix(vision): fuse the ball across cameras like the robots, and keep a…
isaac0804 Oct 22, 2026
d515142
tools(vision_check): --guided checks each camera against 9 known spot…
isaac0804 Oct 22, 2026
8ad1ab4
docs: plan an in-house vision stack for lab days, with the experiment…
isaac0804 Oct 24, 2026
52875ce
fix(run): the fence holds only edges inside the field, and fences a k…
isaac0804 Oct 24, 2026
fa1f918
fix(vision_check): --guided measures each spot from packets after Enter
isaac0804 Oct 24, 2026
62b5956
fix(vision): a camera at height 0 counts as one whose position is unk…
isaac0804 Oct 24, 2026
71086dc
fix(vision): a camera that loses the robot for a frame keeps the ball…
isaac0804 Oct 24, 2026
62584bd
fix(refiners): the ball is one in the field or a goal, nearest the la…
isaac0804 Oct 24, 2026
d21aa29
docs(sim_realism): first measurements of our robot from the 2026-10-2…
isaac0804 Oct 25, 2026
a2e2d21
docs(in_house_vision): the team chose the in-house stack; plan in ord…
isaac0804 Oct 25, 2026
3253fe5
docs(in_house_vision): how calibration tells floor and raised tags ap…
isaac0804 Oct 25, 2026
538ba1c
feat(game_log): record which code ran, operator and strategy-change n…
isaac0804 Oct 25, 2026
4992933
fix(strategy_view): show running only what the runner swapped in; que…
isaac0804 Oct 25, 2026
054626d
Merge main (#148 squash-merged, v2.4.0) into field-test-day-20261022
isaac0804 Oct 26, 2026
770ae02
fix(vision): preserve plausible nearby ball observations (#150)
fred-huang122 Oct 27, 2026
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 3 additions & 1 deletion docs/README.md
Original file line number Diff line number Diff line change
Expand Up @@ -12,7 +12,8 @@ Every doc in this folder, by kind. New to the repo: the [README](../README.md) f
- [motion_planning_results.md](motion_planning_results.md): its latest full run.
- [tools.md](tools.md): every script and pixi task, by purpose.
- [visual_guide.md](visual_guide.md): the game drawn on the pitch from real replays (how each strategy plays, one match over time, a restart, the motion planner), what each picture has shown us, and how to draw it.
- [setup_external.md](setup_external.md): grSim, the official GameController and AutoReferee, SSL Vision for real robots.
- [setup_external.md](setup_external.md): grSim, the official GameController and AutoReferee.
- [real_robot_setup.md](real_robot_setup.md): a test day with real robots: ssl-vision on its own laptop, WSL networking and USB, the radio, and the checks before a robot moves.
- [contributing.md](contributing.md): editor setup, commits, pull requests and releases.

## Design rationale
Expand All @@ -34,6 +35,7 @@ Every doc in this folder, by kind. New to the repo: the [README](../README.md) f

- [roadmap.md](roadmap.md): larger open workstreams, and one-line pointers to finished ones.
- [sim_realism.md](sim_realism.md): how far rsim is from real matches, the realism scorecard, and the plan to close the gap with measured, randomized physics.
- [in_house_vision.md](in_house_vision.md): our own vision stack for lab days (per-session tag calibration, tags on robots), the experiments that decide it, and the 2026-10-22 test day's vision findings.
- [testing_gaps.md](testing_gaps.md): kinds of testing gap that let bugs through, numbered (code cites them by number).
- [investigation_default_vs_lowblock_stalemate.md](investigation_default_vs_lowblock_stalemate.md): why `default` vs `low_block` stays 0-0; partly fixed.
- [investigation_ball_contact_orientation_divergence.md](investigation_ball_contact_orientation_divergence.md): a robot pinned against the ball rotates away from contact; localized, not fixed.
22 changes: 22 additions & 0 deletions docs/custom_referee_gui.md
Original file line number Diff line number Diff line change
Expand Up @@ -33,6 +33,12 @@ With vision from a camera (real robots or grSim) the Live tab also shows the fie
| `<colour> <id>` (any other) | | seen inside `field_bounds` but not configured: our planners cannot see it, often a wrong ID |
| Ball | | not seen, or outside `field_bounds` |

Before it gets that far, the runner keeps our robots inside `field_bounds` on camera runs
(`utama_core/run/field_fence.py`): each robot's speed towards an edge is capped to what it can
stop from before the line, whatever tactic sent the command, so a robot chasing a ball out of the
camera's area stops at the line. The planners' walls at `field_bounds` are only obstacles to plan
around, and did not stop it (0.5–0.9 m out in grSim before the fence).

Only the red and amber rows are listed; the green ones fold into an "N ok" line that opens on
click. On real robots any red row forces `HALT`, whatever the command and whether or not the page is
open; the red banner says why. Pressing Force Start while a row is red halts again at once, so
Expand All @@ -41,6 +47,22 @@ with everything outside `field_bounds` dimmed, so a half-field test shows which
expects. Space halts; nothing on the keyboard starts the robots. The Kickoff and Free Kick
buttons are hidden when the profile has no rule that sets up a restart (goal detection only).

## Strategy panel

A script can let the page change what each side plays, or restart it, without restarting the
run (`utama_core/dashboard/views/strategy.py`):

```python
strategy_view.attach(server, runner,
choices={"my": {"lead": make_lead, "press": make_press}}, # name -> builds a fresh AbstractStrategy
running={"my": "lead"})
```

The Live tab then lists the choices per side with a Run button; Run on the one running restarts
it. `StrategyRunner.replace_strategy` takes the new strategy at the next tick and only while
halted, so the page refuses otherwise. `examples/real_attacker_defender.py` offers its attacker
and defender tactics this way.

## Commands and what robots do

| Button | Command | Use | Robots |
Expand Down
306 changes: 306 additions & 0 deletions docs/in_house_vision.md

Large diffs are not rendered by default.

148 changes: 148 additions & 0 deletions docs/real_robot_setup.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,148 @@
# Real robots: setting up and checking vision and radio

The procedure for a test day with real robots: ssl-vision on its own Linux laptop sending vision
over the network, and our stack on a Windows laptop in WSL with the radio dongle. Each part is
checked on its own before anything drives a robot: vision with `tools/vision_check.py`, the radio
with teleop, then both together in the field check of `examples/real_attacker_defender.py`.

```
vision laptop (Linux) robot laptop (Windows + WSL)
cameras -> ssl-vision --multicast--> tools/vision_check.py, then the runner
224.5.23.2:10006 radio dongle (USB, passed into WSL) -> robots
```

## Once per machine

### Vision laptop (Linux)

1. Build [ssl-vision](https://github.com/RoboCup-SSL/ssl-vision) (its README). For a FLIR
camera install FLIR's **Spinnaker SDK** first: on the
[download page](https://www.flir.com/products/spinnaker-sdk) take "Spinnaker SDK, 64-bit"
for your Ubuntu (not ARM64 unless the laptop is ARM). Unpack it, install the libraries its
README lists, then `sudo sh install_spinnaker.sh`: yes to the udev entry (add your user to
`flirimaging`) and to USB-FS 1000 MB. Build ssl-vision with
`cmake -B build -DUSE_SPINNAKER=true -DUSE_V4L=true && make -C build`.
2. Add our field as a preset: `git apply tools/ssl-vision-lab-field.patch` in the ssl-vision
checkout (copy the file over), then rebuild. Field Configuration gets a **Lab Field** button
(3 m x 2.25 m, goal 0.8 m, defense area 1 m x 0.5 m, two cameras). Do not use the Division B
button with two cameras: it sets the camera count to 1.
3. USB webcams (the RER camera is one) need your user in `video`:
`sudo usermod -aG video $USER`, then log in again.

### Robot laptop (Windows + WSL)

1. **USB into WSL:** in admin PowerShell, `winget install --exact dorssel.usbipd-win`. The
`usbipd` you can run inside WSL is an unrelated Linux tool: always run it in PowerShell.
2. **Share the radio once, by its hardware ID** (stays the same whatever port it is in, unlike
the bus ID): `usbipd list`, note the radio's `VID:PID`, then
`usbipd bind --hardware-id <VID:PID>`.
3. **WSL on the real network:** in `%USERPROFILE%\.wslconfig`, under `[wsl2]`, add
`networkingMode=mirrored`. Without it WSL sits on a private network that never sees the
vision laptop's multicast.
4. **Let vision in:** in admin PowerShell, open UDP 10006 to WSL in the Hyper-V firewall:
```
New-NetFirewallHyperVRule -Name SSLVision -DisplayName "SSL Vision multicast" -Direction Inbound -VMCreatorId '{40E0AC32-46A5-438A-A0B2-2B479E8F2E90}' -Protocol UDP -LocalPorts 10006
```
(`40E0AC32-...` is WSL's fixed ID in that firewall.) Then `wsl --shutdown`.
5. **Radio permission in WSL:** `sudo usermod -aG dialout $USER`, then `newgrp dialout` in the
terminal you run from (or restart WSL).

## Each test day

### 1. Network

Both laptops on the same network, by Ethernet to one switch or router if possible: many Wi-Fi
routers drop or throttle multicast. If the robot laptop has two networks (Wi-Fi for internet,
Ethernet to the switch), our receiver listens on the one Windows uses for internet: use one.

### 2. Vision

On the vision laptop: `./bin/vision -c 2` (the number of cameras) in the ssl-vision checkout.
For each camera under **Image Capture**: the capture module (**Spinnaker** for FLIR, **Video 4
Linux** for a USB webcam), then **Capture Control → Start**. Settings save on a clean exit or
with **Save Settings**, not on a crash.

- **USB webcam:** cam idx is the `/dev/video` number of its image; a camera shows up as two
nodes and the second is metadata ("Inappropriate ioctl" means the wrong one). Use **MJPEG**:
the RER camera's uncompressed YUYV is 5 fps at 1280x960, MJPEG 60-90 fps. Its controls:
`v4l2-ctl -d /dev/video0 --list-ctrls`. Let auto white balance settle
(`--set-ctrl=white_balance_automatic=1`), then lock it (`=0` and
`--set-ctrl=white_balance_temperature=<what it picked>`): colours that drift break the colour
calibration. Keep exposure under about 10 ms (`exposure_time_absolute=100`) so the ball is
not smeared.
- **FLIR:** exposure and gain are in its Spinnaker node and change live.
- Field Configuration: **Lab Field → Apply**, then each camera's calibration, then colours per
camera.
- `./bin/graphicalClient` on the vision laptop shows what ssl-vision sends, before any network.

On the robot laptop, in WSL:

```
pixi run python tools/vision_check.py
```

Expect each camera at about its frame rate and the field at 3000 x 2250 mm. Nothing at all
means the network or the firewall (steps 3-4 above, step 1 here); one camera missing means its
capture is not running.

After a calibration, check it against known spots: `tools/vision_check.py --guided ball`, then
`--guided "blue 2"` (any robot, facing +x). It asks for the ball or robot on the 9 points
(corners, edge midpoints, centre) and prints each camera's error there; the results land in
`replays/field/*_vision_truth_*.json` to compare with the next setup. The pattern points at the
cause: errors growing towards the edges are the distortion or focal length, the same shift
everywhere the camera's position, more at one end than the other its tilt or height. The ball
right but the robot not is the robot height in ssl-vision.

### 3. Radio

Plug the dongle in, then in admin PowerShell (leave it open: it re-attaches after a replug):

```
usbipd attach --wsl --hardware-id <VID:PID> --auto-attach
```

In WSL `ls /dev/ttyACM*` shows it; the code uses `PORT` in `utama_core/config/settings.py`
(`/dev/ttyACM0`). Then drive each robot by hand:

```
pixi run debug-robots
```

Number keys choose the robot by its **radio (firmware) ID**, WASD moves, Q/E turns, Shift is
fast (0.5 m/s, else 0.1), Space dribbles, B/C kick/chip, Esc stops every robot and quits. Hold
the robot off the floor for the first presses and check each key moves it the way it says.
Note each robot's radio ID and the pattern on top (its vision ID): the runner needs both.

One radio drives every robot, of either colour: robots are addressed by radio ID only, so the
radio IDs must differ across all robots on it.

### 4. Both together

Set the "Test-day configuration" block of `examples/real_attacker_defender.py`: `FIELD`,
`CAMERA_HALF` (`"full"` when the cameras cover the whole field), each robot's vision and radio
ID and working hardware. Then `pixi run python examples/real_attacker_defender.py`, open
http://localhost:8080 and go through the Live tab's field check
([custom_referee_gui.md](custom_referee_gui.md#field-check-camera-runs)): every row green or
amber, each robot under its own ID and colour, a ball in each corner inside the area in play,
and a robot pushed by hand across the cameras' overlap moving smoothly (a jump there means the
two calibrations disagree). Only then Force Start.

Each run records `replays/field/<time>_<mode>_<name>.log`, a game log of every vision packet,
the radio both ways, the referee and which code ran. Beside it is a `.npz` replay of the world
the strategy saw, written when the run closes. Use the Live tab's Note box (Enter writes it into
the log) to say what a stretch is: "ball placed by hand", "start dribble test", "ignore". Most of
a test day is setting up, and notes make the useful minutes easy to find later.

## When something fails

| Symptom | Cause |
|---|---|
| `usbipd` in WSL talks about `linux-tools` packages | It is the Linux tool; run `usbipd` in PowerShell |
| `usbipd list` shows "Unknown USB device (device descriptor request failed)", `0000:0002` | Windows cannot read the device: other port, no hub, other cable |
| No `/dev/video*` after attaching a webcam | `sudo modprobe uvcvideo` |
| ssl-vision: "unable to obtain instance of camera" / permission | User not in `video` (or `flirimaging`); `newgrp video` |
| ssl-vision: "Could not set format" on `/dev/video1` | cam idx points at the metadata node: use the other one |
| `tee: .../usbfs_memory_mb: No such file` | WSL loads USB support only once a device is attached; `/etc/modprobe.d/usbfs.conf` with `options usbcore usbfs_memory_mb=1000` sets it then |
| Whole image tinted one colour | White balance stuck at an extreme (2800 K): auto, then lock |
| `vision_check` sees nothing | Different networks, Wi-Fi multicast, `.wslconfig` not mirrored, or the firewall rule missing |
| Dashboard: "Address already in use" | Another dashboard (`dashboard_server.py`) holds 8080: stop it |
11 changes: 10 additions & 1 deletion docs/roadmap.md
Original file line number Diff line number Diff line change
Expand Up @@ -218,6 +218,15 @@ entry by its title, not its number.
not yet rank strategies better than goals, so it explains results rather than saving matches
(`sim_realism.md`, "P1"). P2 (structured strategy search scored by it) is not started.

13. **Deferred, revisit only when forced** (minimalism):
13. **In-house vision for lab days (team decision 2026-10-25):** [`in_house_vision.md`](in_house_vision.md).
The 2026-10-22 test day lost most of its time to ssl-vision: cameras 5–8.5 cm apart and 3–9 cm off known spots, colour
calibration slow and noisy at the edges, fake balls, no way to lock focus or zoom. The plan:
per-session tag calibration of both cameras, tags on robots, an orange ball inside the field
mask, sent as standard SSL packets so our stack is unchanged. Lab only; competitions keep
the league's ssl-vision. The team chose to build it (2026-10-25). Next: a vision scorecard on the
recorded logs (the ssl-vision baseline to beat), an offline tag calibration solver, then
recording camera frames on the next test day; nothing is built yet.

14. **Deferred, revisit only when forced** (minimalism):
- `@pytest.mark.engine` marker for kernel tests — wait for real CI bottleneck data.
- `TickContext` responsibilities beyond `motion_controller`/`match_log`.
30 changes: 3 additions & 27 deletions docs/setup_external.md
Original file line number Diff line number Diff line change
Expand Up @@ -50,31 +50,7 @@ cd AutoReferee && ./gradlew run
Then run your own strategy. The GameController's web UI is at http://localhost:8081/#/match
(this repo's dashboard is :8080).

## SSL Vision for real testing (WSL)
## SSL Vision and the radio for real robots

1. Connect the vision Linux laptop and your own laptop to the same network (an external
hotspot).
2. Allow inbound UDP packets through the vision port. With admin privileges, in PowerShell:

```
New-NetFirewallRule -DisplayName "Allow Multicast UDP 10006" -Direction Inbound -Protocol UDP -LocalPort 10006 -Action Allow
```

3. Type `%USERPROFILE%` into Windows + R and add a `.wslconfig` file there (file type
WSLCONFIG):

```
[wsl2]
networkingMode=mirrored
```

4. Restart WSL with `wsl --shutdown`, then check the connection:

```
sudo tcpdump -i eth1 -n host 224.5.23.2 and udp port 10006
```

If you see UDP packets, everything is working.

For the robot radio and controllers see
[`utama_core/team_controller/README.md`](../utama_core/team_controller/README.md).
The whole procedure (vision laptop, WSL networking and USB, radio, the checks before a robot
moves) is in [real_robot_setup.md](real_robot_setup.md).
43 changes: 43 additions & 0 deletions docs/sim_realism.md
Original file line number Diff line number Diff line change
Expand Up @@ -414,6 +414,49 @@ Replace league ranges with measurements of our robots. Tests, each short and rep
Ranges for our robots then replace the league ranges for our side only. Opponents keep the
league ranges.

#### First measurements of our robot (field test 2026-10-22)

From the logs in `replays/field/20261022_*_real_*.log`, one robot (blue 2, firmware 0), mostly
`real_score_goal` runs. Of 33 recorded minutes, the robot moved for under 3, dribbled for 3.5
and kicked 9 times, so these are small samples. The radio log (`RADIO_OUT`) says when the
dribbler and kicker were commanded. Kicks and ball slow-down come from one camera's raw ball
detections, because the two cameras disagreed by several cm. Vision noise comes from
`tools/robot_calibration.py`.

| Measure | Ours | League / sim |
|---|---|---|
| Full kick, launch speed | 1.95–2.37 m/s (3 kicks on one camera; a 4th, from the fused ball, about 2.5); one weak kick at 1.07 | league full power 4.1–6.3; sim 5 (`KICK_SPD`) |
| Kick misfire: the ball moved under 15 cm | 4 of 9, the IR sensor seeing the ball every time | sim never |
| Kick direction, against the robot's heading | +2.6° to +4.9°: a steady offset, about 1° of spread | sim 0 |
| Kick command to the ball moving (camera seen) | 63–89 ms | sim: next tick |
| Ball slide, first 0.4 s after a kick | 1.0–3.5 m/s² | league 2–4; sim 0.65 |
| Ball rolling, after 0.5 s | 0.22–0.37 m/s² | league 0.29; sim 0.65 |
| Robot position noise at rest | 0.2–0.6 mm (2–8 mm in 4 logs where the robot rocked or the cameras traded off) | league 0.4–1.0 |
| Robot heading noise at rest | 0.3–0.5° | league 0.2–0.3 |
| Robot missing from a camera frame | 3–9% | league 0.1–0.9% |
| Ball at rest, position noise | 0.2–0.5 mm | |
| Ball lost while dribbling | 12 losses, nearly all with ≥ 0.85 m/s or ≥ 2.5 rad/s commanded in the 0.7 s before; slow, straight dribbles held 10–15 s | |
| Loop delay (command to motion seen) | 80 ms, from 3 noisy steps in one log | sim 0.05–0.10 when on |

- **Our kicker is less than half as fast as the league's and the sim's.** The electronics team
says the capacitor's charge, and so the kick strength, depends on how long it has been
charging, and they can't control it. So the sim should treat every kick as a full kick, at
about 2.1 m/s for our robots, with the league range kept for opponents.
- **Misfires aren't explained by the ball's place in the mouth.** On the misfires, vision put the
ball within 22 mm of where it sits when IR sees it, and within 8 mm sideways; full kicks sat
just as far off. Vision in those logs is only good to about ±2 cm, so a ball a centimetre
short of the kicker can't be ruled out. Off-centre balls didn't explain direction either: the
offset was +3° to +5° whatever the ball's sideways place. It is likely the robot's heading as
vision reads it, or the kicker's mounting.
- **The ball on this floor slows like the league's carpet:** it slides, then rolls at about
0.3 m/s². This is the two-phase friction found in Phase 1, which rsim's single 0.65 doesn't
reproduce.
- **The IR ball sensor never fired with the ball more than 25 cm away.** Where vision puts the
ball while IR fires shows vision's own error at the dribbler. It was steady (95–99 mm from
the robot's centre) after the cameras were retuned, but spread over 66–104 mm earlier.
- **Still unmeasured:** loop delay and acceleration limits (they need a `--calibrate` run, not
strategy runs), spread across robots (one robot), and kick strength against charging time.

## P1: Value model on real data

The xG model is already a small value model fitted on reality, for shots only. The extension
Expand Down
Loading
Loading