doc: say "DotBot", spell out SEGGER Embedded Studio, drop pip --pre

AI-assisted: Claude Opus 4.7

Author: geonnave

doc/cli/index.md

@@ -11,7 +11,7 @@ config
 
 One CLI for the whole DotBot workflow: build firmware, flash one board, control a
 whole swarm, and launch the host-side processes that tie it together -
-from one bot to a thousand.
+from one DotBot to a thousand.
 
 ```bash
 dotbot --help
@@ -25,7 +25,7 @@ dotbot --help
 |---|---|---|
 | [`fw`](fw.md) | Build, fetch, and list firmware files. No hardware needed. | You want a `.hex`/`.bin` to flash later, or to see what builds. |
 | [`device`](device.md) | Flash one cabled board and read its info. | A DotBot or DK is plugged into your USB port right now. |
-| [`swarm`](swarm.md) | Drive the whole fleet over the air - status, OTA flash, start/stop, monitor. | You're operating many provisioned bots through a gateway. |
+| [`swarm`](swarm.md) | Drive the whole fleet over the air - status, OTA flash, start/stop, monitor. | You're operating many provisioned DotBots through a gateway. |
 | [`run`](run.md) | Start host processes on your computer - controller, gateway bridge, simulator, demos, teleop. | You need the web UI, a gateway bridge, the simulator, or a demo. |
 
 Beyond the four namespaces, [`config`](config.md) scaffolds and inspects the

doc/cli/run.md

@@ -14,7 +14,7 @@ dotbot run --help        # the full list
 | `controller` | Control plane: REST/WS API + web dashboard. The hub everything else talks to. |
 | `gateway` | Host bridge: gateway firmware UART ↔ MQTT broker. |
 | `simulator` | Standalone simulator (no hardware). |
-| `lh2-calibration` | LH2 calibration on one cabled board (capture / apply); deployed bots use `swarm lh2-calibration`. |
+| `lh2-calibration` | LH2 calibration on one cabled board (capture / apply); deployed DotBots use `swarm lh2-calibration`. |
 | `demo` | Built-in research demos (qrkey phone bridge, …). |
 | `keyboard` | Drive a DotBot from the keyboard. |
 | `joystick` | Drive a DotBot from a joystick. |
@@ -26,16 +26,16 @@ Connect to a swarm and serve the dashboard at `http://localhost:8000/PyDotBot/`.
 `simulator`.
 
 ```bash
-dotbot run controller --conn mqtts://argus.paris.inria.fr:8883 --swarm-id 1234 -w
-dotbot run controller --conn /dev/ttyACM0 -w
+dotbot run controller --conn mqtts://argus.paris.inria.fr:8883 --swarm-id 1234
+dotbot run controller --conn /dev/ttyACM0
 ```
 
 | Flag | Meaning |
 |---|---|
 | `-n/--conn` | `mqtts://host:port`, serial path, or `simulator` |
 | `-s/--swarm-id` | hex swarm id - **required for MQTT**, ignored for serial/simulator |
-| `-w/--webbrowser` | open the dashboard automatically |
-| `--csv-data-output` | record robot data to a CSV file |
+| `--headless` | don't open the dashboard in a browser (it's still served) |
+| `--csv-data-output` | record DotBot data to a CSV file |
 
 Full options and the dashboard tour live in
 [the controller guide](../guides/controller.md). See `dotbot run controller --help`.
@@ -60,15 +60,15 @@ No hardware, no gateway. Exactly equivalent to `run controller --conn simulator`
 so it shares the controller's flags and serves the same dashboard.
 
 ```bash
-dotbot run simulator -w
+dotbot run simulator
 ```
 
 ## `lh2-calibration` - capture & apply (cabled)
 
 Lighthouse v2 calibration against a single serial-attached board. `collect`
 opens a TUI to capture LH2 counts; `apply` writes the saved calibration out as
-a C header. This is the cabled, bench path - for deployed bots, capture over the
-air with [`swarm lh2-calibration`](swarm.md) instead.
+a C header. This is the cabled, bench path - for deployed DotBots, capture over
+the air with [`swarm lh2-calibration`](swarm.md) instead.
 
 ```bash
 dotbot run lh2-calibration collect
@@ -90,7 +90,7 @@ dotbot run demo qr          # qrkey phone bridge
 
 Drive a DotBot live through a running controller (start one with
 `run controller` first). Both default to `localhost:8000`; pass `-d` to target a
-specific robot by hex address.
+specific DotBot by hex address.
 
 ```bash
 dotbot run keyboard

doc/cli/swarm.md

@@ -1,8 +1,8 @@
 # `dotbot swarm` - operate the fleet over the air
 
-Run experiments across many robots at once. `dotbot swarm` drives the
+Run experiments across many DotBots at once. `dotbot swarm` drives the
 [SwarmIT](https://github.com/DotBots/swarmit) orchestration backend: it
-OTA-flashes a sandbox app to every bot, starts/stops it, and watches status -
+OTA-flashes a sandbox app to every DotBot, starts/stops it, and watches status -
 all wirelessly through a gateway.
 
 For one cabled board, use [`device`](device.md). To build the apps you flash,
@@ -19,14 +19,14 @@ see [`fw`](fw.md). The host bridge and dashboard come from [`run`](run.md).
 
 ## 1. Provision once
 
-Each robot needs the SwarmIT sandbox-host firmware; the gateway is an
+Each DotBot needs the SwarmIT sandbox-host firmware; the gateway is an
 nRF5340-DK running the Mari gateway firmware. Both are cabled flashes over
 USB-C (the DotBot v3 has an on-board programmer - no separate J-Link needed).
 Details and chip caveats live in [`device`](device.md).
 
 ```bash
 dotbot device flash-mari-gateway      --swarm-id 1234 -s 10 -f 0.8.0rc1   # a DK -> gateway, net id 0x1234
-dotbot device flash-swarmit-sandbox --swarm-id 1234 -s 77 -f 0.8.0rc1   # each bot -> sandbox host
+dotbot device flash-swarmit-sandbox --swarm-id 1234 -s 77 -f 0.8.0rc1   # each DotBot -> sandbox host
 ```
 
 ## 2. Start the host bridge
@@ -109,14 +109,14 @@ driving it over the swarm. The arena geometry and `-d` sizing live in the
 
 ```bash
 dotbot swarm stop                                              # capture only runs in READY
-dotbot swarm lh2-calibration collect --device BC3D... -d 500   # capture from one bot -> solve -> save
-dotbot swarm lh2-calibration push ~/.dotbot/calibration-<UTC>.toml   # apply to every ready bot
+dotbot swarm lh2-calibration collect --device BC3D... -d 500   # capture from one DotBot -> solve -> save
+dotbot swarm lh2-calibration push ~/.dotbot/calibration-<UTC>.toml   # apply to every ready DotBot
 ```
 
-`collect` walks one bot through the four arena corners over the air, solves the
+`collect` walks one DotBot through the four arena corners over the air, solves the
 homography, and saves it under `~/.dotbot/`. `push` (no `--device`) then sends
-that calibration to **every ready bot** - the arena shares one transform.
-(`collect --push` is a single-bot shortcut: it sends only to the captured bot.)
+that calibration to **every ready DotBot** - the arena shares one transform.
+(`collect --push` is a single-DotBot shortcut: it sends only to the captured DotBot.)
 `push` takes a `calibration-*.toml` or the legacy raw payload - the format is
 picked by file extension. Get the `--device` address from `dotbot swarm status`.
 

doc/guides/controller.md

@@ -2,34 +2,35 @@
 
 The controller is the host-side control plane: it talks to your gateway (or a
 simulator), exposes a REST + WebSocket API, and serves a web UI to drive your
-robots.
+DotBots.
 
 ## Start it
 
 Point the controller at a connection and open the web UI:
 
 ```bash
 # serial gateway plugged into your computer (no swarm-id needed)
-dotbot run controller --conn /dev/ttyACM0 -w
+dotbot run controller --conn /dev/ttyACM0
 
 # a swarm over MQTT (swarm-id required - the broker carries many swarms)
-dotbot run controller --conn mqtts://argus.paris.inria.fr:8883 --swarm-id 1234 -w
+dotbot run controller --conn mqtts://argus.paris.inria.fr:8883 --swarm-id 1234
 
 # no hardware at all - pure software simulator
-dotbot run controller --conn simulator -w
+dotbot run controller --conn simulator
 ```
 
 `--conn` takes one string: a serial device path (`/dev/ttyACM0`, `COM3` on
 Windows), an MQTT broker (`mqtts://host:port`), or `simulator`.
 
-`-w` / `--webbrowser` opens a tab automatically. Otherwise browse to
+The dashboard opens in a browser tab automatically. Pass `--headless` to
+suppress that (it's still served); browse to
 <http://localhost:8000/PyDotBot> yourself.
 
 | Flag | What it does |
 |---|---|
 | `-n, --conn` | Connection: serial path, `mqtts://host:port`, or `simulator` |
 | `-s, --swarm-id` | Swarm id in hex (required for MQTT, ignored otherwise) |
-| `-w, --webbrowser` | Open the web UI automatically |
+| `--headless` | Don't open the web UI in a browser (still served) |
 | `--controller-http-port` | HTTP/REST port (default `8000`) |
 | `--config-path` | Path to a `.toml` config file |
 | `--dotbot / --sailbot` | With `--conn simulator`: which robot to simulate |
@@ -38,7 +39,7 @@ See `dotbot run controller --help` for the full list (logging, CSV export, map
 size, background map, simulator init state).
 
 `dotbot run simulator` is shorthand for `dotbot run controller --conn simulator` - try
-the UI with no robot or gateway.
+the UI with no DotBot or gateway.
 
 ## Use a config file
 
@@ -64,9 +65,9 @@ discovered and the full schema.
 At <http://localhost:8000/PyDotBot> the page lists every DotBot the controller
 sees. Select one to control it:
 
-- **Joystick** - a virtual joystick drives the selected bot.
-- **RGB LED** - pick a color and the bot's LED follows.
-- If you flashed Lighthouse 2 localization, bots report their `(x, y)` position
+- **Joystick** - a virtual joystick drives the selected DotBot.
+- **RGB LED** - pick a color and the DotBot's LED follows.
+- If you flashed Lighthouse 2 localization, DotBots report their `(x, y)` position
   on the map (see [LH2 calibration](lh2-calibration.md)).
 
 ## Firefox websockets note
@@ -77,5 +78,5 @@ being blocked. Open `about:config` (Ctrl + L, then type it), find
 
 ## Next steps
 
-- Flash robots and a gateway first - see [device flashing](../cli/device.md).
+- Flash DotBots and a gateway first - see [device flashing](../cli/device.md).
 - Operate the whole fleet over the air - see [swarm](../cli/swarm.md).

doc/guides/index.md

@@ -11,13 +11,13 @@ lh2-calibration
 lh2-calibration-cabled
 ```
 
-- [Try it in the simulator](simulator.md) - run the full UI and script bots with
-  no hardware.
-- [Drive a single DotBot](one-bot.md) - build, flash, and control one bot end to
-  end.
+- [Try it in the simulator](simulator.md) - run the full UI and script DotBots
+  with no hardware.
+- [Drive a single DotBot](one-bot.md) - build, flash, and control one DotBot end
+  to end.
 - [Run the controller + web UI](controller.md) - drive and visualize a swarm
   from the browser.
-- [Lighthouse 2 localization](lh2-calibration.md) - give your bots real-world
+- [Lighthouse 2 localization](lh2-calibration.md) - give your DotBots real-world
   `(x, y)` positions, calibrated over the air.
 - [LH2 calibration over a cable](lh2-calibration-cabled.md) - the bench
-  alternative, for a single USB-connected bot.
+  alternative, for a single USB-connected DotBot.

doc/guides/lh2-calibration-cabled.md

@@ -2,8 +2,9 @@
 
 The bench alternative to the [over-the-air flow](lh2-calibration.md): calibrate a
 single DotBot connected over USB, with no swarm provisioned. Reach for this when
-you're working with one bot on the bench, or before the fleet is set up. For
-already-deployed bots, prefer the over-the-air flow - no cable, no firmware swap.
+you're working with one DotBot on the bench, or before the fleet is set up. For
+already-deployed DotBots, prefer the over-the-air flow - no cable, no firmware
+swap.
 
 What LH2 calibration is, and the arena geometry (the `-d` square sizing), are
 covered in the [main guide](lh2-calibration.md); this page is just the cabled
@@ -18,28 +19,28 @@ capture path.
 - The `[calibrate]` extra:
 
 ```bash
-pip install --pre 'pydotbot[calibrate]'
+pip install 'pydotbot[calibrate]'
 ```
 
 ## 1. Flash the capture firmware
 
 The `lh2_calibration` app streams raw LH2 counts over serial. Flash it to the
-cabled bot (see [device](../cli/device.md) for serial-prefix selection):
+cabled DotBot (see [device](../cli/device.md) for serial-prefix selection):
 
 ```bash
 dotbot device flash lh2_calibration -s 77      # board defaults to dotbot-v3
 ```
 
 ## 2. Capture the four reference points
 
-Place the bot on the floor square and run the TUI. `-d` is the side length of
+Place the DotBot on the floor square and run the TUI. `-d` is the side length of
 the square, in millimeters:
 
 ```bash
 dotbot run lh2-calibration collect -p /dev/cu.usbmodem... -d 500
 ```
 
-Move the bot to each corner - Top left -> Top right -> Bottom left -> Bottom
+Move the DotBot to each corner - Top left -> Top right -> Bottom left -> Bottom
 right - pressing the matching button in the TUI at each. When all four are
 captured, save. The calibration is written under `~/.dotbot/` (a
 `calibration-<UTC>.toml`), the same place the over-the-air flow uses.
@@ -74,12 +75,12 @@ dotbot run lh2-calibration apply ./lh2_calibration.h
 ```
 
 The swarmit secure bootloader `#include`s this file; rebuild and reflash the
-bootloader for it to take effect. For already-running bots, prefer the
+bootloader for it to take effect. For already-running DotBots, prefer the
 over-the-air push above - no reflash needed.
 
 ## Troubleshooting
 
-- **No counts in the TUI** - wrong `-p` port, or the bot can't see both base
+- **No counts in the TUI** - wrong `-p` port, or the DotBot can't see both base
   stations. Confirm line-of-sight and that the base-station LEDs are steady.
 - **Positions look skewed or mirrored** - the corners were captured out of
   order. Re-run `collect` and follow TL -> TR -> BL -> BR exactly.

doc/guides/lh2-calibration.md

@@ -1,63 +1,63 @@
 # Lighthouse 2 (LH2) calibration
 
 Lighthouse 2 gives every DotBot a real-world **(x, y) position** on your arena
-floor. Two SteamVR base stations sweep the room with IR; each bot's LH2 sensor
+floor. Two SteamVR base stations sweep the room with IR; each DotBot's LH2 sensor
 times the sweeps. Calibration is the one-time step that maps those raw sweep
-counts to metric coordinates: you place one bot on four known corners of a
+counts to metric coordinates: you place one DotBot on four known corners of a
 square, capture, and the resulting transform is pushed to the whole fleet.
 
 You do this once per physical setup (move a base station -> recalibrate).
 
-**The default flow is over the air** - drive one already-deployed bot through the
-corners over the swarm, no cable and no firmware swap. If you'd rather calibrate
-a single bot on the bench over USB, see
+**The default flow is over the air** - drive one already-deployed DotBot through
+the corners over the swarm, no cable and no firmware swap. If you'd rather
+calibrate a single DotBot on the bench over USB, see
 [LH2 calibration over a cable](lh2-calibration-cabled.md).
 
 ## Prerequisites
 
-- A provisioned swarm: a gateway plus sandbox-host bots, reachable from your
+- A provisioned swarm: a gateway plus sandbox-host DotBots, reachable from your
   config (see [swarm](../cli/swarm.md)).
 - Two LH2 base stations mounted ~2 m up, facing the arena.
 - A square marked on the floor with a known side length.
 - The `[calibrate]` extra (the homography solve uses opencv):
 
 ```bash
-pip install --pre 'pydotbot[calibrate]'
+pip install 'pydotbot[calibrate]'
 ```
 
 ## Capture and push
 
 The calibration is a property of the **arena** (the base-station layout), not the
-individual bot, so you capture once from any one bot and apply the result to the
-whole fleet. Two steps:
+individual DotBot, so you capture once from any one DotBot and apply the result
+to the whole fleet. Two steps:
 
 ```bash
-dotbot swarm stop                                  # put the bots in READY
+dotbot swarm stop                                  # put the DotBots in READY
 dotbot swarm lh2-calibration collect \
-    --device BC3D3C8A2A6F8E68 -d 500               # capture from one bot -> solve -> save
+    --device BC3D3C8A2A6F8E68 -d 500               # capture from one DotBot -> solve -> save
 dotbot swarm lh2-calibration push \
-    ~/.dotbot/calibration-<UTC>.toml               # apply to every ready bot
+    ~/.dotbot/calibration-<UTC>.toml               # apply to every ready DotBot
 ```
 
-`collect` walks one bot through the four corners - **top-left -> top-right ->
-bottom-left -> bottom-right** - (capture only runs while the bot is in READY, so
+`collect` walks one DotBot through the four corners - **top-left -> top-right ->
+bottom-left -> bottom-right** - (capture only runs while the DotBot is in READY, so
 `swarm stop` first). Each prompt triggers a raw-count capture over the air; it
 then solves the homography and saves a `calibration-<UTC>.toml` under `~/.dotbot/`
 (the path is printed at the end). Find the `--device` address with
 `dotbot swarm status`.
 
-`push` with **no `--device`** sends that calibration to **every ready bot** - the
-whole arena shares one transform. It accepts a `calibration-*.toml` or the legacy
-raw `calibration.out` payload; the format is picked by file extension.
+`push` with **no `--device`** sends that calibration to **every ready DotBot** -
+the whole arena shares one transform. It accepts a `calibration-*.toml` or the
+legacy raw `calibration.out` payload; the format is picked by file extension.
 
 ```{note}
-`collect --push` is a **single-bot shortcut**: it sends the result to *only* the
-`--device` bot you captured from (handy to spot-check that one bot, or for a
-single-bot setup). To calibrate the fleet, run the standalone `push` above - it
-targets all ready bots.
+`collect --push` is a **single-DotBot shortcut**: it sends the result to *only*
+the `--device` DotBot you captured from (handy to spot-check that one DotBot, or
+for a single-DotBot setup). To calibrate the fleet, run the standalone `push`
+above - it targets all ready DotBots.
 ```
 
-Once pushed, the bots report positions, which show up live in the
+Once pushed, the DotBots report positions, which show up live in the
 [controller](../cli/run.md) Web UI.
 
 ### `collect` flags
@@ -70,7 +70,7 @@ Once pushed, the bots report positions, which show up live in the
 | `--timeout` | `5` s | Seconds to wait for each capture before re-triggering. |
 | `--retries` | `3` | Re-trigger this many times per corner before giving up. |
 | `--tag` | - | Arena/setup label (e.g. `office-2x2m`) added to the filename + metadata. |
-| `--push` | off | After solving, send to the captured `--device` bot **only** (use the standalone `push` for the whole fleet). |
+| `--push` | off | After solving, send to the captured `--device` DotBot **only** (use the standalone `push` for the whole fleet). |
 
 See `dotbot swarm lh2-calibration collect --help` for the full list.
 
@@ -97,18 +97,18 @@ side):
                   ⌖ LH2 base station (mounted ~2 m up, facing the arena)
 ```
 
-`TL/TR/BL/BR` are the four reference points you place the bot on; `d` is the
+`TL/TR/BL/BR` are the four reference points you place the DotBot on; `d` is the
 square side (`--distance`, in mm), `5·d` the resulting arena.
 
 | `-d` | Square | Usable arena |
 |---|---|---|
 | `400` | 40 cm | 2.0 m × 2.0 m |
 | `500` | 50 cm | 2.5 m × 2.5 m |
-| `800` | 80 cm | 4.0 m × 4.0 m (used for the 725-bot Limerick run) |
+| `800` | 80 cm | 4.0 m × 4.0 m (used for the 725-DotBot Limerick run) |
 
 ## Troubleshooting
 
-- **Capture times out** - the bot isn't in READY (run `dotbot swarm stop`
+- **Capture times out** - the DotBot isn't in READY (run `dotbot swarm stop`
   first), or it can't see both base stations. The address passed to `--device`
   must match one from `dotbot swarm status`.
 - **Positions look skewed or mirrored** - the corners were captured out of