feetech-cli 0.1.2__tar.gz → 0.1.3__tar.gz

{feetech_cli-0.1.2 → feetech_cli-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: feetech-cli
-Version: 0.1.2
+Version: 0.1.3
 Summary: Command line tool to inspect and configure FEETECH STS/SMS/SCS serial bus servos
 Author-email: Iori Yanokura <ab.ioryz@gmail.com>
 License-Expression: MIT
@@ -466,3 +466,90 @@ Sources:
 ## License
 
 MIT
+
+## Other devices on the bus
+
+A FEETECH bus can carry more than servos: any board that speaks the same
+framing can sit next to the joints it works with. Its control table is its
+own, though, and reading it through the servo table gives nonsense (an id of
+48, a 250 kbps speed) while writing through it corrupts the board.
+
+feetech-cli itself only knows FEETECH servos. Any other device is described by
+a JSON **device file**, normally shipped by whoever makes the device, and
+loaded from
+
+1. `--device-file PATH` (a file or a directory of them, repeatable),
+2. `$FEETECH_CLI_DEVICES` (files or directories, separated like `PATH`),
+3. `~/.config/feetech-cli/devices/*.json` (or `$XDG_CONFIG_HOME/...`).
+
+With a device file loaded, every id is identified once by reading the bytes its
+`match` names; a match gets the file's control table, everything else is a
+servo as before. With none loaded nothing extra is sent on the bus.
+
+Two boards that share a model number -- the same firmware on two board
+revisions, say -- are told apart by listing more than one place to look:
+
+```json
+"match": [{"address": 0, "bytes": "3412455842"}, {"address": 40, "bytes": "03"}]
+```
+
+```json
+{
+  "name": "Example sensor board",
+  "match": {"address": 0, "bytes": "3412455842"},
+  "settle_time": 1.0,
+  "registers": {
+    "model_number": {"address": 0, "size": 2},
+    "id":        {"address": 7, "size": 1, "writable": true},
+    "baud_rate": {"address": 8, "size": 1, "writable": true},
+    "mode":      {"address": 20, "size": 1, "writable": true,
+                  "values": {"0": "off", "1": "on"}},
+    "pressure":  {"address": 24, "size": 2, "signed": true,
+                  "scale": 0.01, "unit": "kPa", "digits": 2},
+    "acc_range_g": {"address": 12, "size": 2},
+    "acc_z":     {"address": 26, "size": 2, "signed": true, "unit": "g",
+                  "scale_by": {"register": "acc_range_g", "divisor": 32768}},
+    "error":     {"address": 30, "size": 1, "bits": {"0": "imu", "3": "adc"}}
+  },
+  "info": ["id", "mode", "pressure", "acc_z", "error"],
+  "summary": ["mode", "pressure"]
+}
+```
+
+| key | meaning |
+|---|---|
+| `name` | what the device is called in messages |
+| `match` | `address` and hex `bytes` found there on this device and no other; or a list of such objects, all of which must match (checked in order, so a servo is ruled out by the first READ) |
+| `registers` | name to `address`, `size` (1 or 2), `writable`, `signed` (two's complement), and optionally how to show it: `values` (number to label), `bits` (bit number to label), `scale` or `scale_by` (value × another register ÷ `divisor`), `unit`, `digits`; a writable register may add `settle_time`, the seconds the device stays silent after a write to it (while it saves the value to flash, say), and the write waits for it to answer before reading back |
+| `settle_time` | seconds the device may stay silent after an id or speed change (default 1) |
+| `baudrate_table` | `"sts"` (default) or an object of `baud_rate` value to bits per second |
+| `eeprom_lock` | whether EEPROM writes need the servo-style `lock` register (default false) |
+| `info`, `summary` | registers `feetech info` and the `scan` line show |
+| `description` | free text |
+
+A file with a misspelt key, an unknown register in a list, or bytes that are
+not hex is rejected with the file and key named. A broken file is never
+skipped: that would identify the device as a servo and write servo registers
+into it.
+
+```console
+$ feetech --device-file my_board.json --max-id 20 scan
+Found 2 device(s) on /dev/ttyUSB0 at 1.00Mbps:
+  id   1  model   777  position  2048 (+0.0 deg)  12.1V  35C
+  id  10  Example sensor board (model 0x1234, fw 2)  mode 0 (off)  pressure -4210 (-42.10 kPa)
+$ feetech --device-file my_board.json info 10
+$ feetech --device-file my_board.json registers --device my_board
+$ feetech --device-file my_board.json --simulate scan    # try a file without hardware
+$ feetech --device-file my_board.json watch 10 acc_z pressure   # live, Ctrl-C to stop
+```
+
+`watch ID [REGISTER ...]` redraws the named registers (default: what `info`
+shows) every `--interval` seconds, reading neighbouring registers in one READ
+so six IMU axes cost one round trip. Off a terminal it prints one line per
+refresh, for logging; `--count` stops after that many. It works for servos too.
+
+`set-id` and `set-baud` write the device's own `id` and `baud_rate` registers
+directly: no torque, no EEPROM lock, then poll for up to `settle_time` while it
+commits them. Servo-only commands (`move`, `torque`, `mode`, `set-zero`,
+`selftest`, `factory-reset`) refuse such a device, and the status screen leaves
+it out.

{feetech_cli-0.1.2 → feetech_cli-0.1.3}/README.md

@@ -441,3 +441,90 @@ Sources:
 ## License
 
 MIT
+
+## Other devices on the bus
+
+A FEETECH bus can carry more than servos: any board that speaks the same
+framing can sit next to the joints it works with. Its control table is its
+own, though, and reading it through the servo table gives nonsense (an id of
+48, a 250 kbps speed) while writing through it corrupts the board.
+
+feetech-cli itself only knows FEETECH servos. Any other device is described by
+a JSON **device file**, normally shipped by whoever makes the device, and
+loaded from
+
+1. `--device-file PATH` (a file or a directory of them, repeatable),
+2. `$FEETECH_CLI_DEVICES` (files or directories, separated like `PATH`),
+3. `~/.config/feetech-cli/devices/*.json` (or `$XDG_CONFIG_HOME/...`).
+
+With a device file loaded, every id is identified once by reading the bytes its
+`match` names; a match gets the file's control table, everything else is a
+servo as before. With none loaded nothing extra is sent on the bus.
+
+Two boards that share a model number -- the same firmware on two board
+revisions, say -- are told apart by listing more than one place to look:
+
+```json
+"match": [{"address": 0, "bytes": "3412455842"}, {"address": 40, "bytes": "03"}]
+```
+
+```json
+{
+  "name": "Example sensor board",
+  "match": {"address": 0, "bytes": "3412455842"},
+  "settle_time": 1.0,
+  "registers": {
+    "model_number": {"address": 0, "size": 2},
+    "id":        {"address": 7, "size": 1, "writable": true},
+    "baud_rate": {"address": 8, "size": 1, "writable": true},
+    "mode":      {"address": 20, "size": 1, "writable": true,
+                  "values": {"0": "off", "1": "on"}},
+    "pressure":  {"address": 24, "size": 2, "signed": true,
+                  "scale": 0.01, "unit": "kPa", "digits": 2},
+    "acc_range_g": {"address": 12, "size": 2},
+    "acc_z":     {"address": 26, "size": 2, "signed": true, "unit": "g",
+                  "scale_by": {"register": "acc_range_g", "divisor": 32768}},
+    "error":     {"address": 30, "size": 1, "bits": {"0": "imu", "3": "adc"}}
+  },
+  "info": ["id", "mode", "pressure", "acc_z", "error"],
+  "summary": ["mode", "pressure"]
+}
+```
+
+| key | meaning |
+|---|---|
+| `name` | what the device is called in messages |
+| `match` | `address` and hex `bytes` found there on this device and no other; or a list of such objects, all of which must match (checked in order, so a servo is ruled out by the first READ) |
+| `registers` | name to `address`, `size` (1 or 2), `writable`, `signed` (two's complement), and optionally how to show it: `values` (number to label), `bits` (bit number to label), `scale` or `scale_by` (value × another register ÷ `divisor`), `unit`, `digits`; a writable register may add `settle_time`, the seconds the device stays silent after a write to it (while it saves the value to flash, say), and the write waits for it to answer before reading back |
+| `settle_time` | seconds the device may stay silent after an id or speed change (default 1) |
+| `baudrate_table` | `"sts"` (default) or an object of `baud_rate` value to bits per second |
+| `eeprom_lock` | whether EEPROM writes need the servo-style `lock` register (default false) |
+| `info`, `summary` | registers `feetech info` and the `scan` line show |
+| `description` | free text |
+
+A file with a misspelt key, an unknown register in a list, or bytes that are
+not hex is rejected with the file and key named. A broken file is never
+skipped: that would identify the device as a servo and write servo registers
+into it.
+
+```console
+$ feetech --device-file my_board.json --max-id 20 scan
+Found 2 device(s) on /dev/ttyUSB0 at 1.00Mbps:
+  id   1  model   777  position  2048 (+0.0 deg)  12.1V  35C
+  id  10  Example sensor board (model 0x1234, fw 2)  mode 0 (off)  pressure -4210 (-42.10 kPa)
+$ feetech --device-file my_board.json info 10
+$ feetech --device-file my_board.json registers --device my_board
+$ feetech --device-file my_board.json --simulate scan    # try a file without hardware
+$ feetech --device-file my_board.json watch 10 acc_z pressure   # live, Ctrl-C to stop
+```
+
+`watch ID [REGISTER ...]` redraws the named registers (default: what `info`
+shows) every `--interval` seconds, reading neighbouring registers in one READ
+so six IMU axes cost one round trip. Off a terminal it prints one line per
+refresh, for logging; `--count` stops after that many. It works for servos too.
+
+`set-id` and `set-baud` write the device's own `id` and `baud_rate` registers
+directly: no torque, no EEPROM lock, then poll for up to `settle_time` while it
+commits them. Servo-only commands (`move`, `torque`, `mode`, `set-zero`,
+`selftest`, `factory-reset`) refuse such a device, and the status screen leaves
+it out.

{feetech_cli-0.1.2 → feetech_cli-0.1.3}/feetech_cli/__init__.py

@@ -7,7 +7,7 @@ from feetech_cli.protocol import FeetechStatusError
 from feetech_cli.protocol import FeetechTimeoutError
 from feetech_cli.protocol import PacketHandler
 
-__version__ = "0.1.2"
+__version__ = "0.1.3"
 
 __all__ = [
     "FeetechServoController",

{feetech_cli-0.1.2 → feetech_cli-0.1.3}/feetech_cli/cli.py

@@ -2,6 +2,7 @@
 
 import argparse
 import sys
+import time
 
 import colorama
 from colorama import Fore
@@ -9,11 +10,15 @@ from colorama import Style
 
 from feetech_cli.controller import FeetechServoController
 from feetech_cli.controller import list_candidate_ports
+from feetech_cli.devices import SERVO
+from feetech_cli.devices import DeviceFileError
+from feetech_cli.devices import default_device_dir
+from feetech_cli.devices import format_value
+from feetech_cli.devices import load_profiles
 from feetech_cli.protocol import FeetechError
 from feetech_cli.registers import BAUDRATE_INDEX
 from feetech_cli.registers import BAUDRATE_TABLE
 from feetech_cli.registers import CENTER_POSITION
-from feetech_cli.registers import CONTROL_TABLE
 from feetech_cli.registers import DEFAULT_MAX_ID
 from feetech_cli.registers import DEFAULT_MIN_ID
 from feetech_cli.registers import INFO_REGISTERS
@@ -68,6 +73,14 @@ def build_parser():
         "--scs", action="store_true",
         help="talk to the older big endian SCS series instead of STS/SMS",
     )
+    parser.add_argument(
+        "--device-file", action="append", default=[], metavar="PATH",
+        help=(
+            "JSON file (or directory of them) describing a non-servo device that "
+            "may share the bus; repeatable. Also read from $FEETECH_CLI_DEVICES "
+            "and ~/.config/feetech-cli/devices/*.json."
+        ),
+    )
     parser.add_argument(
         "--simulate", action="store_true",
         help=(
@@ -108,6 +121,23 @@ def build_parser():
     )
     set_baud.add_argument("-y", "--yes", action="store_true", help="do not ask for confirmation")
 
+    watch = sub.add_parser(
+        "watch", help="show registers of one device live (IMU, pressure, position, ...)"
+    )
+    watch.add_argument("id", type=int, help="device id")
+    watch.add_argument(
+        "registers", nargs="*",
+        help="register names (default: what 'feetech info' shows for that device)",
+    )
+    watch.add_argument(
+        "-i", "--interval", type=float, default=0.1,
+        help="seconds between refreshes (default: %(default)s)",
+    )
+    watch.add_argument(
+        "-n", "--count", type=int, default=None,
+        help="stop after this many refreshes (default: until Ctrl-C)",
+    )
+
     read = sub.add_parser("read", help="read one register")
     read.add_argument("id", type=int, help="servo id")
     read.add_argument("register", help="register name, see 'feetech registers'")
@@ -117,7 +147,11 @@ def build_parser():
     write.add_argument("register", help="register name, see 'feetech registers'")
     write.add_argument("value", type=int, help="value to write")
 
-    sub.add_parser("registers", help="list the register names of the control table")
+    registers = sub.add_parser("registers", help="list the register names of the control table")
+    registers.add_argument(
+        "--device", default="servo",
+        help="whose control table to list: 'servo' (default) or a loaded device file's name",
+    )
 
     move = sub.add_parser("move", help="command a servo to a position")
     move.add_argument("id", type=int, help="servo id")
@@ -232,6 +266,7 @@ def make_controller(args):
         little_endian=not args.scs,
         min_id=args.min_id,
         max_id=args.max_id,
+        device_profiles=args.device_profiles,
     )
 
 
@@ -250,10 +285,18 @@ def attach_simulator(controller, args):
         Parsed arguments.
     """
     from feetech_cli.protocol import PacketHandler
+    from feetech_cli.simulator import SimulatedBoard
     from feetech_cli.simulator import build_demo_bus
 
     baudrate = args.baudrate or 1000000
     bus = build_demo_bus(servo_ids=(1, 2, 3), baudrate=baudrate)
+    # One simulated device per loaded device file, so a new file can be tried
+    # before the hardware exists.
+    boards = []
+    for offset, profile in enumerate(args.device_profiles):
+        if "id" in profile.control_table and "baud_rate" in profile.control_table:
+            boards.append(SimulatedBoard(profile, board_id=10 + offset))
+    bus.servos.extend(boards)
     controller.requested_port = bus.port
     controller.requested_baudrate = baudrate
 
@@ -272,8 +315,9 @@ def attach_simulator(controller, args):
 
     controller._open_port = open_port
     controller.is_simulated = True
+    extra = "".join(f", {b.profile.name} at id {b.servo_id}" for b in boards)
     print(
-        f"{Fore.YELLOW}Simulated bus: three servos at ids 1, 2 and 3. "
+        f"{Fore.YELLOW}Simulated bus: three servos at ids 1, 2 and 3{extra}. "
         f"No hardware is involved.{Style.RESET_ALL}"
     )
 
@@ -335,11 +379,16 @@ def command_scan(args, controller):
     if not found:
         _print_empty_bus(controller)
         return 1
+    profiles = {servo_id: controller.device_profile(servo_id) for servo_id in found}
+    noun = "servo(s)" if all(p.is_servo for p in profiles.values()) else "device(s)"
     print(
-        f"Found {len(found)} servo(s) on {controller.serial.port} "
+        f"Found {len(found)} {noun} on {controller.serial.port} "
         f"at {format_baud(controller.baudrate)}bps:"
     )
     for servo_id in found:
+        if not profiles[servo_id].is_servo:
+            print(_device_summary(controller, servo_id, profiles[servo_id]))
+            continue
         model = controller.read_register(servo_id, "model_number")
         position = controller.read_register(servo_id, "present_position")
         voltage = controller.read_register(servo_id, "present_voltage")
@@ -353,6 +402,70 @@ def command_scan(args, controller):
     return 0
 
 
+def _device_summary(controller, servo_id, profile):
+    """One scan line for a device that is not a servo.
+
+    Parameters
+    ----------
+    controller : FeetechServoController
+        An open controller.
+    servo_id : int
+        Device id.
+    profile : DeviceProfile
+        What the device was identified as.
+
+    Returns
+    -------
+    str
+        The line to print: the device's name, its model and firmware when its
+        device file names them, then its ``summary`` registers.
+    """
+    table = profile.control_table
+    header = [name for name in ("model_number", "firmware_version") if name in table]
+    shown = list(profile.summary_registers)
+    values = controller.dump(servo_id, _with_references(profile, header + shown))
+    details = []
+    if "model_number" in table:
+        model = values["model_number"]
+        details.append("model " + ("?" if model is None else f"0x{model:04X}"))
+    if "firmware_version" in table:
+        details.append(f"fw {_plain_value(values['firmware_version'])}")
+    line = f"  id {servo_id:>3}  {profile.name}"
+    if details:
+        line += f" ({', '.join(details)})"
+    for name in shown:
+        line += f"  {name} {_annotate(name, values[name], values, profile)}"
+    return line
+
+
+def _with_references(profile, names):
+    """Add the registers that ``scale_by`` rules of ``names`` need.
+
+    Parameters
+    ----------
+    profile : DeviceProfile
+        The device's profile.
+    names : list of str
+        Registers about to be shown.
+
+    Returns
+    -------
+    list of str
+        ``names`` followed by any missing reference registers.
+    """
+    out = list(names)
+    for name in names:
+        rule = profile.formats.get(name, {})
+        if "scale_by" in rule and rule["scale_by"][0] not in out:
+            out.append(rule["scale_by"][0])
+    return out
+
+
+def _plain_value(value):
+    """Render an optional register value."""
+    return "?" if value is None else str(value)
+
+
 def resolve_servo_id(controller, servo_id):
     """Pick the servo to act on when the user did not name one.
 
@@ -403,25 +516,31 @@ def command_info(args, controller):
         Process exit status.
     """
     servo_id = resolve_servo_id(controller, args.id)
-    names = list(CONTROL_TABLE) if args.all else INFO_REGISTERS
-    values = controller.dump(servo_id, names)
+    profile = controller.device_profile(servo_id)
+    table = profile.control_table
+    if args.all:
+        names = list(table)
+    else:
+        names = list(profile.info_registers or INFO_REGISTERS)
+    values = controller.dump(servo_id, _with_references(profile, names))
     width = max(len(name) for name in names)
-    print(f"Servo {servo_id} on {controller.serial.port} at {format_baud(controller.baudrate)}bps")
+    kind = "Servo" if profile.is_servo else profile.name[:1].upper() + profile.name[1:]
+    print(f"{kind} {servo_id} on {controller.serial.port} at {format_baud(controller.baudrate)}bps")
     for name in names:
-        register = CONTROL_TABLE[name]
+        register = table[name]
         value = values[name]
         print(
             "  {:<{width}}  addr {:>3}  {}".format(
                 name,
                 register.address,
-                _annotate(name, value, values),
+                _annotate(name, value, values, profile),
                 width=width,
             )
         )
     return 0
 
 
-def _annotate(name, value, context=None):
+def _annotate(name, value, context=None, profile=SERVO):
     """Render a register value with a unit or label where one applies.
 
     Parameters
@@ -433,6 +552,9 @@ def _annotate(name, value, context=None):
     context : dict or None, optional
         Other register values of the same servo. ``present_current`` uses
         ``model_number`` and ``present_load`` from it.
+    profile : DeviceProfile, optional
+        The device's kind. For a device file, its own display rules apply and
+        the servo ones never do.
 
     Returns
     -------
@@ -441,6 +563,11 @@ def _annotate(name, value, context=None):
     """
     if value is None:
         return "no data"
+    if not profile.is_servo:
+        if name == "baud_rate" and value in profile.baudrate_table:
+            return f"{value} ({format_baud(profile.baudrate_table[value])}bps)"
+        rendered = format_value(profile, name, value, context)
+        return str(value) if rendered is None else rendered
     if name == "baud_rate":
         baud = BAUDRATE_TABLE.get(value)
         if baud is None:
@@ -483,19 +610,46 @@ def command_set_id(args, controller):
     int
         Process exit status.
     """
+    kind, memory = _kind_and_memory(controller, args.old_id)
     if not confirm(
-        f"Change servo {args.old_id} to id {args.new_id}? This writes the servo EEPROM.",
+        f"Change {kind.lower()} {args.old_id} to id {args.new_id}? This writes the {memory}.",
         args.yes,
     ):
         print("Cancelled.")
         return 1
     confirmed = controller.set_id(args.old_id, args.new_id)
     print(
-        f"{Fore.GREEN}Servo {args.old_id} is now id {confirmed}.{Style.RESET_ALL}"
+        f"{Fore.GREEN}{kind} {args.old_id} is now id {confirmed}.{Style.RESET_ALL}"
     )
     return 0
 
 
+def _kind_and_memory(controller, servo_id):
+    """Name a device and the memory a setting change writes, for messages.
+
+    Parameters
+    ----------
+    controller : FeetechServoController
+        An open controller.
+    servo_id : int
+        Device id.
+
+    Returns
+    -------
+    tuple of (str, str)
+        ``("Servo", "servo EEPROM")`` or, for another kind of device, its
+        capitalised name and ``"board's flash"``.
+    """
+    try:
+        profile = controller.device_profile(servo_id)
+    except FeetechError:
+        # Absent ids are reported by set_id / set_baudrate themselves.
+        return "Servo", "servo EEPROM"
+    if profile.is_servo:
+        return "Servo", "servo EEPROM"
+    return profile.name[:1].upper() + profile.name[1:], "board's flash"
+
+
 def command_set_baud(args, controller):
     """Change the bus speed a servo uses.
 
@@ -511,16 +665,17 @@ def command_set_baud(args, controller):
     int
         Process exit status.
     """
+    kind, memory = _kind_and_memory(controller, args.id)
     if not confirm(
-        f"Set servo {args.id} to {format_baud(args.new_baudrate)}bps? "
-        f"This writes the servo EEPROM.",
+        f"Set {kind.lower()} {args.id} to {format_baud(args.new_baudrate)}bps? "
+        f"This writes the {memory}.",
         args.yes,
     ):
         print("Cancelled.")
         return 1
     confirmed = controller.set_baudrate(args.id, args.new_baudrate)
     print(
-        f"{Fore.GREEN}Servo {args.id} now runs at {format_baud(confirmed)}bps.{Style.RESET_ALL}"
+        f"{Fore.GREEN}{kind} {args.id} now runs at {format_baud(confirmed)}bps.{Style.RESET_ALL}"
     )
     print(f"Pass --baudrate {confirmed} on later calls, or let it be auto detected.")
     return 0
@@ -542,10 +697,14 @@ def command_read(args, controller):
         Process exit status.
     """
     value = controller.read_register(args.id, args.register)
+    profile = controller.device_profile(args.id)
     context = None
-    if args.register == "present_current":
+    if not profile.is_servo:
+        references = _with_references(profile, [args.register])[1:]
+        context = controller.dump(args.id, references) if references else None
+    elif args.register == "present_current":
         context = controller.dump(args.id, ["model_number", "present_load"])
-    print(f"{args.register} = {_annotate(args.register, value, context)}")
+    print(f"{args.register} = {_annotate(args.register, value, context, profile)}")
     return 0
 
 
@@ -573,7 +732,8 @@ def command_write(args, controller):
         )
         return 1
     value = controller.write_register(args.id, args.register, args.value)
-    print(f"{args.register} = {_annotate(args.register, value)}")
+    profile = controller.device_profile(args.id)
+    print(f"{args.register} = {_annotate(args.register, value, None, profile)}")
     if value != args.value:
         print(
             f"{Fore.RED}Read back {value} but {args.value} was written; "
@@ -583,6 +743,72 @@ def command_write(args, controller):
     return 0
 
 
+def command_watch(args, controller):
+    """Show registers of one device, refreshed in place.
+
+    Each refresh reads every shown register (plus any a ``scale_by`` rule
+    needs) in as few READs as possible. On a terminal the block is redrawn in
+    place; otherwise one line per refresh is printed, which suits logging.
+
+    Parameters
+    ----------
+    args : argparse.Namespace
+        Parsed arguments.
+    controller : FeetechServoController
+        An open controller.
+
+    Returns
+    -------
+    int
+        Process exit status.
+    """
+    profile = controller.device_profile(args.id)
+    names = list(args.registers) or list(profile.info_registers or INFO_REGISTERS)
+    unknown = [name for name in names if name not in profile.control_table]
+    if unknown:
+        print(
+            f"{Fore.RED}Unknown register(s) {', '.join(unknown)} for a {profile.name}; "
+            f"see 'feetech registers --device {profile.key}'.{Style.RESET_ALL}"
+        )
+        return 1
+    to_read = _with_references(profile, names)
+    interactive = sys.stdout.isatty()
+    width = max(len(name) for name in names)
+    drawn = 0
+    refreshes = 0
+    started = time.monotonic()
+    try:
+        while args.count is None or refreshes < args.count:
+            tick = time.monotonic()
+            values = controller.read_registers(args.id, to_read)
+            refreshes += 1
+            rate = refreshes / max(time.monotonic() - started, 1e-6)
+            if interactive:
+                lines = [
+                    f"{profile.name} {args.id}  {rate:5.1f} Hz  (Ctrl-C to stop)"
+                ] + [
+                    "  {:<{width}}  {}".format(
+                        name, _annotate(name, values[name], values, profile), width=width
+                    )
+                    for name in names
+                ]
+                if drawn:
+                    sys.stdout.write(f"\x1b[{drawn}F")
+                sys.stdout.write("".join(f"\x1b[2K{line}\n" for line in lines))
+                sys.stdout.flush()
+                drawn = len(lines)
+            else:
+                print("  ".join(
+                    f"{name}={_annotate(name, values[name], values, profile)}" for name in names
+                ))
+            remaining = args.interval - (time.monotonic() - tick)
+            if remaining > 0 and (args.count is None or refreshes < args.count):
+                time.sleep(remaining)
+    except KeyboardInterrupt:
+        print()
+    return 0
+
+
 def command_registers(args):
     """List the control table.
 
@@ -596,8 +822,18 @@ def command_registers(args):
     int
         Process exit status.
     """
-    width = max(len(name) for name in CONTROL_TABLE)
-    for name, register in sorted(CONTROL_TABLE.items(), key=lambda kv: kv[1].address):
+    known = {SERVO.key: SERVO}
+    known.update({profile.key: profile for profile in args.device_profiles})
+    if args.device not in known:
+        print(
+            f"{Fore.RED}No device '{args.device}'. Known: {', '.join(sorted(known))}. "
+            f"Load its file with --device-file or put it in {default_device_dir()}."
+            f"{Style.RESET_ALL}"
+        )
+        return 1
+    table = known[args.device].control_table
+    width = max(len(name) for name in table)
+    for name, register in sorted(table.items(), key=lambda kv: kv[1].address):
         print(
             "  {:<{width}}  addr {:>3}  {} byte  {:<6}  {}".format(
                 name, register.address, register.size, register.area,
@@ -728,6 +964,13 @@ def command_monitor(args, controller):
         Process exit status.
     """
     found = controller.scan()
+    others = [sid for sid in found if not controller.is_servo(sid)]
+    found = [sid for sid in found if sid not in others]
+    for sid in others:
+        print(
+            f"{Fore.YELLOW}id {sid} is a {controller.device_profile(sid).name}, not a "
+            f"servo; 'feetech info {sid}' shows it.{Style.RESET_ALL}"
+        )
     if not found:
         # Start anyway and wait. A servo plugged in later
         # is picked up without restarting the tool.
@@ -878,6 +1121,7 @@ BUS_COMMANDS = {
     "set-baud": command_set_baud,
     "read": command_read,
     "write": command_write,
+    "watch": command_watch,
     "move": command_move,
     "torque": command_torque,
     "mode": command_mode,
@@ -904,6 +1148,11 @@ def main(argv=None):
     colorama.init()
     parser = build_parser()
     args = parser.parse_args(argv)
+    try:
+        args.device_profiles = load_profiles(args.device_file)
+    except DeviceFileError as error:
+        print(f"{Fore.RED}Device file: {error}{Style.RESET_ALL}")
+        return 2
 
     if args.command == "ports":
         return command_ports(args)