Logic Analyzer (Preview)

Capture and analyze digital signals using the logic analyzer functionality of mixed-signal oscilloscopes.

Known limitations on the Rigol MSO5000. Channel control, capture, measurements, and the edge and SPI triggers work. The pulse, UART, I2C and CAN triggers raise an error that says the scope supports edge and SPI triggers, before anything reaches it. Bus decoders are refused the same way: creating one raises an error that says the scope does not decode buses through lager.

Import

from lager import Net, NetType

Methods

Method	Description
`enable()`	Enable the logic channel display
`disable()`	Disable the logic channel display
`start_capture()`	Start continuous acquisition
`stop_capture()`	Stop acquisition
`start_single_capture()`	Start single-shot capture
`force_trigger()`	Force a trigger event
`set_signal_threshold()`	Set logic level threshold voltage
`display_position()`	Set channel display position
`size_large()` / `size_medium()` / `size_small()`	Set display size

Method Reference

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

Get a logic analyzer net by name.

from lager import Net, NetType

logic = Net.get('SPI_CLK', type=NetType.Logic)

Parameters:

Parameter	Type	Description
`name`	`str`	Name of the logic net
`type`	`NetType`	Must be `NetType.Logic`

Returns: Logic analyzer Net instance

`enable()`

Enable the logic channel display.

logic.enable()

`disable()`

Disable the logic channel display.

logic.disable()

`start_capture()`

Start continuous waveform acquisition.

logic.start_capture()

`stop_capture()`

Stop waveform acquisition.

logic.stop_capture()

`start_single_capture()`

Start single-shot capture (captures one triggered event).

logic.start_single_capture()

`force_trigger()`

Force a trigger event immediately.

logic.force_trigger()

`set_signal_threshold(voltage)`

Set the logic level threshold voltage.

logic.set_signal_threshold(1.65)  # 1.65V for 3.3V CMOS
logic.set_signal_threshold(2.5)   # 2.5V for 5V TTL

Parameter	Type	Description
`voltage`	`float`	Threshold voltage in volts

Note: Channels 0-7 share one threshold, channels 8-15 share another.

`display_position(position)`

Set the channel display position.

logic.display_position(100)  # Set vertical position

Parameter	Type	Description
`position`	`int`	Vertical position value

`size_large()` / `size_medium()` / `size_small()`

Set the display size for enabled channels.

logic.size_large()   # Maximum visibility
logic.size_medium()  # Balanced
logic.size_small()   # Compact view

Trigger Settings

Logic analyzer nets support advanced triggering through trigger_settings:

Edge Trigger

logic = Net.get('SPI_CLK', type=NetType.Logic)

# Set edge trigger on this channel
logic.trigger_settings.edge.set_source(logic)
logic.trigger_settings.edge.set_slope_rising()
logic.trigger_settings.set_mode_normal()

Edge trigger methods:

Method	Description
`edge.set_source(net)`	Set trigger source net
`edge.set_slope_rising()`	Trigger on rising edge
`edge.set_slope_falling()`	Trigger on falling edge
`edge.set_slope_both()`	Trigger on either edge
`edge.get_slope()`	Get current slope setting
`edge.set_level(level)`	Set the trigger level in volts
`edge.get_level()`	Get the trigger level in volts, or `None`

Pulse Trigger

logic = Net.get('PULSE_SIG', type=NetType.Logic)

# Trigger on pulse width > 1ms
logic.trigger_settings.pulse.set_source(logic)
logic.trigger_settings.pulse.set_trigger_on_pulse_greater_than_width(0.001)

# Trigger on pulse width < 100us
logic.trigger_settings.pulse.set_trigger_on_pulse_less_than_width(0.0001)

Protocol Triggers

UART Trigger

logic = Net.get('UART_TX', type=NetType.Logic)

logic.trigger_settings.uart.set_source(logic)
logic.trigger_settings.uart.set_uart_params(baud=115200, bits=8, parity=None, stopbits=1)

# Trigger on start bit
logic.trigger_settings.uart.set_trigger_on_start()

# Trigger on specific data
logic.trigger_settings.uart.set_trigger_on_data(data=0x55)

# Trigger on frame error
logic.trigger_settings.uart.set_trigger_on_frame_error()

I2C Trigger

scl = Net.get('I2C_SCL', type=NetType.Logic)
sda = Net.get('I2C_SDA', type=NetType.Logic)

scl.trigger_settings.i2c.set_source(net_scl=scl, net_sda=sda)

# Trigger on start condition
scl.trigger_settings.i2c.set_trigger_on_start()

# Trigger on specific address
scl.trigger_settings.i2c.set_trigger_on_address(bits=7, address=0x48)

# Trigger on NACK
scl.trigger_settings.i2c.set_trigger_on_nack()

SPI Trigger

clk = Net.get('SPI_CLK', type=NetType.Logic)
mosi = Net.get('SPI_MOSI', type=NetType.Logic)
cs = Net.get('SPI_CS', type=NetType.Logic)

clk.trigger_settings.spi.set_source(net_sck=clk, net_mosi_miso=mosi, net_cs=cs)
clk.trigger_settings.spi.set_clk_edge_positive()

# Trigger on specific data
clk.trigger_settings.spi.set_trigger_data(bits=8, data=0xAA)

# Trigger on CS
clk.trigger_settings.spi.set_trigger_on_cs_low()

SPI trigger methods:

Method	Description
`spi.set_source(net_sck, net_mosi_miso, net_cs)`	Set the clock, data and chip-select nets (keyword arguments)
`spi.set_clk_edge_positive()` / `spi.set_clk_edge_negative()`	Sample data on the rising or falling clock edge
`spi.get_clk_edge_slope()`	Get the clock edge setting
`spi.set_trigger_on_cs_low()` / `spi.set_trigger_on_cs_high()`	Trigger while chip select is low or high
`spi.set_trigger_on_timeout(timeout)`	Trigger after the clock is idle for `timeout` seconds
`spi.get_trigger_timeout()`	Get the idle timeout
`spi.set_trigger_data(bits, data)`	Trigger on a data value (keyword arguments)
`spi.set_sck_trigger_level(level)` / `spi.get_sck_trigger_level()`	Clock threshold in volts
`spi.set_mosi_miso_trigger_level(level)` / `spi.get_mosi_miso_trigger_level()`	Data threshold in volts
`spi.set_cs_trigger_level(level)` / `spi.get_cs_trigger_level()`	Chip-select threshold in volts

CAN Trigger

can = Net.get('CAN_RX', type=NetType.Logic)

can.trigger_settings.can.set_source(can)
can.trigger_settings.can.set_baud(500000)

# Trigger on start of frame
can.trigger_settings.can.set_trigger_on_sof()

# Trigger on error frame
can.trigger_settings.can.set_trigger_on_error_frame()

Valid Ranges

These ranges apply to the SPI trigger, the only protocol trigger the MSO5000 accepts. A value outside them raises ValueError, and the message names the valid range.

Method	Parameter	Valid values
`spi.set_trigger_data()`	`bits`	4 to 32
`spi.set_trigger_data()`	`data`	0 to 2^bits − 1

Measurements

Logic analyzer nets support digital timing measurements:

logic = Net.get('CLK', type=NetType.Logic)

# Frequency and period
freq = logic.measurement.frequency()
period = logic.measurement.period()

# Pulse measurements
pos_width = logic.measurement.pulse_width_positive()
neg_width = logic.measurement.pulse_width_negative()
pos_duty = logic.measurement.duty_cycle_positive()
neg_duty = logic.measurement.duty_cycle_negative()

# Rise/fall times
rise = logic.measurement.rise_time()
fall = logic.measurement.fall_time()

# Edge counts
pos_edges = logic.measurement.positive_edge_count()
neg_edges = logic.measurement.negative_edge_count()

Bus Decoding

A Rigol MSO5000 does not decode buses through lager. Each constructor below raises an error before anything reaches the scope.

For protocol analysis, create bus decoders using multiple logic channels:

UART Bus

from lager.nets.mappers.rigol_mso5000 import BusUART_RigolMSO5000FunctionMapper

tx = Net.get('UART_TX', type=NetType.Logic)
rx = Net.get('UART_RX', type=NetType.Logic)

bus = BusUART_RigolMSO5000FunctionMapper(tx=tx, rx=rx)
bus.set_baud(115200)
bus.set_data_bits(8)
bus.set_parity_none()
bus.set_stop_bits(1)

bus.enable()
bus.show_table()

I2C Bus

from lager.nets.mappers.rigol_mso5000 import BusI2C_RigolMSO5000FunctionMapper

scl = Net.get('I2C_SCL', type=NetType.Logic)
sda = Net.get('I2C_SDA', type=NetType.Logic)

bus = BusI2C_RigolMSO5000FunctionMapper(scl=scl, sda=sda)
bus.set_signal_threshold(sda=1.5, scl=1.5)

bus.enable()
bus.show_table()

SPI Bus

from lager.nets.mappers.rigol_mso5000 import BusSPI_RigolMSO5000FunctionMapper

clk = Net.get('SPI_CLK', type=NetType.Logic)
mosi = Net.get('SPI_MOSI', type=NetType.Logic)
miso = Net.get('SPI_MISO', type=NetType.Logic)
cs = Net.get('SPI_CS', type=NetType.Logic)

bus = BusSPI_RigolMSO5000FunctionMapper(clk=clk, mosi=mosi, miso=miso, cs=cs)
bus.set_sck_phase_rising_edge()
bus.set_data_width(8)
bus.set_endianness_msb()

bus.enable()
bus.show_table()

CAN Bus

from lager.nets.mappers.rigol_mso5000 import BusCAN_RigolMSO5000FunctionMapper

can_net = Net.get('CAN_RX', type=NetType.Logic)

bus = BusCAN_RigolMSO5000FunctionMapper(can=can_net)
bus.set_baud(500000)
bus.set_signal_type_rx()
bus.set_signal_threshold(2.0)

bus.enable()
bus.show_table()

Examples

Basic Digital Signal Capture

from lager import Net, NetType
import time

# Get logic channel
clk = Net.get('SYS_CLK', type=NetType.Logic)

# Configure
clk.enable()
clk.set_signal_threshold(1.65)  # 3.3V logic
clk.size_medium()

# Set trigger
clk.trigger_settings.edge.set_source(clk)
clk.trigger_settings.edge.set_slope_rising()
clk.trigger_settings.set_mode_normal()

# Capture
clk.start_capture()
time.sleep(1)

# Measure
freq = clk.measurement.frequency()
print(f"Clock frequency: {freq / 1e6:.3f} MHz")

clk.stop_capture()
clk.disable()

Protocol Timing Verification

from lager import Net, NetType

# Test UART timing
uart_tx = Net.get('UART_TX', type=NetType.Logic)
uart_tx.enable()
uart_tx.set_signal_threshold(1.65)

uart_tx.start_capture()

# Measure bit timing
period = uart_tx.measurement.period()
if period:
    measured_baud = 1.0 / period
    expected_baud = 115200
    error_pct = abs(measured_baud - expected_baud) / expected_baud * 100

    print(f"Measured baud: {measured_baud:.0f}")
    print(f"Expected baud: {expected_baud}")
    print(f"Error: {error_pct:.2f}%")

    if error_pct < 3:
        print("PASS: Baud rate within tolerance")
    else:
        print("FAIL: Baud rate out of tolerance")

uart_tx.stop_capture()
uart_tx.disable()

Digital Channels

Channel	Range
D0-D7	Pod 1 (shared threshold)
D8-D15	Pod 2 (shared threshold)

Supported Hardware

Manufacturer	Model	Features
Rigol	MSO5000 series	16 digital channels, edge and SPI triggers

Notes

Logic channels are numbered D0-D15
Channels D0-D7 share one threshold voltage, D8-D15 share another
Bus decoders are refused; creating one raises UnsupportedScopeFeature
Use NetType.Logic for digital channels, NetType.Analog for analog
Only the edge and SPI triggers work; the others raise UnsupportedScopeFeature
The trigger can use any combination of analog and digital channels

​Import

​Methods

​Method Reference

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

​enable()

​disable()

​start_capture()

​stop_capture()

​start_single_capture()

​force_trigger()

​set_signal_threshold(voltage)

​display_position(position)

​size_large() / size_medium() / size_small()

​Trigger Settings

​Edge Trigger

​Pulse Trigger

​Protocol Triggers

​UART Trigger

​I2C Trigger

​SPI Trigger

​CAN Trigger

​Valid Ranges

​Measurements

​Bus Decoding

​UART Bus

​I2C Bus

​SPI Bus

​CAN Bus

​Examples

​Basic Digital Signal Capture

​Protocol Timing Verification

​Digital Channels

​Supported Hardware

​Notes

Import

Methods

Method Reference

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

`enable()`

`disable()`

`start_capture()`

`stop_capture()`

`start_single_capture()`

`force_trigger()`

`set_signal_threshold(voltage)`

`display_position(position)`

`size_large()` / `size_medium()` / `size_small()`

Trigger Settings

Edge Trigger

Pulse Trigger

Protocol Triggers

UART Trigger

I2C Trigger

SPI Trigger

CAN Trigger

Valid Ranges

Measurements

Bus Decoding

UART Bus

I2C Bus

SPI Bus

CAN Bus

Examples

Basic Digital Signal Capture

Protocol Timing Verification

Digital Channels

Supported Hardware

Notes