Measurement
===========

.. py:module:: Nets
    :noindex:

.. py:class:: Measurement

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

    .. py:method:: voltage_max(display=False, measurement_cursor=False)

        Measure the maximum voltage.

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: max voltage for this trace in Volts
        :rtype: float     

    .. py:method:: voltage_min(display=False, measurement_cursor=False)

        Measure the minimum voltage.

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: min voltage for this trace in Volts
        :rtype: float

    .. py:method:: voltage_peak_to_peak(display=False, measurement_cursor=False)

        Measure peak to peak voltage

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: peak to peak voltage for this trace in Volts
        :rtype: float

    .. py:method:: voltage_flat_top(display=False, measurement_cursor=False)

        Measure top "flat" voltage.

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: Top flat voltage for this trace in Volts
        :rtype: float

    .. py:method:: voltage_flat_base(display=False, measurement_cursor=False)

        Measure bottom "flat" voltage.

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: Bottom flat voltage for this trace in Volts
        :rtype: float

    .. py:method:: voltage_flat_amplitude(display=False, measurement_cursor=False)

        Measure flat top to flat bottom voltage.

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: amplitude of the voltage between the top and bottom of the waveform
        :rtype: float

    .. py:method:: voltage_average(display=False, measurement_cursor=False)

        Measure average voltage.

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: average voltage
        :rtype: float

    .. py:method:: voltage_rms(display=False, measurement_cursor=False)

        Measure root mean square (rms) voltage.

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: Rms voltage
        :rtype: float

    .. py:method:: voltage_overshoot(display=False, measurement_cursor=False)

        Measure waveform overshoot voltage.

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: waveform overshoot voltage
        :rtype: float

    .. py:method:: voltage_preshoot(display=False, measurement_cursor=False)

        Measure preshoot voltage.

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: waveform preshoot voltage
        :rtype: float        

    .. py:method:: waveform_area(display=False, measurement_cursor=False)

        Measure area on the screen.

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: waveform area on screen in V*s
        :rtype: float 

    .. py:method:: waveform_period_area(display=False, measurement_cursor=False)

        Measure first period area on the screen.

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: waveform's first period area on screen in V*s
        :rtype: float

    .. py:method:: period(display=False, measurement_cursor=False)

        Measure waveform period.

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: waveform's period in s
        :rtype: float

    .. py:method:: frequency(display=False, measurement_cursor=False)

        Measure frequency.

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: waveform's frequency in Hz
        :rtype: float        

    .. py:method:: rise_time(display=False, measurement_cursor=False)

        Measure rise-time.

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: rise time in s
        :rtype: float 

    .. py:method:: fall_time(display=False, measurement_cursor=False)

        Measure fall-time.

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: fall time in s
        :rtype: float 

    .. py:method:: pulse_width_positive(display=False, measurement_cursor=False)

        Mesure positive pulse width

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: positive pulse width in s
        :rtype: float

    .. py:method:: pulse_width_negative(display=False, measurement_cursor=False)

        Measure negative pulse width

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: negative pulse width in s
        :rtype: float

    .. py:method:: duty_cycle_positive(display=False, measurement_cursor=False)

        Measure PWM signal's postive duty cycle

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: positive duty cycle in %
        :rtype: float

    .. py:method:: duty_cycle_negative(display=False, measurement_cursor=False)

        Measure PWM signal's negative duty cycle

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: negative duty cycle in %
        :rtype: float        

    .. py:method:: time_at_voltage_max(display=False, measurement_cursor=False)

        Measure time a signal spends at its maximum voltage.

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: time at max voltage in seconds
        :rtype: float

    .. py:method:: time_at_voltage_min(display=False, measurement_cursor=False)

        Measure time a signal spends at its minimum voltage.

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: time at min voltage in seconds
        :rtype: float

    .. py:method:: positive_slew_rate(display=False, measurement_cursor=False)

        Measure the positive slew rate.

        .. code-block:: python
            :emphasize-lines: 8

            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)   

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: positive slew rate in V/s
        :rtype: float        

    .. py:method:: negative_slew_rate(display=False, measurement_cursor=False)

        Measure the negative slew rate.

        .. code-block:: python
            :emphasize-lines: 8

            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)

    .. py:method:: voltage_threshold_upper(display=False, measurement_cursor=False)

        Measure the the upper voltage threshold of the signal.

        .. code-block:: python
            :emphasize-lines: 8

            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)              

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: upper voltage threshold in Volts
        :rtype: float 

    .. py:method:: voltage_threshold_lower(display=False, measurement_cursor=False)

        Measure the the lower voltage threshold of the signal.

        .. code-block:: python
            :emphasize-lines: 8

            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)              

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: lower voltage threshold in Volts
        :rtype: float 

    .. py:method:: voltage_threshold_mid(display=False, measurement_cursor=False)

        Measure the the mid voltage threshold of the signal.

        .. code-block:: python
            :emphasize-lines: 8

            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)            

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: mid voltage threshold in Volts
        :rtype: float 

    .. py:method:: variance(display=False, measurement_cursor=False)

        Measure signal variance.

        .. code-block:: python
            :emphasize-lines: 8

            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)            

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: variance
        :rtype: float 

    .. py:method:: pvoltage_rms(display=False, measurement_cursor=False)

        Measure positive root mean square (rms).

        .. code-block:: python
            :emphasize-lines: 8

            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)            

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: postive RMS voltage
        :rtype: float

    .. py:method:: positve_pulse_count(display=False, measurement_cursor=False)

        Measure positive pulse count.

        .. code-block:: python
            :emphasize-lines: 8

            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)            

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: postive pulse count
        :rtype: float

    .. py:method:: negative_pulse_count(display=False, measurement_cursor=False)

        Measure negative pulse count.

        .. code-block:: python
            :emphasize-lines: 8

            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)            

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: negative pulse count
        :rtype: float 

    .. py:method:: positive_edge_count(display=False, measurement_cursor=False)

        Measure the positive slope edge count.

        .. code-block:: python
            :emphasize-lines: 8

            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)            

    .. py:method:: negative_edge_count(display=False, measurement_cursor=False)

        Measure the negative slope edge count.

        .. code-block:: python
            :emphasize-lines: 8

            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)

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: negative edge count
        :rtype: float

    .. py:method:: delay_rising_rising_edge(display=False, measurement_cursor=False)

        Delay between two rising edges.

        .. code-block:: python
            :emphasize-lines: 8

            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)

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: delay time between two rising edges in Seconds
        :rtype: float

    .. py:method:: delay_rising_falling_edge(display=False, measurement_cursor=False)

        Delay between leading rising edge and trailing falling edge.

        .. code-block:: python
            :emphasize-lines: 8

            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)

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: delay time between leading rising edge and trailing falling edge in Seconds
        :rtype: float                                      

    .. py:method:: delay_falling_rising_edge(display=False, measurement_cursor=False)

        Delay between leading falling edge and trailing rising edge.

        .. code-block:: python
            :emphasize-lines: 8

            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)

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: delay time between leading falling edge and trailing rising edge in Seconds
        :rtype: float 

    .. py:method:: delay_falling_falling_edge(display=False, measurement_cursor=False)

        Delay between two falling edges.

        .. code-block:: python
            :emphasize-lines: 8

            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)

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: delay time between two falling edges in Seconds
        :rtype: float     

    .. py:method:: phase_rising_rising_edge(display=False, measurement_cursor=False)

        Phase between two rising edges.

        .. code-block:: python
            :emphasize-lines: 8

            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)

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: phase between two rising edges
        :rtype: float   

    .. py:method:: phase_rising_falling_edge(display=False, measurement_cursor=False)

        Phase between leading rising edge and trailing falling edge.

        .. code-block:: python
            :emphasize-lines: 8

            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)

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: phase between leading rising edge and trailing falling edge
        :rtype: float  

    .. py:method:: phase_falling_rising_edge(display=False, measurement_cursor=False)

        Phase between leading falling edge and trailing rising edge.

        .. code-block:: python
            :emphasize-lines: 8

            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)

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: phase between leading falling edge and trailing rising edge
        :rtype: float   

    .. py:method:: phase_falling_falling_edge(display=False, measurement_cursor=False)

        Phase between two falling edges.

        .. code-block:: python
            :emphasize-lines: 8

            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)

        :param bool display: display measurement value to screen, optional
        :param bool measurement_cursor: display measurement cursor to screen, optional
        :return: phase between two falling edges
        :rtype: float