Electronic Load

Control electronic loads to sink current in various modes for testing power systems.

Import

There are two ways to control electronic loads:

# Option 1: Net-based API
from lager import Net, NetType

# Option 2: Module-level functions
from lager.eload import (
    set_constant_current, get_constant_current,
    set_constant_voltage, get_constant_voltage,
    set_constant_resistance, get_constant_resistance,
    set_constant_power, get_constant_power
)

Net API Methods

The Net-based API provides methods that can either get or set values. When called without a value parameter, methods read and return the current value. When called with a value, they set it.

Method	Description
`mode(mode_type)`	Set or read operation mode (CC/CV/CR/CW)
`current(value)`	Set or read constant current (A)
`voltage(value)`	Set or read constant voltage (V)
`resistance(value)`	Set or read constant resistance (ohms)
`power(value)`	Set or read constant power (W)
`enable()`	Enable electronic load input
`disable()`	Disable electronic load input
`state()`	Print comprehensive state
`measured_voltage()`	Read measured voltage (returns float)
`measured_current()`	Read measured current (returns float)
`measured_power()`	Read measured power (returns float)

Method Reference

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

Get an electronic load net by name.

from lager import Net, NetType

eload = Net.get('LOAD', type=NetType.ELoad)

Parameters:

Parameter	Type	Description
`name`	`str`	Name of the electronic load net
`type`	`NetType`	Must be `NetType.ELoad`

Returns: Electronic load Net instance

`mode(mode_type=None)`

Set or read the operation mode.

# Set mode
eload.mode('CC')  # Constant Current
eload.mode('CV')  # Constant Voltage
eload.mode('CR')  # Constant Resistance
eload.mode('CW')  # Constant Power (also 'CP')

# Read current mode
current_mode = eload.mode()
print(f"Mode: {current_mode}")

Parameters:

Parameter	Type	Description
`mode_type`	`str` or `None`	’CC’, ‘CV’, ‘CR’, or ‘CW’/‘CP’. If None, reads current mode.

Returns: Current mode string if mode_type is None

`current(value=None)`

Set or read the constant current setting.

# Set CC mode current
eload.mode('CC')
eload.current(0.5)  # Set to 500mA

# Read current setting
i = eload.current()
print(f"Current setting: {i}A")

Parameters:

Parameter	Type	Description
`value`	`float` or `None`	Current in amps. If None, reads current setting.

Returns: Current setting in amps if value is None

`voltage(value=None)`

Set or read the constant voltage setting.

# Set CV mode voltage
eload.mode('CV')
eload.voltage(5.0)  # Set to 5V

# Read voltage setting
v = eload.voltage()
print(f"Voltage setting: {v}V")

`resistance(value=None)`

Set or read the constant resistance setting.

# Set CR mode resistance
eload.mode('CR')
eload.resistance(100.0)  # Set to 100 ohms

# Read resistance setting
r = eload.resistance()
print(f"Resistance setting: {r} ohms")

`power(value=None)`

Set or read the constant power setting.

# Set CW mode power
eload.mode('CW')
eload.power(5.0)  # Set to 5W

# Read power setting
p = eload.power()
print(f"Power setting: {p}W")

`enable()` / `disable()`

Enable or disable the electronic load input.

eload.enable()   # Start sinking current
eload.disable()  # Stop sinking current

`state()`

Print comprehensive electronic load state.

eload.state()
# Prints: mode, current/voltage/resistance/power settings, measured values, input state

`measured_voltage()` / `measured_current()` / `measured_power()`

Read actual measured values (return floats, for use in code).

v = eload.measured_voltage()  # Returns measured voltage
i = eload.measured_current()  # Returns measured current
p = eload.measured_power()    # Returns measured power

print(f"V={v:.2f}V, I={i:.3f}A, P={p:.3f}W")

Returns: float - Measured value

Load Modes

Mode	Code	Description
Constant Current	`CC`	Sinks a fixed current regardless of voltage
Constant Voltage	`CV`	Maintains a fixed voltage across the load
Constant Resistance	`CR`	Behaves as a fixed resistance
Constant Power	`CW` or `CP`	Dissipates a fixed power

Examples

Constant Current Test

from lager import Net, NetType

eload = Net.get('LOAD', type=NetType.ELoad)

# Configure constant current mode at 500mA
eload.mode('CC')
eload.current(0.5)

eload.enable()

# Read measurements
print(f"Voltage: {eload.measured_voltage():.2f}V")
print(f"Current: {eload.measured_current():.3f}A")
print(f"Power: {eload.measured_power():.3f}W")

eload.disable()

Battery Discharge Test

from lager import Net, NetType
import time

eload = Net.get('LOAD', type=NetType.ELoad)

# Configure constant resistance load
eload.mode('CR')
eload.resistance(10.0)

eload.enable()

# Monitor discharge
for i in range(30):
    v = eload.measured_voltage()
    i_curr = eload.measured_current()
    print(f"V={v:.2f}V, I={i_curr:.3f}A")

    if v < 3.0:
        print("Discharge cutoff reached")
        break

    time.sleep(1)

eload.disable()

Power Efficiency Test

from lager import Net, NetType

# Input power supply
psu = Net.get('INPUT', type=NetType.PowerSupply)
psu.voltage(12.0)
psu.current(2.0)
psu.enable()

# Output load
eload = Net.get('OUTPUT', type=NetType.ELoad)
eload.mode('CC')
eload.current(0.5)
eload.enable()

# Measure efficiency
p_in = 12.0 * psu.measured_current()  # Input power
p_out = eload.measured_power()         # Output power
efficiency = (p_out / p_in) * 100 if p_in > 0 else 0

print(f"Input: {p_in:.2f}W")
print(f"Output: {p_out:.2f}W")
print(f"Efficiency: {efficiency:.1f}%")

eload.disable()
psu.disable()

Supported Hardware

Manufacturer	Model	Features
Rigol	DL3000 series	CC/CV/CR/CP modes

Module-Level Functions

For simple scripts, you can use module-level functions that take net names directly:

Constant Current Mode

from lager.eload import set_constant_current, get_constant_current

# Set constant current to 500mA
set_constant_current('LOAD', 0.5)

# Read current setting
current = get_constant_current('LOAD')
print(f"Load current: {current}A")

Constant Voltage Mode

from lager.eload import set_constant_voltage, get_constant_voltage

# Set constant voltage to 5V
set_constant_voltage('LOAD', 5.0)

# Read voltage setting
voltage = get_constant_voltage('LOAD')
print(f"Load voltage: {voltage}V")

Constant Resistance Mode

from lager.eload import set_constant_resistance, get_constant_resistance

# Set constant resistance to 100 ohms
set_constant_resistance('LOAD', 100.0)

# Read resistance setting
resistance = get_constant_resistance('LOAD')
print(f"Load resistance: {resistance} ohms")

Constant Power Mode

from lager.eload import set_constant_power, get_constant_power

# Set constant power to 10W
set_constant_power('LOAD', 10.0)

# Read power setting
power = get_constant_power('LOAD')
print(f"Load power: {power}W")

Module Functions Reference

Function	Description
`set_constant_current(net_name, current)`	Set CC mode with specified current (A)
`get_constant_current(net_name)`	Get CC mode current setting
`set_constant_voltage(net_name, voltage)`	Set CV mode with specified voltage (V)
`get_constant_voltage(net_name)`	Get CV mode voltage setting
`set_constant_resistance(net_name, resistance)`	Set CR mode with specified resistance (ohms)
`get_constant_resistance(net_name)`	Get CR mode resistance setting
`set_constant_power(net_name, power)`	Set CP mode with specified power (W)
`get_constant_power(net_name)`	Get CP mode power setting

Notes

Use mode() to set the operation mode before setting the corresponding value
Methods like current(), voltage(), resistance(), power() can get or set values
measured_voltage(), measured_current(), measured_power() return actual measurements
state() prints state (for debugging), measurement methods return values (for code)
Always call enable() to start sinking current
Always call disable() when finished
Module-level functions are simpler for quick mode changes

Getting Started

Development

Power & Simulation

Measurement

I/O & Communication

Utilities

Import

Net API Methods

Method Reference

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

`mode(mode_type=None)`

`current(value=None)`

`voltage(value=None)`

`resistance(value=None)`

`power(value=None)`

`enable()` / `disable()`

`state()`

`measured_voltage()` / `measured_current()` / `measured_power()`

Load Modes

Examples

Constant Current Test

Battery Discharge Test

Power Efficiency Test

Supported Hardware

Module-Level Functions

Constant Current Mode

Constant Voltage Mode

Constant Resistance Mode

Constant Power Mode

Module Functions Reference

Notes

Getting Started

Development

Power & Simulation

Measurement

I/O & Communication

Utilities

​Import

​Net API Methods

​Method Reference

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

​mode(mode_type=None)

​current(value=None)

​voltage(value=None)

​resistance(value=None)

​power(value=None)

​enable() / disable()

​state()

​measured_voltage() / measured_current() / measured_power()

​Load Modes

​Examples

​Constant Current Test

​Battery Discharge Test

​Power Efficiency Test

​Supported Hardware

​Module-Level Functions

​Constant Current Mode

​Constant Voltage Mode

​Constant Resistance Mode

​Constant Power Mode

​Module Functions Reference

​Notes

Import

Net API Methods

Method Reference

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

`mode(mode_type=None)`

`current(value=None)`

`voltage(value=None)`

`resistance(value=None)`

`power(value=None)`

`enable()` / `disable()`

`state()`

`measured_voltage()` / `measured_current()` / `measured_power()`

Load Modes

Examples

Constant Current Test

Battery Discharge Test

Power Efficiency Test

Supported Hardware

Module-Level Functions

Constant Current Mode

Constant Voltage Mode

Constant Resistance Mode

Constant Power Mode

Module Functions Reference

Notes