Measurement

class Nets.Measurement

Measure horizontal(time) and vertical(voltage) characteristics of a waveform.

voltage_max(display=False, measurement_cursor=False)

Measure the maximum voltage.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
v_max = v33_net.measurement.voltage_max() #Max voltage in Volts
print(v_max)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

max voltage for this trace in Volts

Return type:

float

voltage_min(display=False, measurement_cursor=False)

Measure the minimum voltage.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
v_max = v33_net.measurement.voltage_min() #Min voltage in Volts
print(v_min)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

min voltage for this trace in Volts

Return type:

float

voltage_peak_to_peak(display=False, measurement_cursor=False)

Measure peak to peak voltage

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
v_pp = v33_net.measurement.voltage_peak_to_peak() #Peak to peak voltage in Volts
print(v_pp)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

peak to peak voltage for this trace in Volts

Return type:

float

voltage_flat_top(display=False, measurement_cursor=False)

Measure top "flat" voltage.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
v_flat_top = v33_net.measurement.voltage_flat_top() #Top flat voltage in Volts
print(v_flat_top)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

Top flat voltage for this trace in Volts

Return type:

float

voltage_flat_base(display=False, measurement_cursor=False)

Measure bottom "flat" voltage.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
v_flat_bottom = v33_net.measurement.voltage_flat_base() #Bottom flat voltage in Volts
print(v_flat_bottom)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

Bottom flat voltage for this trace in Volts

Return type:

float

voltage_flat_amplitude(display=False, measurement_cursor=False)

Measure flat top to flat bottom voltage.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
v_flat_amp = v33_net.measurement.voltage_flat_amplitude() #Top to bottom flat voltage in Volts
print(v_flat_amp)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

amplitude of the voltage between the top and bottom of the waveform

Return type:

float

voltage_average(display=False, measurement_cursor=False)

Measure average voltage.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
v_avg = v33_net.measurement.voltage_average() #Average voltage in Volts
print(v_avg)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

average voltage

Return type:

float

voltage_rms(display=False, measurement_cursor=False)

Measure root mean square (rms) voltage.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
v_rms = v33_net.measurement.voltage_rms() #Rms voltage in Volts
print(v_rms)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

Rms voltage

Return type:

float

voltage_overshoot(display=False, measurement_cursor=False)

Measure waveform overshoot voltage.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
v_osht = v33_net.measurement.voltage_overshoot() #Waveform overshoot voltage in Volts
print(v_v_osht)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

waveform overshoot voltage

Return type:

float

voltage_preshoot(display=False, measurement_cursor=False)

Measure preshoot voltage.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
v_psht = v33_net.measurement.voltage_preshoot() #Waveform preshoot voltage in Volts
print(v_psht)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

waveform preshoot voltage

Return type:

float

waveform_area(display=False, measurement_cursor=False)

Measure area on the screen.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
area = v33_net.measurement.waveform_area() #Waveform area on screen in V*s
print(area)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

waveform area on screen in V*s

Return type:

float

waveform_period_area(display=False, measurement_cursor=False)

Measure first period area on the screen.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
area_period = v33_net.measurement.waveform_period_area() #Waveform's first period area on screen in V*s
print(area_period)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

waveform's first period area on screen in V*s

Return type:

float

period(display=False, measurement_cursor=False)

Measure waveform period.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
period = v33_net.measurement.period() #Waveform's period in seconds
print(period)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

waveform's period in s

Return type:

float

frequency(display=False, measurement_cursor=False)

Measure frequency.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
freq = v33_net.measurement.frequency() #Waveform's frequency in Hz
print(freq)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

waveform's frequency in Hz

Return type:

float

rise_time(display=False, measurement_cursor=False)

Measure rise-time.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
rt = v33_net.measurement.rise_time() #Rise time in seconds
print(rt)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

rise time in s

Return type:

float

fall_time(display=False, measurement_cursor=False)

Measure fall-time.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
ft = v33_net.measurement.fall_time() #Fall time in seconds
print(ft)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

fall time in s

Return type:

float

pulse_width_positive(display=False, measurement_cursor=False)

Mesure positive pulse width

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
ppw = v33_net.measurement.pulse_width_positive() #Positive pulse width in seconds
print(ppw)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

positive pulse width in s

Return type:

float

pulse_width_negative(display=False, measurement_cursor=False)

Measure negative pulse width

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
npw = v33_net.measurement.pulse_width_negative() #Negative pulse width in seconds
print(npw)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

negative pulse width in s

Return type:

float

duty_cycle_positive(display=False, measurement_cursor=False)

Measure PWM signal's postive duty cycle

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
pos_dc = v33_net.measurement.duty_cycle_positive() #Positive Duty Cycle in %
print(pos_dc)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

positive duty cycle in %

Return type:

float

duty_cycle_negative(display=False, measurement_cursor=False)

Measure PWM signal's negative duty cycle

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
neg_dc = v33_net.measurement.duty_cycle_positive() #Negative Duty Cycle in %
print(neg_dc)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

negative duty cycle in %

Return type:

float

time_at_voltage_max(display=False, measurement_cursor=False)

Measure time a signal spends at its maximum voltage.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
tvmx = v33_net.measurement.time_at_voltage_max() #Time at max voltage in seconds
print(tvmx)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

time at max voltage in seconds

Return type:

float

time_at_voltage_min(display=False, measurement_cursor=False)

Measure time a signal spends at its minimum voltage.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
tvmin = v33_net.measurement.time_at_voltage_min() #Time at min voltage in seconds
print(tvmin)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

time at min voltage in seconds

Return type:

float

positive_slew_rate(display=False, measurement_cursor=False)

Measure the positive slew rate.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
p_slew = v33_net.measurement.positive_slew_rate() #Positive slew rate in V/s
print(p_slew)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

positive slew rate in V/s

Return type:

float

negative_slew_rate(display=False, measurement_cursor=False)

Measure the negative slew rate.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
n_slew = v33_net.measurement.negative_slew_rate() #Negative slew rate in V/s
print(n_slew)

voltage_threshold_upper(display=False, measurement_cursor=False)

Measure the the upper voltage threshold of the signal.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
vupper = v33_net.measurement.voltage_threshold_upper() #Upper voltage threshold in Volts
print(vupper)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

upper voltage threshold in Volts

Return type:

float

voltage_threshold_lower(display=False, measurement_cursor=False)

Measure the the lower voltage threshold of the signal.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
v_lower = v33_net.measurement.voltage_threshold_lower() #Lower voltage threshold in Volts
print(v_lower)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

lower voltage threshold in Volts

Return type:

float

voltage_threshold_mid(display=False, measurement_cursor=False)

Measure the the mid voltage threshold of the signal.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
v_mid = v33_net.measurement.voltage_threshold_mid() #Mid voltage threshold in Volts
print(v_mid)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

mid voltage threshold in Volts

Return type:

float

variance(display=False, measurement_cursor=False)

Measure signal variance.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
variance = v33_net.measurement.variance() #Waveform variance
print(variance)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

variance

Return type:

float

pvoltage_rms(display=False, measurement_cursor=False)

Measure positive root mean square (rms).

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
p_rms = v33_net.measurement.pvoltage_rms()
print(p_rms)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

postive RMS voltage

Return type:

float

positve_pulse_count(display=False, measurement_cursor=False)

Measure positive pulse count.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
pos_pulse_count = v33_net.measurement.positve_pulse_count()
print(pos_pulse_count)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

postive pulse count

Return type:

float

negative_pulse_count(display=False, measurement_cursor=False)

Measure negative pulse count.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
neg_pulse_count = v33_net.measurement.negative_pulse_count()
print(neg_pulse_count)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

negative pulse count

Return type:

float

positive_edge_count(display=False, measurement_cursor=False)

Measure the positive slope edge count.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
pos_edge_count = v33_net.measurement.positive_edge_count()
print(pos_edge_count)

negative_edge_count(display=False, measurement_cursor=False)

Measure the negative slope edge count.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
neg_edge_count = v33_net.measurement.negative_edge_count()
print(neg_edge_count)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

negative edge count

Return type:

float

delay_rising_rising_edge(display=False, measurement_cursor=False)

Delay between two rising edges.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
delay = v33_net.measurement.delay_rising_rising_edge()
print(delay)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

delay time between two rising edges in Seconds

Return type:

float

delay_rising_falling_edge(display=False, measurement_cursor=False)

Delay between leading rising edge and trailing falling edge.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
delay = v33_net.measurement.delay_rising_falling_edge()
print(delay)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

delay time between leading rising edge and trailing falling edge in Seconds

Return type:

float

delay_falling_rising_edge(display=False, measurement_cursor=False)

Delay between leading falling edge and trailing rising edge.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
delay = v33_net.measurement.delay_falling_rising_edge()
print(delay)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

delay time between leading falling edge and trailing rising edge in Seconds

Return type:

float

delay_falling_falling_edge(display=False, measurement_cursor=False)

Delay between two falling edges.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
delay = v33_net.measurement.delay_falling_falling_edge()
print(delay)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

delay time between two falling edges in Seconds

Return type:

float

phase_rising_rising_edge(display=False, measurement_cursor=False)

Phase between two rising edges.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
phase = v33_net.measurement.phase_rising_rising_edge()
print(phase)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

phase between two rising edges

Return type:

float

phase_rising_falling_edge(display=False, measurement_cursor=False)

Phase between leading rising edge and trailing falling edge.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
phase = v33_net.measurement.phase_rising_falling_edge()
print(phase)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

phase between leading rising edge and trailing falling edge

Return type:

float

phase_falling_rising_edge(display=False, measurement_cursor=False)

Phase between leading falling edge and trailing rising edge.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
phase = v33_net.measurement.phase_falling_rising_edge()
print(phase)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

phase between leading falling edge and trailing rising edge

Return type:

float

phase_falling_falling_edge(display=False, measurement_cursor=False)

Phase between two falling edges.

from lager.pcb.net import Net, NetType

v33_net = Net.get('+3.3V',
            type=NetType.Analog,
            setup_function=setup_net,
            teardown_function=teardown_net)
v33_net.enable()
phase = v33_net.measurement.phase_falling_falling_edge()
print(phase)

Parameters:

display (bool) -- display measurement value to screen, optional
measurement_cursor (bool) -- display measurement cursor to screen, optional

Returns:

phase between two falling edges

Return type:

float