embeddedci 2.13.2__tar.gz → 2.13.3__tar.gz

{embeddedci-2.13.2 → embeddedci-2.13.3}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog — `embeddedci`
 
+## 2.13.3
+
+- The DMM-guided calibration (pod firmware 3.9.4+, `Capabilities.cal_dmm`):
+  `BenchPod.calibrate_dac(path, points)` stores this pod's own line for a DAC output from two
+  `(code16, volts)` DMM readings, `calibrate_adc_gain(source)` measures an ADC gain (`cal1`,
+  `cal2`, `ext`) through a loopback, and `clear_calibration(part)` clears one part (`offset`,
+  `dac`, `adc`). `Calibration` gains `dac` (`DacLine`), `adc_gain_ppm`, `dmm` and `measured`;
+  `BenchPod.DMM_SET_POINTS` has the set points. New types `DacCalPath`, `AdcGainSource`,
+  `CalibrationPart`. `Calibration.zero_count` is the raw J8-open zero the pod derives its offset from.
+
 ## 2.13.2
 
 - Docs: `calibrate()` corrects every ADC source from firmware 3.9.3 (they share the front end) and

{embeddedci-2.13.2 → embeddedci-2.13.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: embeddedci
-Version: 2.13.2
+Version: 2.13.3
 Summary: BenchPod SDK and pytest plugin for EmbeddedCI hardware-in-the-loop testing
 Project-URL: Homepage, https://embeddedci.com
 Project-URL: Repository, https://github.com/embeddedci-com/embeddedci-python
@@ -1046,8 +1046,45 @@ and keeps what it had. `a` and `b` are the fit the pod now uses for `current_in`
 Every ADC source shares the same front end after its input switch, so from firmware 3.9.3 the pod
 takes the offset out of all of them: `adc_read` on `ext`, `cal1` and `cal2`, and `capture_adc`,
 whose `volts` use the fit the pod reports (on the LAN in `status`, through embeddedci.com in its
-capabilities). Older firmware corrects `current_in` only. Only the offset is calibrated; the gain
-uses the built-in fits. Needs firmware 3.4.0 (capability `calibrate`, `Capabilities.calibrate`).
+capabilities). Older firmware corrects `current_in` only. Needs firmware 3.4.0 (capability
+`calibrate`, `Capabilities.calibrate`). The web app has it in the pod's Settings tab, under
+Calibration.
+
+#### Calibrating with a DMM
+
+With a bench DMM the pod can also take out what the offset leaves (firmware 3.9.4+, capability
+`cal_dmm`, `Capabilities.cal_dmm`): its own DAC line per output, then the ADC gain per source.
+Every step is optional and stored on its own; an output or source without one keeps the built-in
+fit. Disconnect the DUT from the DAC outputs first: this drives up to ±5 V on them.
+
+```python
+points = []
+for volts in bp.DMM_SET_POINTS["5v"]:            # 1.0 and 4.0 V; 3v3: 0.5 / 3.0, 12v: -5 / +5
+    out = bp.dac_output("5v", volts=volts)
+    points.append((out.code16, read_dmm()))      # the DMM on the 5 V output SMA, DC volts
+cal = bp.calibrate_dac("5v", points)             # this pod's line for the 5 V output
+bp.dac_output("off")
+print(cal.dac["5v"])                             # DacLine(a, b, offset=-0.0031, gain_ppm=-996)
+
+bp.calibrate_adc_gain("cal1")                    # 5 V loopback, against the line just stored
+bp.calibrate_adc_gain("ext")                     # needs the 12v line and an SMA cable ±12 V -> ADC in
+bp.clear_calibration("dac")                      # one part: "offset", "dac" or "adc"; no part = all
+```
+
+`calibrate_dac(path, points)` takes two `(code16, volts)` pairs: the 16-bit code `dac_output`
+drove and the DMM reading. From then on `dac_output`, the calibrated `generate` and the DAC output
+limits convert with this pod's line (`DacLine`: `a`, `b` per 16-bit code, `offset`, `gain_ppm`
+against the built-in line). `calibrate_adc_gain(source)` measures `cal1` through the 5 V output,
+`cal2` through the ±12 V output and `ext` (the front SMA, which `capture_adc` and the control loop
+use) through an SMA cable from the ±12 V output to the ADC input; `current_in` follows `cal1`. It
+needs the ADC offset and the driving output's DMM line, and `Calibration.measured` says what it
+saw. The pod refuses (`BenchPodError`) and keeps what it had when a reading cannot be right: two
+codes too close, a reading far from what the output should give (the DMM on another SMA), a gain
+more than 2 % off. It also refuses while DAC output limits are set. `Calibration.dac`,
+`Calibration.adc_gain_ppm` and `Calibration.dmm` show what is stored. The pod stores raw
+measurements (the J8-open zero as `Calibration.zero_count`, the DMM points) and derives every fit
+from them, so a later firmware with re-measured built-in fits keeps them right. Going back to
+firmware 3.4.0 to 3.9.3 keeps the offset; the DMM parts are not used there.
 
 ### The 4-20 mA output
 
@@ -1631,7 +1668,7 @@ lease_wait=600.0, lease_ttl=120, wiring=None)`. A context manager; `close()` is
 | GPIO and pins | `gpio(la, mode="output", *, level=None)`, `gpio_pins(las, mode="output", *, level=None)`, `configure_gpio(las, mode="output", *, level=None)`, `set_gpio(la, level)`, `read_gpio(la)`, `wait_for_level(la, level, *, timeout, poll=0.005)` (`False` when `timeout` passes first), `pin_levels()`, `la_pins()`, `release_gpio(*las)`, `la_step(la, *, steps, delay, dir_la=None, direction=0)` |
 | I2C sensor | `enable_i2c_sensor(sensor=Sensor.BMP280, *, sda=None, scl=None, address=None, **values)`, `set_i2c_sensor(**values)`, `disable_i2c_sensor()`, `i2c_sensor_status()`, `i2c_sensor_types()`, `i2c_sensor_regs()`, `i2c_sensor_capture(...)` |
 | GPS receiver | `enable_gps(tx, *, baud=9600, rate_hz=1, sentences=None, utc=None, **fix)`, `set_gps(*, utc=None, **fix)`, `disable_gps()`, `gps_status()` |
-| Analog | `analog_path(path)`, `adc_read(source="ext")`, `dac_output(path, *, volts=None)`, `current_out(current)`, `current_out_range()`, `calibrate(source="current_in")`, `calibration()`, `clear_calibration()` |
+| Analog | `analog_path(path)`, `adc_read(source="ext")`, `dac_output(path, *, volts=None)`, `current_out(current)`, `current_out_range()`, `calibrate(source="current_in")`, `calibration()`, `clear_calibration(part=None)`, `calibrate_dac(path, points)`, `calibrate_adc_gain(source)`, `DMM_SET_POINTS` |
 | Captures | `capture_adc(...)`, `capture_la(...)`, `capture_correlated(...)`, `decode(source, protocol="i2c", ...)` |
 | DAC | `generate(...)`, `replay(...)`, `replay_waveform(...)`, `dac_stop()`, `control_loop(...)`, `loop_input(...)`, `loop_probe()` |
 | CAN | `open_can(*, bitrate=500000, mode="normal", term=False, fd=False)`, `can_config(...)`, `can_disable()`, `can_status()`, `can_term(on)`, `can_write(...)`, `can_read(...)`, `can_respond(...)`, `can_respond_clear()` |
@@ -1676,7 +1713,8 @@ few built from other shapes); `to_dict()` goes the other way where a type is sen
 | `AdcReading` | `adc_read` | `source`, `voltage`, `count`, `span`, `offset`, `current` |
 | `DacOutput` | `dac_output` | `path`, `voltage`, `code` |
 | `CurrentOutput` | `current_out`, `current_out_range` | `current`, `code`, `min_current`, `max_current` |
-| `Calibration` | `calibrate`, `calibration`, `clear_calibration` | `source`, `calibrated`, `offset`, `a`, `b`, `count`, `span`, `samples` |
+| `Calibration` | `calibrate`, `calibration`, `clear_calibration`, `calibrate_dac`, `calibrate_adc_gain` | `source`, `calibrated`, `offset`, `a`, `b`, `count`, `span`, `samples`, `dac`, `adc_gain_ppm`, `dmm`, `measured`, `zero_count` |
+| `DacLine` | `Calibration.dac` | `a`, `b`, `offset`, `gain_ppm` |
 | `Capture` | `capture_adc` | `counts`, `volts`, `currents`, `sample_rate_hz`, `source`, `trigger`, `duration`, `times()`, `mean()`, `min()`, `max()`, `rms()`, `rms_ac()`, `peak_to_peak()`, `first_crossing()`, `crossing_times()`, `fft()`, `dominant_frequency()` |
 | `LaCapture` | `capture_la` | `words`, `channels`, `sample_rate_hz`, `trigger`, `duration`, `channel(la)`, `level_at()`, `edges()`, `edge_times()`, `first_edge()`, `delay()`, `frequency()`, `duty_cycle()`, `pulse_widths()`, `decode()` |
 | `CorrelatedCapture` | `capture_correlated` | `adc` (a `Capture`), `la` (a `LaCapture`), sharing one hardware trigger |
@@ -1720,7 +1758,7 @@ reported keeps its default (`False`, `0` or `""`), so a feature check is just
 | Identity | `board`, `firmware_version`, `board_rev` (`"v2"`, `"v3"`, `"unknown"`, or `""`), `la_vccio_mv` (the LA bank voltage the pod reports) |
 | ADC | `adc_bits`, `adc_fullscale_mv`, `adc_channels`, `adc_offset_counts`, `adc_affine` (the front-end fit), `adc_max_count`, `counts_to_volts(count)` |
 | DAC and replay | `dac`, `dac_dc`, `dac_replay`, `dac_deep_replay`, `dac_control_loop`, `dac_loop_sources` (gateware v29+), `dac_loop_input_map` (v30+), `dac_cotrig` (v27+), `generate16` (firmware 3.9.1+: `generate` in calibrated 16-bit volts), `dac_bits`, `dac_replay_bits`, `dac_replay_max_samples`, `dac_fullscale_mv`, `dac_channels`, `dac_limits` (output limits on the DAC paths) |
-| Features | `scope`, `analyzer`, `serial`, `tunnel`, `command`, `ota`, `la_pins`, `gpio_read` (direct pin reads, v35+), `capture_trigger` (v35+), `power_profile`, `capture_b64` (faster ADC read-back, used automatically), `nrst_pin` (the dedicated reset pin, rev3), `usb_cc` (rev3), `spi_master` (v45+), `spi_stream`, `calibrate`, `current_out`, `can`, `pod_current` (`PowerStatus.pod`), `sensor_types` (the BME280/SHT4x/MPU-6050 models), `gps` (the GPS receiver, gateware v48+), `analog` (`False` on the digital-only board, `None` when not announced) |
+| Features | `scope`, `analyzer`, `serial`, `tunnel`, `command`, `ota`, `la_pins`, `gpio_read` (direct pin reads, v35+), `capture_trigger` (v35+), `power_profile`, `capture_b64` (faster ADC read-back, used automatically), `nrst_pin` (the dedicated reset pin, rev3), `usb_cc` (rev3), `spi_master` (v45+), `spi_stream`, `calibrate`, `cal_dmm` (firmware 3.9.4+: `calibrate_dac`, `calibrate_adc_gain`), `current_out`, `can`, `pod_current` (`PowerStatus.pod`), `sensor_types` (the BME280/SHT4x/MPU-6050 models), `gps` (the GPS receiver, gateware v48+), `analog` (`False` on the digital-only board, `None` when not announced) |
 | Firmware updates and policies | `flash_kb` (MCU flash in KiB, 0 when not reported), `blob_slots`, `ota_sig`, `sig_policy` (`"audit"`, `"required"`, ...), `sig_keys`, `sig_policy_cmd`, `lan_policy` (`"open"`, `"locked"`, `"off"`), `lan_policy_cmd`, `tunnel_max_tier`, `lease_state` (the pod refuses LAN writes while a cloud job holds it), `cloud_ca`, `cloud_proxy`, `ws_auth_v2` (server only) |
 | Boot health | `safe_mode`, `safe_reason`, `last_crash`, `reset_cause`, `boot_warning()` (a one-line warning after safe mode or a crash, else `None`) |
 | Source | `raw` (the map it was parsed from) |
@@ -1761,7 +1799,7 @@ timeout=60.0, lease_id=None)`. Errors raise `ServerApiError` (`status`), and an
 | `curve_output_at(curve, input_code)`, `input_percent_to_code(percent)` | evaluate a curve the way the gateware does; an input percentage as a code |
 | `encode_curve_b64url(codes)` | 16-bit DAC codes as little-endian base64url, the wire form of a curve |
 | `INTERNAL`, `EXTERNAL`, `PIN1` … `PIN14`, `BMP280_ADDR_PRIMARY`, `BMP280_ADDR_SECONDARY` | named constants (see [API conventions](#api-conventions-and-stability)) |
-| `DacPath`, `DacOutputPath`, `AnalogPath`, `AdcSource`, `CalibrateSource` (`"current_in"`), `LoopSource`, `Waveshape`, `ReplayMapping`, `DecodeProtocol`, `CanMode`, `FaultType`, `GpioMode`, `Edge`, `TriggerEdge` | the `Literal` string types |
+| `DacPath`, `DacOutputPath`, `AnalogPath`, `AdcSource`, `CalibrateSource` (`"current_in"`), `DacCalPath` (`"3v3"`, `"5v"`, `"12v"`), `AdcGainSource` (`"cal1"`, `"cal2"`, `"ext"`), `CalibrationPart` (`"offset"`, `"dac"`, `"adc"`), `LoopSource`, `Waveshape`, `ReplayMapping`, `DecodeProtocol`, `CanMode`, `FaultType`, `GpioMode`, `Edge`, `TriggerEdge` | the `Literal` string types |
 | `decode`, `i2c`, `can`, `control_loop`, `motor_emulator`, `dsp` | submodules: off-device decoders, I2C helpers, CAN types, curve helpers, the emulator's registers, and `dsp`, a pure-Python mirror of the server's record-to-replay processing |
 
 ## Examples

{embeddedci-2.13.2 → embeddedci-2.13.3}/README.md

@@ -1008,8 +1008,45 @@ and keeps what it had. `a` and `b` are the fit the pod now uses for `current_in`
 Every ADC source shares the same front end after its input switch, so from firmware 3.9.3 the pod
 takes the offset out of all of them: `adc_read` on `ext`, `cal1` and `cal2`, and `capture_adc`,
 whose `volts` use the fit the pod reports (on the LAN in `status`, through embeddedci.com in its
-capabilities). Older firmware corrects `current_in` only. Only the offset is calibrated; the gain
-uses the built-in fits. Needs firmware 3.4.0 (capability `calibrate`, `Capabilities.calibrate`).
+capabilities). Older firmware corrects `current_in` only. Needs firmware 3.4.0 (capability
+`calibrate`, `Capabilities.calibrate`). The web app has it in the pod's Settings tab, under
+Calibration.
+
+#### Calibrating with a DMM
+
+With a bench DMM the pod can also take out what the offset leaves (firmware 3.9.4+, capability
+`cal_dmm`, `Capabilities.cal_dmm`): its own DAC line per output, then the ADC gain per source.
+Every step is optional and stored on its own; an output or source without one keeps the built-in
+fit. Disconnect the DUT from the DAC outputs first: this drives up to ±5 V on them.
+
+```python
+points = []
+for volts in bp.DMM_SET_POINTS["5v"]:            # 1.0 and 4.0 V; 3v3: 0.5 / 3.0, 12v: -5 / +5
+    out = bp.dac_output("5v", volts=volts)
+    points.append((out.code16, read_dmm()))      # the DMM on the 5 V output SMA, DC volts
+cal = bp.calibrate_dac("5v", points)             # this pod's line for the 5 V output
+bp.dac_output("off")
+print(cal.dac["5v"])                             # DacLine(a, b, offset=-0.0031, gain_ppm=-996)
+
+bp.calibrate_adc_gain("cal1")                    # 5 V loopback, against the line just stored
+bp.calibrate_adc_gain("ext")                     # needs the 12v line and an SMA cable ±12 V -> ADC in
+bp.clear_calibration("dac")                      # one part: "offset", "dac" or "adc"; no part = all
+```
+
+`calibrate_dac(path, points)` takes two `(code16, volts)` pairs: the 16-bit code `dac_output`
+drove and the DMM reading. From then on `dac_output`, the calibrated `generate` and the DAC output
+limits convert with this pod's line (`DacLine`: `a`, `b` per 16-bit code, `offset`, `gain_ppm`
+against the built-in line). `calibrate_adc_gain(source)` measures `cal1` through the 5 V output,
+`cal2` through the ±12 V output and `ext` (the front SMA, which `capture_adc` and the control loop
+use) through an SMA cable from the ±12 V output to the ADC input; `current_in` follows `cal1`. It
+needs the ADC offset and the driving output's DMM line, and `Calibration.measured` says what it
+saw. The pod refuses (`BenchPodError`) and keeps what it had when a reading cannot be right: two
+codes too close, a reading far from what the output should give (the DMM on another SMA), a gain
+more than 2 % off. It also refuses while DAC output limits are set. `Calibration.dac`,
+`Calibration.adc_gain_ppm` and `Calibration.dmm` show what is stored. The pod stores raw
+measurements (the J8-open zero as `Calibration.zero_count`, the DMM points) and derives every fit
+from them, so a later firmware with re-measured built-in fits keeps them right. Going back to
+firmware 3.4.0 to 3.9.3 keeps the offset; the DMM parts are not used there.
 
 ### The 4-20 mA output
 
@@ -1593,7 +1630,7 @@ lease_wait=600.0, lease_ttl=120, wiring=None)`. A context manager; `close()` is
 | GPIO and pins | `gpio(la, mode="output", *, level=None)`, `gpio_pins(las, mode="output", *, level=None)`, `configure_gpio(las, mode="output", *, level=None)`, `set_gpio(la, level)`, `read_gpio(la)`, `wait_for_level(la, level, *, timeout, poll=0.005)` (`False` when `timeout` passes first), `pin_levels()`, `la_pins()`, `release_gpio(*las)`, `la_step(la, *, steps, delay, dir_la=None, direction=0)` |
 | I2C sensor | `enable_i2c_sensor(sensor=Sensor.BMP280, *, sda=None, scl=None, address=None, **values)`, `set_i2c_sensor(**values)`, `disable_i2c_sensor()`, `i2c_sensor_status()`, `i2c_sensor_types()`, `i2c_sensor_regs()`, `i2c_sensor_capture(...)` |
 | GPS receiver | `enable_gps(tx, *, baud=9600, rate_hz=1, sentences=None, utc=None, **fix)`, `set_gps(*, utc=None, **fix)`, `disable_gps()`, `gps_status()` |
-| Analog | `analog_path(path)`, `adc_read(source="ext")`, `dac_output(path, *, volts=None)`, `current_out(current)`, `current_out_range()`, `calibrate(source="current_in")`, `calibration()`, `clear_calibration()` |
+| Analog | `analog_path(path)`, `adc_read(source="ext")`, `dac_output(path, *, volts=None)`, `current_out(current)`, `current_out_range()`, `calibrate(source="current_in")`, `calibration()`, `clear_calibration(part=None)`, `calibrate_dac(path, points)`, `calibrate_adc_gain(source)`, `DMM_SET_POINTS` |
 | Captures | `capture_adc(...)`, `capture_la(...)`, `capture_correlated(...)`, `decode(source, protocol="i2c", ...)` |
 | DAC | `generate(...)`, `replay(...)`, `replay_waveform(...)`, `dac_stop()`, `control_loop(...)`, `loop_input(...)`, `loop_probe()` |
 | CAN | `open_can(*, bitrate=500000, mode="normal", term=False, fd=False)`, `can_config(...)`, `can_disable()`, `can_status()`, `can_term(on)`, `can_write(...)`, `can_read(...)`, `can_respond(...)`, `can_respond_clear()` |
@@ -1638,7 +1675,8 @@ few built from other shapes); `to_dict()` goes the other way where a type is sen
 | `AdcReading` | `adc_read` | `source`, `voltage`, `count`, `span`, `offset`, `current` |
 | `DacOutput` | `dac_output` | `path`, `voltage`, `code` |
 | `CurrentOutput` | `current_out`, `current_out_range` | `current`, `code`, `min_current`, `max_current` |
-| `Calibration` | `calibrate`, `calibration`, `clear_calibration` | `source`, `calibrated`, `offset`, `a`, `b`, `count`, `span`, `samples` |
+| `Calibration` | `calibrate`, `calibration`, `clear_calibration`, `calibrate_dac`, `calibrate_adc_gain` | `source`, `calibrated`, `offset`, `a`, `b`, `count`, `span`, `samples`, `dac`, `adc_gain_ppm`, `dmm`, `measured`, `zero_count` |
+| `DacLine` | `Calibration.dac` | `a`, `b`, `offset`, `gain_ppm` |
 | `Capture` | `capture_adc` | `counts`, `volts`, `currents`, `sample_rate_hz`, `source`, `trigger`, `duration`, `times()`, `mean()`, `min()`, `max()`, `rms()`, `rms_ac()`, `peak_to_peak()`, `first_crossing()`, `crossing_times()`, `fft()`, `dominant_frequency()` |
 | `LaCapture` | `capture_la` | `words`, `channels`, `sample_rate_hz`, `trigger`, `duration`, `channel(la)`, `level_at()`, `edges()`, `edge_times()`, `first_edge()`, `delay()`, `frequency()`, `duty_cycle()`, `pulse_widths()`, `decode()` |
 | `CorrelatedCapture` | `capture_correlated` | `adc` (a `Capture`), `la` (a `LaCapture`), sharing one hardware trigger |
@@ -1682,7 +1720,7 @@ reported keeps its default (`False`, `0` or `""`), so a feature check is just
 | Identity | `board`, `firmware_version`, `board_rev` (`"v2"`, `"v3"`, `"unknown"`, or `""`), `la_vccio_mv` (the LA bank voltage the pod reports) |
 | ADC | `adc_bits`, `adc_fullscale_mv`, `adc_channels`, `adc_offset_counts`, `adc_affine` (the front-end fit), `adc_max_count`, `counts_to_volts(count)` |
 | DAC and replay | `dac`, `dac_dc`, `dac_replay`, `dac_deep_replay`, `dac_control_loop`, `dac_loop_sources` (gateware v29+), `dac_loop_input_map` (v30+), `dac_cotrig` (v27+), `generate16` (firmware 3.9.1+: `generate` in calibrated 16-bit volts), `dac_bits`, `dac_replay_bits`, `dac_replay_max_samples`, `dac_fullscale_mv`, `dac_channels`, `dac_limits` (output limits on the DAC paths) |
-| Features | `scope`, `analyzer`, `serial`, `tunnel`, `command`, `ota`, `la_pins`, `gpio_read` (direct pin reads, v35+), `capture_trigger` (v35+), `power_profile`, `capture_b64` (faster ADC read-back, used automatically), `nrst_pin` (the dedicated reset pin, rev3), `usb_cc` (rev3), `spi_master` (v45+), `spi_stream`, `calibrate`, `current_out`, `can`, `pod_current` (`PowerStatus.pod`), `sensor_types` (the BME280/SHT4x/MPU-6050 models), `gps` (the GPS receiver, gateware v48+), `analog` (`False` on the digital-only board, `None` when not announced) |
+| Features | `scope`, `analyzer`, `serial`, `tunnel`, `command`, `ota`, `la_pins`, `gpio_read` (direct pin reads, v35+), `capture_trigger` (v35+), `power_profile`, `capture_b64` (faster ADC read-back, used automatically), `nrst_pin` (the dedicated reset pin, rev3), `usb_cc` (rev3), `spi_master` (v45+), `spi_stream`, `calibrate`, `cal_dmm` (firmware 3.9.4+: `calibrate_dac`, `calibrate_adc_gain`), `current_out`, `can`, `pod_current` (`PowerStatus.pod`), `sensor_types` (the BME280/SHT4x/MPU-6050 models), `gps` (the GPS receiver, gateware v48+), `analog` (`False` on the digital-only board, `None` when not announced) |
 | Firmware updates and policies | `flash_kb` (MCU flash in KiB, 0 when not reported), `blob_slots`, `ota_sig`, `sig_policy` (`"audit"`, `"required"`, ...), `sig_keys`, `sig_policy_cmd`, `lan_policy` (`"open"`, `"locked"`, `"off"`), `lan_policy_cmd`, `tunnel_max_tier`, `lease_state` (the pod refuses LAN writes while a cloud job holds it), `cloud_ca`, `cloud_proxy`, `ws_auth_v2` (server only) |
 | Boot health | `safe_mode`, `safe_reason`, `last_crash`, `reset_cause`, `boot_warning()` (a one-line warning after safe mode or a crash, else `None`) |
 | Source | `raw` (the map it was parsed from) |
@@ -1723,7 +1761,7 @@ timeout=60.0, lease_id=None)`. Errors raise `ServerApiError` (`status`), and an
 | `curve_output_at(curve, input_code)`, `input_percent_to_code(percent)` | evaluate a curve the way the gateware does; an input percentage as a code |
 | `encode_curve_b64url(codes)` | 16-bit DAC codes as little-endian base64url, the wire form of a curve |
 | `INTERNAL`, `EXTERNAL`, `PIN1` … `PIN14`, `BMP280_ADDR_PRIMARY`, `BMP280_ADDR_SECONDARY` | named constants (see [API conventions](#api-conventions-and-stability)) |
-| `DacPath`, `DacOutputPath`, `AnalogPath`, `AdcSource`, `CalibrateSource` (`"current_in"`), `LoopSource`, `Waveshape`, `ReplayMapping`, `DecodeProtocol`, `CanMode`, `FaultType`, `GpioMode`, `Edge`, `TriggerEdge` | the `Literal` string types |
+| `DacPath`, `DacOutputPath`, `AnalogPath`, `AdcSource`, `CalibrateSource` (`"current_in"`), `DacCalPath` (`"3v3"`, `"5v"`, `"12v"`), `AdcGainSource` (`"cal1"`, `"cal2"`, `"ext"`), `CalibrationPart` (`"offset"`, `"dac"`, `"adc"`), `LoopSource`, `Waveshape`, `ReplayMapping`, `DecodeProtocol`, `CanMode`, `FaultType`, `GpioMode`, `Edge`, `TriggerEdge` | the `Literal` string types |
 | `decode`, `i2c`, `can`, `control_loop`, `motor_emulator`, `dsp` | submodules: off-device decoders, I2C helpers, CAN types, curve helpers, the emulator's registers, and `dsp`, a pure-Python mirror of the server's record-to-replay processing |
 
 ## Examples

{embeddedci-2.13.2 → embeddedci-2.13.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "embeddedci"
-version = "2.13.2"
+version = "2.13.3"
 description = "BenchPod SDK and pytest plugin for EmbeddedCI hardware-in-the-loop testing"
 readme = "README.md"
 requires-python = ">=3.10"

{embeddedci-2.13.2 → embeddedci-2.13.3}/src/embeddedci/benchpod/__init__.py

@@ -50,6 +50,9 @@ from .constants import (
     PIN14,
     AdcSource,
     CalibrateSource,
+    CalibrationPart,
+    DacCalPath,
+    AdcGainSource,
     AnalogPath,
     CanMode,
     DacOutputPath,
@@ -117,6 +120,7 @@ from .state import (
     AdcReading,
     AnalogPathState,
     Calibration,
+    DacLine,
     CurrentOutput,
     DacOutput,
     EfuseState,
@@ -161,6 +165,7 @@ __all__ = [
     "DacOutput",
     "AdcReading",
     "Calibration",
+    "DacLine",
     "CurrentOutput",
     "FpgaImageInfo",
     "LoopState",
@@ -254,6 +259,9 @@ __all__ = [
     "AnalogPath",
     "AdcSource",
     "CalibrateSource",
+    "CalibrationPart",
+    "DacCalPath",
+    "AdcGainSource",
     "Waveshape",
     "ReplayMapping",
     "LoopSource",

{embeddedci-2.13.2 → embeddedci-2.13.3}/src/embeddedci/benchpod/capabilities.py

@@ -176,6 +176,10 @@ class Capabilities:
     spi_stream: bool = False
     #: The pod can calibrate its own ADC and keeps the result: :meth:`BenchPod.calibrate`.
     calibrate: bool = False
+    #: ``calibrate`` also takes the DMM-guided forms (firmware 3.9.4+): this pod's own DAC line
+    #: per output and ADC gain per source, :meth:`BenchPod.calibrate_dac`,
+    #: :meth:`BenchPod.calibrate_adc_gain`.
+    cal_dmm: bool = False
     #: The pod can hold a current on its 4-20 mA output (J9): :meth:`BenchPod.current_out`.
     current_out: bool = False
     #: Classic CAN on the pod's CAN+/CAN- terminals: :meth:`BenchPod.open_can`. Firmware older
@@ -319,6 +323,7 @@ class Capabilities:
                 ("spi_master", "spi_master"),
                 ("spi_stream", "spi_stream"),
                 ("calibrate", "calibrate"),
+                ("cal_dmm", "cal_dmm"),
                 ("current_out", "current_out"),
                 ("can", "can"),
                 ("pod_current", "pod_current"),
@@ -379,7 +384,7 @@ class Capabilities:
             ("capture_b64", "cap.capture_b64"),
             ("nrst_pin", "cap.nrst_pin"), ("usb_cc", "cap.usb_cc"),
             ("spi_master", "cap.spi_master"), ("spi_stream", "cap.spi_stream"),
-            ("calibrate", "cap.calibrate"), ("current_out", "cap.current_out"),
+            ("calibrate", "cap.calibrate"), ("cal_dmm", "cap.cal_dmm"), ("current_out", "cap.current_out"),
             ("can", "cap.can"), ("pod_current", "cap.pod_current"),
             ("sensor_types", "cap.sensor_types"), ("gps", "cap.gps"),
             ("dac_limits", "cap.dac_limits"),

{embeddedci-2.13.2 → embeddedci-2.13.3}/src/embeddedci/benchpod/client.py

@@ -48,9 +48,12 @@ from . import uart as _uart
 from .capabilities import ADC_WRAP_SPAN, ADC_WRAP_THRESHOLD, Capabilities
 from .constants import (
     ADC_SOURCE_PATHS,
+    ADC_GAIN_SOURCES,
     ADC_SOURCES,
     ANALOG_PATHS,
     CALIBRATE_SOURCES,
+    CALIBRATION_PARTS,
+    DAC_CAL_PATHS,
     CAN_MODES,
     DAC_OUTPUT_PATHS,
     DAC_PATHS,
@@ -65,9 +68,12 @@ from .constants import (
     PULLUP_CHANNELS,
     REPLAY_MAPPINGS,
     WAVESHAPES,
+    AdcGainSource,
     AdcSource,
     AnalogPath,
     CalibrateSource,
+    CalibrationPart,
+    DacCalPath,
     CanMode,
     DacOutputPath,
     DacPath,
@@ -1255,10 +1261,66 @@ class BenchPod:
         self._require_capability("calibrate", "calibration")
         return Calibration.from_reply(self.command({"cmd": "calibrate"}))
 
-    def clear_calibration(self) -> Calibration:
-        """Remove the pod's stored calibration. It goes back to the built-in fit."""
+    def clear_calibration(self, part: Optional[CalibrationPart] = None) -> Calibration:
+        """Remove the pod's stored calibration. It goes back to the built-in fits.
+
+        ``part`` removes one part only (firmware 3.9.4+): ``"offset"`` (the ADC offset),
+        ``"dac"`` (the DMM lines of every DAC output) or ``"adc"`` (the ADC gains).
+        """
         self._require_capability("calibrate", "calibration")
-        return Calibration.from_reply(self.command({"cmd": "calibrate", "clear": True}))
+        if part is None:
+            return Calibration.from_reply(self.command({"cmd": "calibrate", "clear": True}))
+        check_choice(part, CALIBRATION_PARTS, "part")
+        self._require_capability("cal_dmm", "partial calibration clears")
+        return Calibration.from_reply(self.command({"cmd": "calibrate", "clear": part}))
+
+    #: The set points a DMM calibration drives on each output, in volts: well inside the range,
+    #: away from the output floor near 0 V. The pod's ADC gain step uses the same ones.
+    DMM_SET_POINTS: Dict[str, Tuple[float, float]] = {"3v3": (0.5, 3.0), "5v": (1.0, 4.0), "12v": (-5.0, 5.0)}
+
+    def calibrate_dac(self, path: DacCalPath,
+                      points: Sequence[Tuple[int, float]]) -> Calibration:
+        """Store this pod's own line for a DAC output from two DMM readings (firmware 3.9.4+).
+
+        ``points`` is two ``(code16, volts)`` pairs: the 16-bit code the pod drove (the
+        ``code16`` of :meth:`dac_output`) and what a DMM read on that output's SMA. Disconnect
+        the DUT from the output first. A typical run::
+
+            for v in pod.DMM_SET_POINTS["5v"]:
+                out = pod.dac_output("5v", volts=v)
+                points.append((out.code16, dmm.read_volts()))
+            pod.calibrate_dac("5v", points)
+            pod.dac_output("off")
+
+        From then on :meth:`dac_output`, the calibrated :meth:`generate` and the DAC output
+        limits convert with this line. Raises :class:`BenchPodError` when the pod refuses: the
+        codes are too close, a reading is far from what the output should give (the DMM is on
+        another SMA), or the gain is more than 2 % off. The stored line is then unchanged.
+        """
+        check_choice(path, DAC_CAL_PATHS, "path")
+        pts = list(points)
+        if len(pts) != 2:
+            raise ValueError("calibrate_dac needs exactly two (code16, volts) points")
+        (c1, v1), (c2, v2) = pts
+        self._require_capability("cal_dmm", "DMM calibration")
+        return Calibration.from_reply(self.command({
+            "cmd": "calibrate", "dac": path, "code1": int(c1), "uv1": int(round(float(v1) * 1e6)),
+            "code2": int(c2), "uv2": int(round(float(v2) * 1e6))}))
+
+    def calibrate_adc_gain(self, source: AdcGainSource) -> Calibration:
+        """Measure and store an ADC source's gain through a loopback (firmware 3.9.4+).
+
+        The pod drives two set points on a DAC output that has its DMM line
+        (:meth:`calibrate_dac`) and compares what the ADC reads with what the output puts out:
+        ``cal1`` through the 5 V output, ``cal2`` through the ±12 V output, and ``ext`` (the front
+        SMA, which captures and the control loop use) through an SMA cable from the ±12 V output
+        to the ADC input. ``current_in`` follows ``cal1``. Needs the ADC offset first
+        (:meth:`calibrate`). ``Calibration.measured`` says what was measured. Takes about 0.7 s
+        and switches the outputs off afterwards.
+        """
+        check_choice(source, ADC_GAIN_SOURCES, "source")
+        self._require_capability("cal_dmm", "DMM calibration")
+        return Calibration.from_reply(self.command({"cmd": "calibrate", "adc": source}))
 
     # -- CAN (FDCAN1 / TCAN1044 transceiver) -----------------------------------
     # Single-node board: use a loopback ``mode`` to self-test on one pod. :meth:`open_can` and

{embeddedci-2.13.2 → embeddedci-2.13.3}/src/embeddedci/benchpod/constants.py

@@ -112,6 +112,13 @@ AnalogPath = Literal["off", "dac_3v3", "dac_5v", "dac_12v", "adc_ext", "cal1", "
 AdcSource = Literal["ext", "cal1", "cal2", "current_in"]
 #: ADC sources a pod can calibrate on its own (:meth:`BenchPod.calibrate`): the 4-20 mA input.
 CalibrateSource = Literal["current_in"]
+#: DAC outputs a DMM line can be stored for (:meth:`BenchPod.calibrate_dac`).
+DacCalPath = Literal["3v3", "5v", "12v"]
+#: ADC sources whose gain the pod measures through a loopback (:meth:`BenchPod.calibrate_adc_gain`);
+#: ``current_in`` follows ``cal1``.
+AdcGainSource = Literal["cal1", "cal2", "ext"]
+#: One part of the pod's calibration (:meth:`BenchPod.clear_calibration`).
+CalibrationPart = Literal["offset", "dac", "adc"]
 #: Parametric DAC waveforms the firmware generator produces.
 Waveshape = Literal["sine", "square", "sawtooth"]
 #: How replayed volts map onto DAC codes: reproduce them (``faithful``) or auto-scale (``fit``).
@@ -139,6 +146,9 @@ DAC_OUTPUT_PATHS: Tuple[str, ...] = get_args(DacOutputPath)
 ANALOG_PATHS: Tuple[str, ...] = get_args(AnalogPath)
 ADC_SOURCES: Tuple[str, ...] = get_args(AdcSource)
 CALIBRATE_SOURCES: Tuple[str, ...] = get_args(CalibrateSource)
+DAC_CAL_PATHS: Tuple[str, ...] = get_args(DacCalPath)
+ADC_GAIN_SOURCES: Tuple[str, ...] = get_args(AdcGainSource)
+CALIBRATION_PARTS: Tuple[str, ...] = get_args(CalibrationPart)
 WAVESHAPES: Tuple[str, ...] = get_args(Waveshape)
 REPLAY_MAPPINGS: Tuple[str, ...] = get_args(ReplayMapping)
 LOOP_SOURCES: Tuple[str, ...] = get_args(LoopSource)

{embeddedci-2.13.2 → embeddedci-2.13.3}/src/embeddedci/benchpod/state.py

@@ -314,13 +314,35 @@ class AdcReading:
                    current=None if ua is None else ua / 1e6, raw=d)
 
 
+@dataclass(frozen=True)
+class DacLine:
+    """This pod's own line for a DAC output, from two DMM readings (``BenchPod.calibrate_dac``)."""
+
+    #: ``volts = a + b * code16``: volts at code 0 and volts per 16-bit code.
+    a: float
+    b: float
+    #: Against the built-in line: the offset in volts (at 0 V on ``12v``, at code 0 on the
+    #: others) and the gain difference in ppm.
+    offset: float
+    gain_ppm: int
+
+    @classmethod
+    def from_reply(cls, d: Any) -> Optional["DacLine"]:
+        if not isinstance(d, dict):
+            return None
+        return cls(a=(_opt_int(d, "a_uv") or 0) / 1e6, b=(_opt_int(d, "b_pv") or 0) / 1e12,
+                   offset=(_opt_int(d, "offset_uv") or 0) / 1e6, gain_ppm=_opt_int(d, "gain_ppm") or 0)
+
+
 @dataclass(frozen=True)
 class Calibration:
-    """The pod's own ADC calibration for one source (``BenchPod.calibrate`` / ``calibration``).
+    """The pod's own calibration (``BenchPod.calibrate`` / ``calibration``).
 
     Every ADC source is scaled with a fit, ``volts = a + b * count``, that is built into the
-    firmware and the same on every pod. A pod that calibrated itself keeps its own value on top
-    of that, in flash. Today that is the offset of ``current_in``, the 4-20 mA input (J8).
+    firmware and the same on every pod. A pod that calibrated itself keeps its own values on top
+    of that, in flash: the ADC offset, measured on ``current_in`` (the 4-20 mA input, J8), and from
+    firmware 3.9.4 the DMM-guided parts, a DAC line per output (``dac``) and an ADC gain per
+    source (``adc_gain_ppm``).
     """
 
     source: str
@@ -338,16 +360,41 @@ class Calibration:
     count: Optional[int] = None
     span: Optional[int] = None
     samples: Optional[int] = None
+    #: This pod's DMM line per DAC output (``3v3``, ``5v``, ``12v``); ``None`` = the built-in
+    #: line. Empty on firmware before 3.9.3.
+    dac: Dict[str, Optional[DacLine]] = field(default_factory=dict)
+    #: The ADC gain correction per source (``cal1``, ``cal2``, ``ext``) in ppm; ``None`` = the
+    #: built-in gain. Empty on firmware before 3.9.3.
+    adc_gain_ppm: Dict[str, Optional[int]] = field(default_factory=dict)
+    #: ``True`` when any DMM part is stored.
+    dmm: bool = False
+    #: The raw zero the offset is derived from: the mean count ``current_in`` read with J8 open,
+    #: unwrapped. ``None`` when not calibrated or on firmware before 3.9.4.
+    zero_count: Optional[float] = None
+    #: After :meth:`BenchPod.calibrate_adc_gain`: what the DAC put out at the two set points
+    #: (``v1``, ``v2``), what the ADC read before the gain (``r1``, ``r2``) and the mean offset left
+    #: after it (``residual``), all in volts. ``None`` otherwise.
+    measured: Optional[Dict[str, float]] = None
     raw: Dict[str, Any] = _raw()
 
     @classmethod
     def from_reply(cls, reply: Any) -> "Calibration":
         d = _d(reply)
+        dac = d.get("dac") if isinstance(d.get("dac"), dict) else {}
+        gains = d.get("adc_gain_ppm") if isinstance(d.get("adc_gain_ppm"), dict) else {}
+        meas = d.get("measured") if isinstance(d.get("measured"), dict) else None
         return cls(source=str(d.get("source", "")), calibrated=d.get("calibrated") is True,
                    offset=(_opt_int(d, "offset_uv") or 0) / 1e6,
                    a=(_opt_int(d, "a_uv") or 0) / 1e6, b=(_opt_int(d, "b_nv") or 0) / 1e9,
                    count=_opt_int(d, "count"), span=_opt_int(d, "span"),
-                   samples=_opt_int(d, "samples"), raw=d)
+                   samples=_opt_int(d, "samples"),
+                   dac={str(k): DacLine.from_reply(v) for k, v in dac.items()},
+                   adc_gain_ppm={str(k): _opt_int(gains, k) for k in gains},
+                   dmm=d.get("dmm") is True,
+                   zero_count=None if _opt_int(d, "zero_count_mc") is None else _opt_int(d, "zero_count_mc") / 1000.0,
+                   measured=None if meas is None else {
+                       k[:-3]: (_opt_int(meas, k) or 0) / 1e6 for k in meas if k.endswith("_uv")},
+                   raw=d)
 
 
 @dataclass(frozen=True)

{embeddedci-2.13.2 → embeddedci-2.13.3}/src/embeddedci/benchpod/transport/cloud.py

@@ -157,7 +157,8 @@ def _read_form(req: dict) -> bool:
     if cmd == "dac_limits":
         return "path" not in req and req.get("enabled") is not False
     if cmd == "calibrate":
-        return "source" not in req and req.get("clear") is not True
+        return (not any(k in req for k in ("source", "dac", "adc"))
+                and req.get("clear") in (None, False))
     if cmd in ("sig_policy", "lan_policy"):
         return "set" not in req
     if cmd in ("cloud_ca", "cloud_proxy"):

{embeddedci-2.13.2 → embeddedci-2.13.3}/tests/api_surface.json

@@ -1,4 +1,5 @@
 {
+  "AdcGainSource": "Literal['cal1', 'cal2', 'ext']",
   "AdcReading": {
     "__fields__": [
       "source",
@@ -42,6 +43,8 @@
     "adc_read": "(self, source: 'AdcSource' = 'ext') -> 'AdcReading'",
     "analog_path": "(self, path: 'AnalogPath') -> 'AnalogPathState'",
     "calibrate": "(self, source: 'CalibrateSource' = 'current_in') -> 'Calibration'",
+    "calibrate_adc_gain": "(self, source: 'AdcGainSource') -> 'Calibration'",
+    "calibrate_dac": "(self, path: 'DacCalPath', points: 'Sequence[Tuple[int, float]]') -> 'Calibration'",
     "calibration": "(self) -> 'Calibration'",
     "can_analog": "property",
     "can_calibrate": "property",
@@ -64,7 +67,7 @@
     "capture_correlated": "(self, *, adc_samples: 'int' = 4096, adc_sample_rate_hz: 'Optional[float]' = None, la_samples: 'int' = 4096, la_sample_rate_hz: 'Optional[float]' = None, stop_dac_after: 'Optional[float]' = None, trigger: 'Optional[Trigger]' = None, trigger_timeout: 'float' = 10.0, source: 'Optional[AdcSource]' = None) -> 'CorrelatedCapture'",
     "capture_la": "(self, samples: 'int' = 4096, *, sample_rate_hz: 'Optional[float]' = None, stop_dac_after: 'Optional[float]' = None, trigger: 'Optional[Trigger]' = None, trigger_timeout: 'float' = 10.0) -> 'LaCapture'",
     "capture_uart": "(self, *, rx: 'Union[Pin, int, str, None]' = None, tx: 'Union[Pin, int, str, None]' = None, baud: 'Optional[int]' = None, duration: 'float', until: 'Optional[_uart.Until]' = None) -> '_uart.UartCapture'",
-    "clear_calibration": "(self) -> 'Calibration'",
+    "clear_calibration": "(self, part: 'Optional[CalibrationPart]' = None) -> 'Calibration'",
     "close": "(self) -> 'None'",
     "command": "(self, req: 'Dict[str, Any]') -> 'Any'",
     "configure_gpio": "(self, las: 'Sequence[Union[Pin, int, str]]', mode: 'GpioMode' = 'output', *, level: 'Optional[int]' = None) -> 'List[LaPinState]'",
@@ -168,10 +171,16 @@
       "count",
       "span",
       "samples",
+      "dac",
+      "adc_gain_ppm",
+      "dmm",
+      "zero_count",
+      "measured",
       "raw"
     ],
     "from_reply": "(cls, reply: 'Any') -> \"'Calibration'\""
   },
+  "CalibrationPart": "Literal['offset', 'dac', 'adc']",
   "CanBus": {
     "__init__": "(self, bp: \"'BenchPod'\", *, bitrate: 'int', mode: 'str', term: 'bool' = False, fd: 'bool' = False) -> 'None'",
     "add_responder": "(self, match_id: 'int', reply_id: 'int', reply_data: 'Union[bytes, Sequence[int], None]' = None, *, match_ext: 'bool' = False, reply_ext: 'bool' = False) -> 'dict'",
@@ -249,6 +258,7 @@
       "spi_master",
       "spi_stream",
       "calibrate",
+      "cal_dmm",
       "current_out",
       "can",
       "pod_current",
@@ -342,10 +352,20 @@
     ],
     "from_reply": "(cls, reply: 'Any') -> \"'CurrentOutput'\""
   },
+  "DacCalPath": "Literal['3v3', '5v', '12v']",
   "DacHandle": {
     "__init__": "(self, *, stop: 'Callable[[], Any]', dac_path: 'str' = '', cotrig: 'bool' = False, data: 'Optional[dict]' = None) -> 'None'",
     "stop": "(self) -> 'None'"
   },
+  "DacLine": {
+    "__fields__": [
+      "a",
+      "b",
+      "offset",
+      "gain_ppm"
+    ],
+    "from_reply": "(cls, d: 'Any') -> \"Optional['DacLine']\""
+  },
   "DacOutput": {
     "__fields__": [
       "path",
@@ -974,6 +994,7 @@
     "with_changes": "(self, **changes: 'Any') -> \"'Wiring'\""
   },
   "__all__": [
+    "AdcGainSource",
     "AdcReading",
     "AdcSource",
     "AnalogPath",
@@ -986,6 +1007,7 @@
     "BuildReporter",
     "CalibrateSource",
     "Calibration",
+    "CalibrationPart",
     "CanBus",
     "CanFrame",
     "CanMode",
@@ -1000,7 +1022,9 @@
     "ControlLoopHandle",
     "CorrelatedCapture",
     "CurrentOutput",
+    "DacCalPath",
     "DacHandle",
+    "DacLine",
     "DacOutput",
     "DacOutputPath",
     "DacPath",

{embeddedci-2.13.2 → embeddedci-2.13.3}/tests/test_client_v2.py

@@ -13,6 +13,7 @@ from embeddedci.benchpod.state import (
     AdcReading,
     AnalogPathState,
     Calibration,
+    DacLine,
     CurrentOutput,
     DacOutput,
     LaVoltage,
@@ -373,6 +374,67 @@ def test_calibrate_needs_the_capability():
     assert BenchPod(transport=CalPod(), lease=False).capabilities.calibrate
 
 
+class DmmCalPod(FakeTransport):
+    """A pod that takes the DMM-guided calibration (firmware 3.9.4+)."""
+
+    def status(self) -> Any:
+        return {**super().status(), "version": "3.9.4", "caps": ["calibrate", "cal_dmm"]}
+
+
+_DMM = {**_CAL, "dmm": True, "zero_count_mc": 65585123,
+        "dac": {"3v3": None, "5v": {"a_uv": -609, "b_pv": 76249841, "offset_uv": -3127, "gain_ppm": -996},
+                "12v": None},
+        "adc_gain_ppm": {"cal1": 1850, "cal2": None, "ext": None}}
+
+
+def test_calibrate_dac_sends_both_points_in_microvolts():
+    t = DmmCalPod({"calibrate": lambda req: _DMM})
+    bp = BenchPod(transport=t, lease=False)
+    assert bp.capabilities.cal_dmm
+    c = bp.calibrate_dac("5v", [(13069, 0.9959), (52374, 3.9929)])
+    assert t.commands[-1] == {"cmd": "calibrate", "dac": "5v", "code1": 13069, "uv1": 995900,
+                              "code2": 52374, "uv2": 3992900}
+    line = c.dac["5v"]
+    assert isinstance(line, DacLine) and c.dac["3v3"] is None and c.dmm
+    assert line.a == pytest.approx(-609e-6) and line.b == pytest.approx(76.249841e-6)
+    assert line.offset == pytest.approx(-3.127e-3) and line.gain_ppm == -996
+    assert c.adc_gain_ppm == {"cal1": 1850, "cal2": None, "ext": None}
+    assert c.zero_count == pytest.approx(65585.123)
+    with pytest.raises(ValueError):
+        bp.calibrate_dac("5v", [(13069, 0.9959)])
+    with pytest.raises(ValueError):
+        bp.calibrate_dac("off", [(1, 0.0), (2, 1.0)])  # type: ignore[arg-type]
+    assert set(bp.DMM_SET_POINTS) == {"3v3", "5v", "12v"}
+
+
+def test_calibrate_adc_gain_and_partial_clear():
+    meas = {"v1_uv": 995900, "v2_uv": 3992900, "r1_uv": 994100, "r2_uv": 3985500, "residual_uv": 1200}
+    t = DmmCalPod({"calibrate": lambda req: {**_DMM, "measured": meas} if "adc" in req else _DMM})
+    bp = BenchPod(transport=t, lease=False)
+    c = bp.calibrate_adc_gain("cal1")
+    assert t.commands[-1] == {"cmd": "calibrate", "adc": "cal1"}
+    assert c.measured == pytest.approx({"v1": 0.9959, "v2": 3.9929, "r1": 0.9941, "r2": 3.9855, "residual": 0.0012})
+    with pytest.raises(ValueError):
+        bp.calibrate_adc_gain("current_in")  # type: ignore[arg-type]
+    bp.clear_calibration("dac")
+    assert t.commands[-1] == {"cmd": "calibrate", "clear": "dac"}
+    with pytest.raises(ValueError):
+        bp.clear_calibration("everything")  # type: ignore[arg-type]
+
+
+def test_dmm_calibration_needs_cal_dmm():
+    t = CalPod({"calibrate": lambda req: _CAL})       # 3.4.0 to 3.9.2: offset only
+    bp = BenchPod(transport=t, lease=False)
+    for call in (lambda: bp.calibrate_dac("5v", [(1, 1.0), (40000, 3.0)]), lambda: bp.calibrate_adc_gain("cal1"),
+                 lambda: bp.clear_calibration("adc")):
+        with pytest.raises(BenchPodError, match="cal_dmm"):
+            call()
+    assert t.commands == []
+    old = bp.calibration()                             # an old reply has no DMM parts
+    assert old.dac == {} and old.adc_gain_ppm == {} and not old.dmm and old.measured is None
+    assert old.zero_count is None
+
+
 def test_capture_adc_routes_the_source_first():
     bp, t = _bp({"analog_path": {"path": "cal1"}})
     cap = bp.capture_adc(2, source="cal1", sample_rate_hz=100_000)