"""enums.py - Contains enum classes."""
from enum import Enum, IntFlag
[docs]
class TriggerType(Enum):
"""TriggerType."""
NONE = 0
r"""No Reference Trigger is configured."""
DIGITAL_EDGE = 1
r"""The Reference Trigger is not asserted until a digital edge is detected. The source of the digital edge is specified
using the :py:attr:`~nirfmxtdscdma.attributes.AttributeID.DIGITAL_EDGE_TRIGGER_SOURCE` attribute."""
IQ_POWER_EDGE = 2
r"""The Reference Trigger is asserted when the signal changes past the level specified by the rising or falling slope,
which is configured using the :py:attr:`~nirfmxtdscdma.attributes.AttributeID.IQ_POWER_EDGE_TRIGGER_SLOPE` attribute."""
SOFTWARE = 3
r"""The trigger is not asserted until a software trigger occurs."""
[docs]
class DigitalEdgeTriggerEdge(Enum):
"""DigitalEdgeTriggerEdge."""
RISING_EDGE = 0
r"""The trigger asserts on the rising edge of the signal."""
FALLING_EDGE = 1
r"""The trigger asserts on the falling edge of the signal."""
[docs]
class IQPowerEdgeTriggerLevelType(Enum):
"""IQPowerEdgeTriggerLevelType."""
RELATIVE = 0
r"""The IQ Power Edge Level attribute is relative to the value of the
:py:attr:`~nirfmxtdscdma.attributes.AttributeID.REFERENCE_LEVEL` attribute."""
ABSOLUTE = 1
r"""The IQ Power Edge Level attribute specifies the absolute power."""
[docs]
class IQPowerEdgeTriggerSlope(Enum):
"""IQPowerEdgeTriggerSlope."""
RISING_SLOPE = 0
r"""The trigger asserts when the signal power is rising."""
FALLING_SLOPE = 1
r"""The trigger asserts when the signal power is falling."""
[docs]
class TriggerMinimumQuietTimeMode(Enum):
"""TriggerMinimumQuietTimeMode."""
MANUAL = 0
r"""The minimum quiet time for triggering is the value of the
:py:attr:`~nirfmxtdscdma.attributes.AttributeID.TRIGGER_MINIMUM_QUIET_TIME_MODE` attribute."""
AUTO = 1
r"""The measurement calculates the minimum quiet time used for triggering."""
[docs]
class ChannelConfigurationMode(Enum):
"""ChannelConfigurationMode."""
AUTO_DETECT = 0
r"""RFmx TD-SCDMA detects the channels automatically."""
USER_DEFINED = 1
r"""The channel configuration is defined manually. This mode increases measurement speed because no time is spent on
channel detection."""
[docs]
class ChannelType(Enum):
"""ChannelType."""
IDLE = 0
r"""Specifies that the user-defined channel type is an empty slot."""
DPCH = 1
r"""Specifies that the user-defined channel is a dedicated physical channel (DPCH)."""
EDCH = 2
r"""Specifies that the user-defined channel is an enhanced dedicated channel (EDCH)."""
HSSICH = 3
r"""Specifies that the user-defined channel is a shared information channel for high speed downlink."""
[docs]
class ModulationType(Enum):
"""ModulationType."""
MODULATION_TYPE_QPSK = 0
r"""Specifies quadrature-phase shift keying (QPSK) modulation type."""
MODULATION_TYPE_8PSK = 1
r"""Specifies 8-phase shift keying (8-PSK) modulation type."""
MODULATION_TYPE_16QAM = 2
r"""Specifies 16-quadrature amplitude modulation (16-QAM) modulation type."""
[docs]
class MidambleAutoDetectionMode(Enum):
"""MidambleAutoDetectionMode."""
OFF = 0
r"""Auto detection of the midamble shift is disabled. The measurement uses the midamble shift value that you specify in the
:py:attr:`~nirfmxtdscdma.attributes.AttributeID.MIDAMBLE_SHIFT` attribute."""
MIDAMBLE_SHIFT = 1
r"""The midamble shift is automatically detected from *K* possible midamble shift values, where *K* is specified by the
:py:attr:`~nirfmxtdscdma.attributes.AttributeID.MAXIMUM_NUMBER_OF_USERS` attribute.
The *K* possible midamble shift values are:
*Midamble Shift* = *k* * *floor(P/K)*,
where *P* is the length of the basic midamble code, and *k* is an integer from 0 to *K*-1."""
[docs]
class ModAccSynchronizationMode(Enum):
"""ModAccSynchronizationMode."""
SLOT = 0
r"""The measurement uses the slot synchronization mode. The slot boundary in the acquired signal is detected, and the
measurement is performed over the number of slots specified by the
:py:attr:`~nirfmxtdscdma.attributes.AttributeID.MODACC_MEASUREMENT_LENGTH` attribute, starting at the offset from the
boundary specified by the :py:attr:`~nirfmxtdscdma.attributes.AttributeID.MODACC_MEASUREMENT_OFFSET` attribute.
If you set the :py:attr:`~nirfmxtdscdma.attributes.AttributeID.TRIGGER_TYPE` attribute to **Digital Edge**, you
should provide the trigger at the start of the slot from which the ModAcc Meas Offset attribute should be considered.
If you set the Trigger Type attribute to **IQ Power Edge**, it is required that the received signal has either one
traffic time slot or contiguous traffic time slots. Additionally, for this trigger type, the traffic time slot(s) in
the received signal should be contiguous with the pilot time slot, if the pilot time slot is present."""
SUBFRAME = 1
r"""The measurement uses the subframe synchronization mode. The first subframe boundary in the acquired signal is detected,
and the measurement is performed over the number of slots specified by the ModAcc Meas Length attribute, starting at
the offset from the boundary specified by the ModAcc Meas Offset attribute.
If you set the Trigger Type attribute to **Digital Edge**, you should provide the trigger at the start of the
subframe. If you set the Trigger Type attribute to **IQ Power Edge**, it is required that the received signal has
either one traffic time slot or contiguous traffic time slots. Additionally, the traffic time slot should be contiguous
with the active pilot time slot."""
[docs]
class ModAccSlotType(Enum):
"""ModAccSlotType."""
TRAFFIC = 0
r"""The measurement is performed on the traffic time slot. The composite, data, and midamble ModAcc results are obtained
when you select this slot type."""
PILOT = 1
r"""The measurement is performed on the pilot time slot. The pilot ModAcc results are obtained when you select this slot
type."""
[docs]
class ModAccSpectrumInverted(Enum):
"""ModAccSpectrumInverted."""
FALSE = 0
r"""The measured spectrum is not inverted."""
TRUE = 1
r"""The measured spectrum is inverted."""
[docs]
class ModAccIQOffsetRemovalEnabled(Enum):
"""ModAccIQOffsetRemovalEnabled."""
FALSE = 0
r"""The I/Q offset is not removed before the ModAcc measurement."""
TRUE = 1
r"""The I/Q offset is removed before the ModAcc measurement."""
[docs]
class ModAccIQGainImbalanceRemovalEnabled(Enum):
"""ModAccIQGainImbalanceRemovalEnabled."""
FALSE = 0
r"""The I/Q gain imbalance is not removed before the ModAcc measurement."""
TRUE = 1
r"""The I/Q gain imbalance is removed before the ModAcc measurement."""
[docs]
class ModAccIQQuadratureErrorRemovalEnabled(Enum):
"""ModAccIQQuadratureErrorRemovalEnabled."""
FALSE = 0
r"""The I/Q quadrature error is not removed before the ModAcc measurement."""
TRUE = 1
r"""The I/Q quadrature error is removed before the ModAcc measurement."""
[docs]
class ModAccRrcFilterEnabled(Enum):
"""ModAccRrcFilterEnabled."""
FALSE = 0
r"""Disables the RRC filter in the ModAcc measurement."""
TRUE = 1
r"""Enables the RRC filter in the ModAcc measurement."""
[docs]
class ModAccAveragingEnabled(Enum):
"""ModAccAveragingEnabled."""
FALSE = 0
r"""The measurement is performed on a single acquisition."""
TRUE = 1
r"""The ModAcc measurement uses the value of the :py:attr:`~nirfmxtdscdma.attributes.AttributeID.MODACC_AVERAGING_COUNT`
attribute as the number of acquisitions over which the ModAcc measurement is averaged."""
[docs]
class ModAccDetectedModulationType(Enum):
"""ModAccDetectedModulationType."""
MODULATION_TYPE_QPSK = 0
r"""Indicates QPSK modulation."""
MODULATION_TYPE_8PSK = 1
r"""Indicates 8-PSK modulation."""
MODULATION_TYPE_16QAM = 2
r"""Indicates 16-QAM modulation."""
[docs]
class AcpRbwAutoBandwidth(Enum):
"""AcpRbwAutoBandwidth."""
FALSE = 0
r"""The measurement uses the RBW that you specify in the
:py:attr:`~nirfmxtdscdma.attributes.AttributeID.ACP_RBW_FILTER_BANDWIDTH` attribute."""
TRUE = 1
r"""The measurement calculates the RBW."""
[docs]
class AcpRbwFilterType(Enum):
"""AcpRbwFilterType."""
FFT_BASED = 0
r"""An RBW filter with a fast Fourier transform (FFT)-based response is applied."""
GAUSSIAN = 1
r"""An RBW filter with a Gaussian response is applied."""
FLAT = 2
r"""An RBW filter with a flat response is applied."""
[docs]
class AcpSweepTimeAuto(Enum):
"""AcpSweepTimeAuto."""
FALSE = 0
r"""The measurement uses the sweep time that you specify in the
:py:attr:`~nirfmxtdscdma.attributes.AttributeID.ACP_SWEEP_TIME_INTERVAL` attribute."""
TRUE = 1
r"""The measurement uses the default sweep time of .00066 seconds (s)."""
[docs]
class AcpMeasurementMethod(Enum):
"""AcpMeasurementMethod."""
NORMAL = 0
r"""The ACP measurement acquires the spectrum using the same signal analyzer setting across frequency bands. Use this
method when a higher measurement speed is desirable over a higher dynamic range."""
DYNAMIC_RANGE = 1
r"""The ACP measurement acquires the spectrum using the hardware-specific optimizations for different frequency bands. Use
this method to get the best dynamic range.**Supported Devices**: PXIe-5665/5668R."""
SEQUENTIAL_FFT = 2
r"""The ACP measurement acquires I/Q samples for a duration specified by the
:py:attr:`~nirfmxtdscdma.attributes.AttributeID.ACP_SWEEP_TIME_INTERVAL` attribute. These samples are divided into
smaller chunks. The size of these chunks is defined by the
:py:attr:`~nirfmxtdscdma.attributes.AttributeID.ACP_SEQUENTIAL_FFT_SIZE` attribute and FFT is computed on each of these
chunks. The resultant FFTs are averaged to get the spectrum and is used to compute ACP. If the total acquired samples
is not an integer multiple of the FFT size, the remaining samples at the end of acquisition are not used for the
measurement. Use this method to optimize ACP measurement speed. Accuracy of the results may be reduced when using this
measurement method.
For accurate power measurements, when the power characteristics of the signal vary over time, Averaging is
allowed.
The following attributes have limited support when you set the ACP Meas Method attribute to **Sequential FFT**.
+---------------------------------------------------------------------------------+-----------------+
| Property | Supported Value |
+=================================================================================+=================+
| :py:attr:`~nirfmxtdscdma.attributes.AttributeID.ACP_RBW_FILTER_AUTO_BANDWIDTH` | True |
+---------------------------------------------------------------------------------+-----------------+
| :py:attr:`~nirfmxtdscdma.attributes.AttributeID.ACP_RBW_FILTER_TYPE` | FFT Based |
+---------------------------------------------------------------------------------+-----------------+
| :py:attr:`~nirfmxtdscdma.attributes.AttributeID.ACP_AVERAGING_COUNT` | >=1 |
+---------------------------------------------------------------------------------+-----------------+
| :py:attr:`~nirfmxtdscdma.attributes.AttributeID.ACP_NUMBER_OF_ANALYSIS_THREADS` | >=1 |
+---------------------------------------------------------------------------------+-----------------+
.. note::
For Multi-Span FFT, the averaging count should be 1."""
[docs]
class AcpNoiseCompensationEnabled(Enum):
"""AcpNoiseCompensationEnabled."""
FALSE = 0
r"""Disables compensation of the channel powers for the signal analyzer noise floor."""
TRUE = 1
r"""Enables compensation of the channel powers for the signal analyzer noise floor. The noise floor of the signal analyzer
is measured for the RF path used by the ACP measurement and cached for future use. If signal analyzer or measurement
parameters change, noise floors are remeasured.
**Supported Devices:** PXIe-5663/5665/5668R/5830/5831/5832/5842/5860"""
[docs]
class AcpAveragingEnabled(Enum):
"""AcpAveragingEnabled."""
FALSE = 0
r"""The measurement is performed on a single acquisition."""
TRUE = 1
r"""The ACP measurement uses the value of the :py:attr:`~nirfmxtdscdma.attributes.AttributeID.ACP_AVERAGING_COUNT`
attribute as the number of acquisitions over which the ACP measurement is averaged."""
[docs]
class AcpAveragingType(Enum):
"""AcpAveragingType."""
RMS = 0
r"""The power spectrum is linearly averaged. RMS averaging reduces signal fluctuations but not the noise floor."""
LOG = 1
r"""The power spectrum is averaged on a logarithmic scale."""
SCALAR = 2
r"""The square root of the power spectrum is averaged."""
MAXIMUM = 3
r"""The peak power in the spectrum at each frequency bin is retained from one acquisition to the next."""
MINIMUM = 4
r"""The lowest power in the spectrum at each frequency bin is retained from one acquisition to the next."""
[docs]
class AcpFftOverlapMode(Enum):
"""AcpFftOverlapMode."""
DISABLED = 0
r"""Indicates that overlapping is not applied to the acquired samples."""
AUTOMATIC = 1
r"""Indicates that the RFmx driver automatically chooses optimal values of the
:py:attr:`~nirfmxtdscdma.attributes.AttributeID.ACP_FFT_OVERLAP` attribute based on the measurement configuration."""
[docs]
class AcpIFOutputPowerOffsetAuto(Enum):
"""AcpIFOutputPowerOffsetAuto."""
FALSE = 0
r"""The system does not calculate an IF output power level offset."""
TRUE = 1
r"""The system calculates an IF output power level offset."""
[docs]
class ChpRbwAutoBandwidth(Enum):
"""ChpRbwAutoBandwidth."""
FALSE = 0
r"""The measurement uses the RBW you specify."""
TRUE = 1
r"""RFmx TD-SCDMA automatically calculates the RBW."""
[docs]
class ChpRbwFilterType(Enum):
"""ChpRbwFilterType."""
FFT_BASED = 0
r"""An RBW filter with a fast Fourier transform (FFT)-based response is applied."""
GAUSSIAN = 1
r"""An RBW filter with a Gaussian response is applied."""
FLAT = 2
r"""An RBW filter with a flat response is applied."""
[docs]
class ChpSweepTimeAuto(Enum):
"""ChpSweepTimeAuto."""
FALSE = 0
r"""The measurement uses the sweep time you specify in the
:py:attr:`~nirfmxtdscdma.attributes.AttributeID.CHP_SWEEP_TIME_INTERVAL` attribute."""
TRUE = 1
r"""The measurement uses the default sweep time of .00066 seconds (s)."""
[docs]
class ChpAveragingEnabled(Enum):
"""ChpAveragingEnabled."""
FALSE = 0
r"""The measurement is performed on a single acquisition."""
TRUE = 1
r"""The CHP measurement uses the :py:attr:`~nirfmxtdscdma.attributes.AttributeID.CHP_AVERAGING_COUNT` attribute as the
number of acquisitions over which the CHP measurement is averaged."""
[docs]
class ChpAveragingType(Enum):
"""ChpAveragingType."""
RMS = 0
r"""The power spectrum is linearly averaged. RMS averaging reduces signal fluctuations but not the noise floor."""
LOG = 1
r"""The power spectrum is averaged on a logarithmic scale."""
SCALAR = 2
r"""The square root of the power spectrum is averaged."""
MAXIMUM = 3
r"""The peak power in the spectrum at each frequency bin is retained from one acquisition to the next."""
MINIMUM = 4
r"""The lowest power in the spectrum at each frequency bin is retained from one acquisition to the next."""
[docs]
class ObwRbwAutoBandwidth(Enum):
"""ObwRbwAutoBandwidth."""
FALSE = 0
r"""The measurement uses the RBW that you specify in the
:py:attr:`~nirfmxtdscdma.attributes.AttributeID.OBW_RBW_FILTER_BANDWIDTH` attribute."""
TRUE = 1
r"""The measurement calculates the RBW."""
[docs]
class ObwRbwFilterType(Enum):
"""ObwRbwFilterType."""
FFT_BASED = 0
r"""An RBW filter with a fast Fourier transform (FFT)-based response is applied."""
GAUSSIAN = 1
r"""An RBW filter with a Gaussian response is applied."""
FLAT = 2
r"""An RBW filter with a flat response is applied."""
[docs]
class ObwSweepTimeAuto(Enum):
"""ObwSweepTimeAuto."""
FALSE = 0
r"""The measurement uses the sweep time that you specify in the
:py:attr:`~nirfmxtdscdma.attributes.AttributeID.OBW_SWEEP_TIME_INTERVAL` attribute."""
TRUE = 1
r"""The measurement uses the default sweep time of .00066 seconds (s)."""
[docs]
class ObwAveragingEnabled(Enum):
"""ObwAveragingEnabled."""
FALSE = 0
r"""The measurement is performed on a single acquisition."""
TRUE = 1
r"""The OBW measurement uses the value of the :py:attr:`~nirfmxtdscdma.attributes.AttributeID.OBW_AVERAGING_COUNT`
attribute as the number of acquisitions over which the OBW measurement is averaged."""
[docs]
class ObwAveragingType(Enum):
"""ObwAveragingType."""
RMS = 0
r"""The power spectrum is linearly averaged. RMS averaging reduces signal fluctuations but not the noise floor."""
LOG = 1
r"""The power spectrum is averaged on a logarithmic scale."""
SCALAR = 2
r"""The square root of the power spectrum is averaged."""
MAXIMUM = 3
r"""The peak power in the spectrum at each frequency bin is retained from one acquisition to the next."""
MINIMUM = 4
r"""The lowest power in the spectrum at each frequency bin is retained from one acquisition to the next."""
[docs]
class SemOffsetRbwFilterType(Enum):
"""SemOffsetRbwFilterType."""
FFT_BASED = 0
r"""No RBW filtering is performed."""
GAUSSIAN = 1
r"""The RBW filter has a Gaussian response."""
FLAT = 2
r"""The RBW filter has a flat response."""
SYNCH_TUNED_4 = 3
r"""The RBW filter has a response of a 4-pole synchronously tuned filter."""
SYNCH_TUNED_5 = 4
r"""The RBW filter has a response of a 5-pole synchronously tuned filter."""
[docs]
class SemSweepTimeAuto(Enum):
"""SemSweepTimeAuto."""
FALSE = 0
r"""The measurement uses the sweep time that you specify in the
:py:attr:`~nirfmxtdscdma.attributes.AttributeID.SEM_SWEEP_TIME_INTERVAL` attribute."""
TRUE = 1
r"""The measurement uses the default sweep time of .00066 seconds (s)."""
[docs]
class SemAveragingEnabled(Enum):
"""SemAveragingEnabled."""
FALSE = 0
r"""The measurement is performed on a single acquisition."""
TRUE = 1
r"""The SEM measurement uses the value of the :py:attr:`~nirfmxtdscdma.attributes.AttributeID.SEM_AVERAGING_COUNT`
attribute as the number of acquisitions over which the SEM measurement is averaged."""
[docs]
class SemAveragingType(Enum):
"""SemAveragingType."""
RMS = 0
r"""The power spectrum is linearly averaged. RMS averaging reduces signal fluctuations but not the noise floor."""
LOG = 1
r"""The power spectrum is averaged on a logarithmic scale."""
SCALAR = 2
r"""The square root of the power spectrum is averaged."""
MAXIMUM = 3
r"""The peak power in the spectrum at each frequency bin is retained from one acquisition to the next."""
MINIMUM = 4
r"""The lowest power in the spectrum at each frequency bin is retained from one acquisition to the next."""
[docs]
class SemMeasurementStatus(Enum):
"""SemMeasurementStatus."""
FAIL = 0
r"""The measurement failed according to the measurement limits and criteria you set."""
PASS = 1
r"""The measurement passed according to the measurement limits and criteria you set."""
[docs]
class SemLowerOffsetMeasurementStatus(Enum):
"""SemLowerOffsetMeasurementStatus."""
FAIL = 0
r"""The lower offset segment measurement failed according to the measurement limits and criteria you set."""
PASS = 1
r"""The lower offset segment measurement passed according to the measurement limits and criteria you set."""
[docs]
class SemUpperOffsetMeasurementStatus(Enum):
"""SemUpperOffsetMeasurementStatus."""
FAIL = 0
r"""The measured power exceeded the specified measurement limits and failure criteria."""
PASS = 1
r"""The measured power did not exceed the specified measurement limits and failure criteria."""
[docs]
class CdaSynchronizationMode(Enum):
"""CdaSynchronizationMode."""
SLOT = 0
r"""The measurement uses slot synchronization mode. The slot boundary in the acquired signal is detected, and the
measurement is performed over one slot, starting from the boundary specified by the
:py:attr:`~nirfmxtdscdma.attributes.AttributeID.MODACC_MEASUREMENT_OFFSET` attribute."""
[docs]
class CdaSpectrumInverted(Enum):
"""CdaSpectrumInverted."""
FALSE = 0
r"""The spectrum is not inverted."""
TRUE = 1
r"""The spectrum is inverted."""
[docs]
class CdaIQOffsetRemovalEnabled(Enum):
"""CdaIQOffsetRemovalEnabled."""
FALSE = 0
r"""The I/Q offset is not removed before the CDA measurement."""
TRUE = 1
r"""The I/Q offset is removed before the CDA measurement."""
[docs]
class CdaIQGainImbalanceRemovalEnabled(Enum):
"""CdaIQGainImbalanceRemovalEnabled."""
FALSE = 0
r"""The I/Q gain imbalance is not removed before the CDA measurement."""
TRUE = 1
r"""The I/Q gain imbalance is removed before the CDA measurement."""
[docs]
class CdaIQQuadratureErrorRemovalEnabled(Enum):
"""CdaIQQuadratureErrorRemovalEnabled."""
FALSE = 0
r"""The I/Q quadrature error is not removed before the CDA measurement."""
TRUE = 1
r"""The I/Q quadrature error is removed before the CDA measurement."""
[docs]
class CdaPowerUnit(Enum):
"""CdaPowerUnit."""
DB = 0
r"""The measurement unit for CDP results is dB."""
DBM = 1
r"""The measurement unit for CDP results is dBm."""
[docs]
class CdaRrcFilterEnabled(Enum):
"""CdaRrcFilterEnabled."""
FALSE = 0
r"""Disables the RRC filter in the measurement."""
TRUE = 1
r"""Enables the RRC filter in the measurement."""
[docs]
class CdaAveragingEnabled(Enum):
"""CdaAveragingEnabled."""
FALSE = 0
r"""The measurement is performed on a single acquisition."""
TRUE = 1
r"""The CDA measurement uses the value of the :py:attr:`~nirfmxtdscdma.attributes.AttributeID.CDA_AVERAGING_COUNT`
attribute as the number of acquisitions over which the CDA measurement is averaged."""
[docs]
class PvtMeasurementMethod(Enum):
"""PvtMeasurementMethod."""
NORMAL = 0
r"""The PVT measurement acquires the spectrum using the same signal analyzer setting across frequency bands. Use this
method when a higher measurement speed is preferred over a higher dynamic range."""
DYNAMIC_RANGE = 1
r"""The PVT measurement acquires the spectrum using the hardware-specific optimizations for different frequency bands. Use
this method to get the best dynamic range.
**Supported Devices**: PXIe-5644R/5645R/5646R/5840/5841/5842/5860"""
[docs]
class PvtRrcFilterEnabled(Enum):
"""PvtRrcFilterEnabled."""
FALSE = 0
r"""Disables the RRC filter in the measurement."""
TRUE = 1
r"""Enables the RRC filter in the measurement."""
[docs]
class PvtAveragingEnabled(Enum):
"""PvtAveragingEnabled."""
FALSE = 0
r"""The measurement is performed on a single acquisition."""
TRUE = 1
r"""The PVT measurement uses the value of the :py:attr:`~nirfmxtdscdma.attributes.AttributeID.PVT_AVERAGING_COUNT`
attribute as the number of acquisitions over which the PVT measurement is averaged."""
[docs]
class PvtAveragingType(Enum):
"""PvtAveragingType."""
RMS = 0
r"""The power spectrum is linearly averaged. RMS averaging reduces signal fluctuations but not the noise floor."""
LOG = 1
r"""The power spectrum is averaged on a logarithmic scale."""
[docs]
class PvtMeasurementStatus(Enum):
"""PvtMeasurementStatus."""
FAIL = 0
r"""Indicates that the test has failed, and the measured power in at least one measurement segment violates the limit."""
PASS = 1
r"""Indicates that the test has passed and the measured power in all defined segments does not violate the limits."""
[docs]
class PvtSegmentStatus(Enum):
"""PvtSegmentStatus."""
FAIL = 0
r"""Indicates that the test has failed and the measured power in at least one measurement segment violates the limit."""
PASS = 1
r"""Indicates that the test has passed and the measured power in all defined segments does not violate the limits."""
[docs]
class SlotPowerSpectrumInverted(Enum):
"""SlotPowerSpectrumInverted."""
FALSE = 0
r"""The spectrum is not inverted."""
TRUE = 1
r"""The spectrum is inverted."""
[docs]
class SlotPowerRrcFilterEnabled(Enum):
"""SlotPowerRrcFilterEnabled."""
FALSE = 0
r"""Disables the RRC filter in the SlotPower measurement."""
TRUE = 1
r"""Enables the RRC filter in the SlotPower measurement."""
[docs]
class LimitedConfigurationChange(Enum):
"""LimitedConfigurationChange."""
DISABLED = 0
r"""This is the normal mode of RFmx operation. All configuration changes in RFmxInstr attributes or in personality
attributes will be applied during RFmx Commit."""
NO_CHANGE = 1
r"""Signal configuration is locked after the first Commit of the named signal configuration. Any configuration change
thereafter either in RFmxInstr attributes or personality attributes will not be considered by subsequent RFmx Commits
or Initiates of this signal. Use **No Change** if you have created named signal configurations for all measurement
configurations but are setting some RFmxInstr attributes. Refer to the Limitations of the Limited Configuration Change
Property topic for more details about the limitations of using this mode."""
FREQUENCY = 2
r"""Signal configuration, other than center frequency and external attenuation, is locked after first Commit of the named
signal configuration. Thereafter, only the :py:attr:`~nirfmxtdscdma.attributes.AttributeID.CENTER_FREQUENCY` and
:py:attr:`~nirfmxtdscdma.attributes.AttributeID.EXTERNAL_ATTENUATION` attribute value changes will be considered by
subsequent driver Commits or Initiates of this signal. Refer to the Limitations of the Limited Configuration Change
Property topic for more details about the limitations of using this mode."""
REFERENCE_LEVEL = 3
r"""Signal configuration, other than the reference level, is locked after first Commit of the named signal configuration.
Thereafter only the :py:attr:`~nirfmxtdscdma.attributes.AttributeID.REFERENCE_LEVEL` attribute value change will be
considered by subsequent driver Commits or Initiates of this signal. If you have configured this signal to use an IQ
Power Edge Trigger, NI recommends that you set the
:py:attr:`~nirfmxtdscdma.attributes.AttributeID.IQ_POWER_EDGE_TRIGGER_LEVEL_TYPE` to **Relative** so that the trigger
level is automatically adjusted as you adjust the reference level. Refer to the Limitations of the Limited
Configuration Change Property topic for more details about the limitations of using this mode."""
FREQUENCY_AND_REFERENCE_LEVEL = 4
r"""Signal configuration, other than center frequency, reference level, and external attenuation, is locked after first
Commit of the named signal configuration. Thereafter only Center Frequency, Reference Level, and External Attenuation
attribute value changes will be considered by subsequent driver Commits or Initiates of this signal. If you have
configured this signal to use an IQ Power Edge Trigger, NI recommends you set the IQ Power Edge Level Type to
**Relative** so that the trigger level is automatically adjusted as you adjust the reference level. Refer to the
Limitations of the Limited Configuration Change Property topic for more details about the limitations of using this
mode."""
SELECTED_PORTS_FREQUENCY_AND_REFERENCE_LEVEL = 5
r"""Signal configuration, other than selected ports, center frequency, reference level, external attenuation, and RFInstr
configuration, is locked after first Commit or Initiate of the named signal configuration. Thereafter only Selected
Ports, Center Frequency, Reference Level, and External Attenuation attribute value changes will be considered by
subsequent driver Commits or Initiates of this signal. If you have configured this signal to use an IQ Power Edge
Trigger, NI recommends you set the IQ Power Edge Level Type to **Relative** so that the trigger level is automatically
adjusted as you adjust the reference level. Refer to the Limitations of the Limited Configuration Change Property topic
for more details about the limitations of using this mode."""
[docs]
class MeasurementTypes(IntFlag):
"""MeasurementTypes."""
MODACC = 1 << 0
r"""Selects MODACC measurement."""
ACP = 1 << 1
r"""Selects ACP measurement."""
CHP = 1 << 2
r"""Selects CHP measurement."""
OBW = 1 << 3
r"""Selects OBW measurement."""
SEM = 1 << 4
r"""Selects SEM measurement."""
CDA = 1 << 5
r"""Selects CDA measurement."""
PVT = 1 << 6
r"""Selects PVT measurement."""
SLOTPOWER = 1 << 7
r"""Selects SLOTPOWER measurement."""