Watt Meter

Measure power consumption from watt meter nets. Supports Yocto-Watt, Joulescope JS220, and Nordic PPK2 hardware.

Import

from lager import Net, NetType

Methods

Method	Hardware	Description
`read()`	All	Read power in watts
`read_current()`	Joulescope JS220, Nordic PPK2	Read current in amps
`read_voltage()`	Joulescope JS220, Nordic PPK2	Read voltage in volts
`read_all()`	Joulescope JS220, Nordic PPK2	Read current, voltage, and power in a single operation

Method Reference

`Net.get(name, type=NetType.WattMeter)`

Get a watt meter net by name.

from lager import Net, NetType

power = Net.get('POWER_METER', type=NetType.WattMeter)

Parameters:

Parameter	Type	Description
`name`	`str`	Name of the watt meter net
`type`	`NetType`	Must be `NetType.WattMeter`

Returns: Watt meter Net instance

`read()`

Read the current power consumption. Available on all watt meter hardware.

watts = power.read()
print(f"Power: {watts}W")

Returns: float - Power in watts

`read_current()`

Read the current in amps. Joulescope JS220 and Nordic PPK2.

amps = power.read_current()
print(f"Current: {amps}A")

Returns: float - Current in amps

`read_voltage()`

Read the voltage in volts. Joulescope JS220 and Nordic PPK2.

volts = power.read_voltage()
print(f"Voltage: {volts}V")

Returns: float - Voltage in volts

`read_all()`

Read current, voltage, and power in a single atomic measurement. Joulescope JS220 and Nordic PPK2. This is more efficient than calling read_current(), read_voltage(), and read() separately, as all values come from the same sample window.

measurements = power.read_all()
print(f"Current: {measurements['current']}A")
print(f"Voltage: {measurements['voltage']}V")
print(f"Power: {measurements['power']}W")

Returns: dict with keys:

Key	Type	Description
`"current"`	`float`	Current in amps
`"voltage"`	`float`	Voltage in volts
`"power"`	`float`	Power in watts

The `duration` parameter

read(), read_current(), read_voltage() and read_all() take duration, the averaging window in seconds. The default is 0.1.

watts = power.read(duration=1.0)  # Average over one second

Hardware	Behavior
Yocto-Watt	Ignores `duration` and returns the instrument’s own averaged value
Nordic PPK2	Uses at least 0.3 s
Joulescope JS220	Above 10 s, switches to the gapless `read_average()`

`read_average(duration)`

Joulescope JS220 only. Return the gapless average current, voltage and power over a long window. It uses the instrument’s charge and energy accumulators, so it holds no samples and drops no data.

avg = power.read_average(60.0)
print(f"Average power over 60 s: {avg['power']}W")

Returns: dict with keys current, voltage and power

Examples

Basic Power Reading

from lager import Net, NetType

power = Net.get('DEVICE_POWER', type=NetType.WattMeter)

watts = power.read()
print(f"Power consumption: {watts:.3f}W")

Joulescope Full Measurement

from lager import Net, NetType

power = Net.get('DEVICE_POWER', type=NetType.WattMeter)

# Read all measurements at once (Joulescope JS220 and Nordic PPK2)
data = power.read_all()
print(f"Voltage: {data['voltage']:.3f}V")
print(f"Current: {data['current']:.6f}A")
print(f"Power: {data['power']:.3f}W")

Power Profiling

from lager import Net, NetType
import time

power = Net.get('DEVICE_POWER', type=NetType.WattMeter)

measurements = []

# Take 60 seconds of measurements
for i in range(60):
    watts = power.read()
    measurements.append(watts)
    print(f"[{i:3d}s] {watts:.3f}W")
    time.sleep(1)

# Statistics
avg = sum(measurements) / len(measurements)
max_p = max(measurements)
min_p = min(measurements)

print(f"\nAverage: {avg:.3f}W")
print(f"Maximum: {max_p:.3f}W")
print(f"Minimum: {min_p:.3f}W")

Battery Life Estimation

from lager import Net, NetType
import time

power = Net.get('POWER', type=NetType.WattMeter)

# Average over multiple readings
readings = []
for _ in range(10):
    readings.append(power.read())
    time.sleep(0.1)

avg_power = sum(readings) / len(readings)

# Estimate battery life (1000mAh @ 3.7V = 3.7Wh)
battery_wh = 3.7
hours = battery_wh / avg_power if avg_power > 0 else float('inf')

print(f"Average power: {avg_power:.3f}W")
print(f"Est. battery life: {hours:.1f} hours")

Power Limit Verification

from lager import Net, NetType
import time

def verify_power_limits(min_watts, max_watts):
    power = Net.get('DEVICE_POWER', type=NetType.WattMeter)

    # Average multiple readings
    readings = []
    for _ in range(10):
        readings.append(power.read())
        time.sleep(0.1)

    avg = sum(readings) / len(readings)

    if min_watts <= avg <= max_watts:
        print(f"PASS: {avg:.3f}W in range [{min_watts}, {max_watts}]")
        return True
    else:
        print(f"FAIL: {avg:.3f}W outside range [{min_watts}, {max_watts}]")
        return False

# Test
verify_power_limits(0.1, 5.0)

Sleep Current Verification (Joulescope)

from lager import Net, NetType
import time

power = Net.get('DEVICE_POWER', type=NetType.WattMeter)

# Put device in sleep mode (external trigger)
# set_device_sleep_mode()
time.sleep(2)  # Wait for stabilization

# Use read_all() for atomic measurement (Joulescope JS220)
data = power.read_all()
sleep_current_ua = data['current'] * 1e6

print(f"Sleep voltage: {data['voltage']:.3f}V")
print(f"Sleep current: {sleep_current_ua:.1f}uA")
print(f"Sleep power: {data['power']:.6f}W")

if sleep_current_ua < 100:
    print("PASS: Sleep current below 100uA")
else:
    print("FAIL: Sleep current exceeds limit")

Supported Hardware

Manufacturer	Model	Measurement	Features
Yoctopuce	Yocto-Watt	Power only	Instantaneous reading
Joulescope	JS220	Power, voltage, current	0.1s averaged, atomic multi-measurement
Nordic Semiconductor	PPK2	Power, voltage, current	0.3s averaged, source mode constant voltage

Hardware Feature Comparison

Feature	Yocto-Watt	Joulescope JS220	Nordic PPK2
`read()` (power)	Yes	Yes	Yes
`read_current()`	No	Yes	Yes
`read_voltage()`	No	Yes	Yes
`read_all()`	No	Yes	Yes
Measurement method	Instantaneous	0.1s averaged	0.3s averaged
Device selection	Channel-based	Serial number-based	Serial number-based

Notes

Power is returned in watts (W)
Joulescope JS220 averages measurements over 0.1 seconds for higher precision
Nordic PPK2 averages measurements over 0.3 seconds and operates in source mode, where it supplies a configurable voltage of 0.8–5V. Voltage readings therefore reflect the configured value, not an independent measurement
read_current(), read_voltage(), and read_all() are available on the Joulescope JS220 and Nordic PPK2; calling them on a Yocto-Watt raises UnsupportedInstrumentError, a RuntimeError
For current on Yocto-Watt: calculate from power and known voltage (I = P / V)
Use multiple readings and averaging for stability
Allow settling time after device state changes

Getting Started

Development

Power & Simulation

Measurement

I/O & Communication

Utilities

Import

Methods

Method Reference

`Net.get(name, type=NetType.WattMeter)`

`read()`

`read_current()`

`read_voltage()`

`read_all()`

The `duration` parameter

`read_average(duration)`

Examples

Basic Power Reading

Joulescope Full Measurement

Power Profiling

Battery Life Estimation

Power Limit Verification

Sleep Current Verification (Joulescope)

Supported Hardware

Hardware Feature Comparison

Notes

​Import

​Methods

​Method Reference

​Net.get(name, type=NetType.WattMeter)

​read()

​read_current()

​read_voltage()

​read_all()

​The duration parameter

​read_average(duration)

​Examples

​Basic Power Reading

​Joulescope Full Measurement

​Power Profiling

​Battery Life Estimation

​Power Limit Verification

​Sleep Current Verification (Joulescope)

​Supported Hardware

​Hardware Feature Comparison

​Notes

Import

Methods

Method Reference

`Net.get(name, type=NetType.WattMeter)`

`read()`

`read_current()`

`read_voltage()`

`read_all()`

The `duration` parameter

`read_average(duration)`

Examples

Basic Power Reading

Joulescope Full Measurement

Power Profiling

Battery Life Estimation

Power Limit Verification

Sleep Current Verification (Joulescope)

Supported Hardware

Hardware Feature Comparison

Notes