"""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:`~nirfmxcdma2k.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 slope (rising or falling),
which is configured using the :py:attr:`~nirfmxcdma2k.attributes.AttributeID.IQ_POWER_EDGE_TRIGGER_SOURCE` attribute."""
SOFTWARE = 3
r"""The Reference 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:`~nirfmxcdma2k.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:`~nirfmxcdma2k.attributes.AttributeID.TRIGGER_MINIMUM_QUIET_TIME_DURATION` attribute."""
AUTO = 1
r"""The measurement computes the minimum quiet time used for triggering."""
[docs]
class LinkDirection(Enum):
"""LinkDirection."""
DOWNLINK = 0
r"""CDMA2k measurement uses 3GPP CDMA2k forward link direction also known as downlink direction to measure the received
signal."""
UPLINK = 1
r"""CDMA2k measurement uses 3GPP CDMA2k reverse link direction also known as uplink direction to measure the received
signal."""
[docs]
class RadioConfiguration(Enum):
"""RadioConfiguration."""
RC1 = 0
r"""If :py:attr:`~nirfmxcdma2k.attributes.AttributeID.LINK_DIRECTION` attribute is set to **Uplink**, Radio configuration 1
includes 64-ary orthogonal modulation, reverse fundamental channel (R-FCH), and reverse supplemental code channels
(R-SCCHs).
If Link Direction attribute is set to **Downlink**, Radio Configuration 1 includes binary phase-shift keying
(BPSK), forward fundamental channels (F-FCHs) and forward supplemental channels (F-SCHs)."""
RC2 = 1
r"""If Link Direction attribute is set to **Uplink**, Radio configuration 2 includes 64-ary orthogonal modulation, R-FCH,
and R-SCCHs.
If Link Direction attribute is set to **Downlink**, Radio Configuration 2 includes BPSKs, F-FCHs and F-SCHs."""
RC3 = 2
r"""If Link Direction attribute is set to **Uplink**, Radio configuration 3 includes BPSK, R-FCH, and reverse supplemental
channels (R-SCHs).
If Link Direction attribute is set to **Downlink**, Radio Configuration 3 includes quadrature phase-shift
keying (QPSK), F-FCHs and F-SCHs."""
RC4 = 3
r"""If Link Direction attribute is set to **Uplink**, Radio configuration 4 includes BPSK, R-FCH, and R-SCHs.
If Link Direction attribute is set to **Downlink**, Radio Configuration 4 includes QPSK, F-FCHs and F-SCHs."""
RC5 = 4
r"""If Link Direction attribute is set to **Uplink**, Radio configuration 5 is not supported and gives invalid results.
If Link Direction attribute is set to **Downlink**, Radio Configuration 5 includes QPSK, F-FCHs and F-SCHs."""
[docs]
class ChannelConfigurationMode(Enum):
"""ChannelConfigurationMode."""
AUTO_DETECT = 0
r"""Specifies that the system automatically detects the channels."""
USER_DEFINED = 1
r"""Specifies that the system uses a specific channel configuration."""
[docs]
class Branch(Enum):
"""Branch."""
I = 0
r"""Specifies the in-phase branch."""
Q = 1
r"""Specifies the quadrature branch."""
I_AND_Q = 2
r"""Specifies the in-phase and quadrature branch."""
[docs]
class ModAccSynchronizationMode(Enum):
"""ModAccSynchronizationMode."""
FRAME = 0
r"""The frame boundary is detected, and the measurement is performed over the
:py:attr:`~nirfmxcdma2k.attributes.AttributeID.MODACC_MEASUREMENT_LENGTH` attribute starting at the
:py:attr:`~nirfmxcdma2k.attributes.AttributeID.MODACC_MEASUREMENT_OFFSET` attribute from the frame boundary."""
SLOT = 1
r"""The slot boundary is detected, and the measurement is performed over the ModAcc Meas Length attribute starting at the
ModAcc Meas Offset attribute from the slot boundary."""
ARBITRARY = 2
r"""The symbol boundary is detected, and the measurement is performed over the ModAcc Meas Length attribute starting at the
ModAcc Meas Offset attribute from the slot boundary."""
[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"""I/Q offset is not removed before the EVM measurement."""
TRUE = 1
r"""I/Q offset is removed before the EVM measurement."""
[docs]
class ModAccIQGainImbalanceRemovalEnabled(Enum):
"""ModAccIQGainImbalanceRemovalEnabled."""
FALSE = 0
r"""I/Q gain imbalance is not removed before the EVM measurement."""
TRUE = 1
r"""I/Q gain imbalance is removed before the EVM measurement."""
[docs]
class ModAccIQQuadratureErrorRemovalEnabled(Enum):
"""ModAccIQQuadratureErrorRemovalEnabled."""
FALSE = 0
r"""I/Q quadrature error is not removed before the EVM measurement."""
TRUE = 1
r"""I/Q quadrature error is removed before the EVM measurement."""
[docs]
class ModAccReceiveFilterEnabled(Enum):
"""ModAccReceiveFilterEnabled."""
FALSE = 0
r"""Disables received filtering for the ModAcc measurement."""
TRUE = 1
r"""Enables received filtering for the ModAcc measurement."""
[docs]
class ModAccMultiCarrierFilterEnabled(Enum):
"""ModAccMultiCarrierFilterEnabled."""
FALSE = 0
r"""Disables multi carrier filter for ModAcc measurement."""
TRUE = 1
r"""Enables multi carrier filter for ModAcc measurement."""
[docs]
class ModAccPeakCdeBranch(Enum):
"""ModAccPeakCdeBranch."""
I = 0
r"""The signal is modulated on the in-phase branch."""
Q = 1
r"""The signal is modulated on the quadrature branch."""
I_AND_Q = 2
r"""Complex modulated signal."""
[docs]
class ModAccPeakActiveCdeBranch(Enum):
"""ModAccPeakActiveCdeBranch."""
I = 0
r"""The signal is modulated on the in-phase branch."""
Q = 1
r"""The signal is modulated on the quadrature branch."""
I_AND_Q = 2
r"""Complex modulated signal."""
[docs]
class ModAccDetectedBranch(Enum):
"""ModAccDetectedBranch."""
I = 0
r"""The signal modulated on the in-phase branch."""
Q = 1
r"""The signal modulated on the quadrature branch."""
I_AND_Q = 2
r"""The signal modulated on the in-phase branch and quadrature branch."""
[docs]
class AcpRbwAutoBandwidth(Enum):
"""AcpRbwAutoBandwidth."""
FALSE = 0
r"""The measurement uses the RBW that you specify in the
:py:attr:`~nirfmxcdma2k.attributes.AttributeID.ACP_RBW_FILTER_BANDWIDTH` attribute."""
TRUE = 1
r"""The measurement computes the RBW."""
[docs]
class AcpRbwFilterType(Enum):
"""AcpRbwFilterType."""
FFT_BASED = 0
r"""An RBW filter with an 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:`~nirfmxcdma2k.attributes.AttributeID.ACP_SWEEP_TIME_INTERVAL` attribute."""
TRUE = 1
r"""The measurement uses the default sweep time of 0.001667 seconds."""
[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 measurement speed is desirable over 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 the samples specified by the
:py:attr:`~nirfmxcdma2k.attributes.AttributeID.ACP_SWEEP_TIME_INTERVAL`. These samples are divided into smaller chunks.
The size of each chunk is defined by the :py:attr:`~nirfmxcdma2k.attributes.AttributeID.ACP_SEQUENTIAL_FFT_SIZE`
attribute,
and FFT is computed for each these chunks. The resultant FFTs are averaged to get the spectrum used to
compute the ACP.
If the total acquired samples is not an integer multiple of the FFT size, the remaining samples at the end of
the acquisition are not used.
Use this method to optimize the ACP Measurement speed. The accuracy of 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 Measurement Method attribute to **Sequential
FFT**.
+--------------------------------------------------------------------------------+------------------+
| Properties | Supported Values |
+================================================================================+==================+
| :py:attr:`~nirfmxcdma2k.attributes.AttributeID.ACP_RBW_FILTER_AUTO_BANDWIDTH` | True |
+--------------------------------------------------------------------------------+------------------+
| :py:attr:`~nirfmxcdma2k.attributes.AttributeID.ACP_RBW_FILTER_TYPE` | FFT Based |
+--------------------------------------------------------------------------------+------------------+
| :py:attr:`~nirfmxcdma2k.attributes.AttributeID.ACP_AVERAGING_COUNT` | >=1 |
+--------------------------------------------------------------------------------+------------------+
| :py:attr:`~nirfmxcdma2k.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 noise floor of the signal analyzer."""
TRUE = 1
r"""Enables compensation of the channel powers for the noise floor of the signal analyzer. 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 measured again.
**Supported Devices:** PXIe-5663/5665/5668R, PXIe-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:`~nirfmxcdma2k.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 in 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 no overlapping is applied to the acquired samples."""
AUTOMATIC = 1
r"""Indicates that RFmx chooses optimal values of the :py:attr:`~nirfmxcdma2k.attributes.AttributeID.ACP_FFT_OVERLAP`
attribute based on the measurement configuration."""
[docs]
class AcpIFOutputPowerOffsetAuto(Enum):
"""AcpIFOutputPowerOffsetAuto."""
FALSE = 0
r"""The measurement does not compute an IF output power level offset for the offset channels."""
TRUE = 1
r"""The measurement computes an IF output power level offset for the offset channels."""
[docs]
class ChpRbwAutoBandwidth(Enum):
"""ChpRbwAutoBandwidth."""
FALSE = 0
r"""The measurement uses the RBW that you specify in the
:py:attr:`~nirfmxcdma2k.attributes.AttributeID.CHP_RBW_FILTER_BANDWIDTH` attribute."""
TRUE = 1
r"""The measurement computes the RBW."""
[docs]
class ChpRbwFilterType(Enum):
"""ChpRbwFilterType."""
FFT_BASED = 0
r"""No RBW filtering is performed."""
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 that you specify in the
:py:attr:`~nirfmxcdma2k.attributes.AttributeID.CHP_SWEEP_TIME_INTERVAL` attribute."""
TRUE = 1
r"""The measurement uses the default sweep time of 0.001667 seconds."""
[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:`~nirfmxcdma2k.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:`~nirfmxcdma2k.attributes.AttributeID.OBW_RBW_FILTER_BANDWIDTH` attribute."""
TRUE = 1
r"""The measurement computes the RBW."""
[docs]
class ObwRbwFilterType(Enum):
"""ObwRbwFilterType."""
FFT_BASED = 0
r"""No RBW filtering is performed."""
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:`~nirfmxcdma2k.attributes.AttributeID.OBW_SWEEP_TIME_INTERVAL` attribute."""
TRUE = 1
r"""The measurement uses the default sweep time of 0.001667 seconds."""
[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:`~nirfmxcdma2k.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 in 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:`~nirfmxcdma2k.attributes.AttributeID.SEM_SWEEP_TIME_INTERVAL` attribute."""
TRUE = 1
r"""The measurement uses the default sweep time, 0.001667 seconds."""
[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:`~nirfmxcdma2k.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 in 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 least 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 fails according to the measurement limits specified by this standard."""
PASS = 1
r"""The measurement passes according to the measurement limits specified by this standard."""
[docs]
class SemLowerOffsetMeasurementStatus(Enum):
"""SemLowerOffsetMeasurementStatus."""
FAIL = 0
r"""The lower offset segment measurement fails according to the measurement limits specified by the standard."""
PASS = 1
r"""The lower offset segment measurement passes according to the measurement limits specified by the standard."""
[docs]
class SemUpperOffsetMeasurementStatus(Enum):
"""SemUpperOffsetMeasurementStatus."""
FAIL = 0
r"""The lower offset segment measurement fails according to the measurement limits specified by this standard."""
PASS = 1
r"""The lower offset segment measurement passes according to the measurement limits specified by this standard."""
[docs]
class QevmAveragingEnabled(Enum):
"""QevmAveragingEnabled."""
FALSE = 0
r"""The averaging is disabled for the measurement."""
TRUE = 1
r"""The averaging is enabled for the measurement."""
[docs]
class QevmSpectrumInverted(Enum):
"""QevmSpectrumInverted."""
FALSE = 0
r"""The measurement spectrum is normal."""
TRUE = 1
r"""The measurement spectrum is inverted."""
[docs]
class QevmIQOffsetRemovalEnabled(Enum):
"""QevmIQOffsetRemovalEnabled."""
FALSE = 0
r"""I/Q offset is not removed before the QEVM measurement."""
TRUE = 1
r"""I/Q offset is removed before the QEVM measurement."""
[docs]
class QevmIQGainImbalanceRemovalEnabled(Enum):
"""QevmIQGainImbalanceRemovalEnabled."""
FALSE = 0
r"""I/Q gain imbalance is not removed before the QEVM measurement."""
TRUE = 1
r"""I/Q gain imbalance is removed before the QEVM measurement."""
[docs]
class QevmIQQuadratureErrorRemovalEnabled(Enum):
"""QevmIQQuadratureErrorRemovalEnabled."""
FALSE = 0
r"""I/Q quadrature error is not removed before the QEVM measurement."""
TRUE = 1
r"""I/Q quadrature error is removed before the QEVM measurement."""
[docs]
class QevmReceiveFilterEnabled(Enum):
"""QevmReceiveFilterEnabled."""
FALSE = 0
r"""Disables received filtering for the QEVM measurement."""
TRUE = 1
r"""Enables received filtering for the QEVM measurement."""
[docs]
class CdaSynchronizationMode(Enum):
"""CdaSynchronizationMode."""
FRAME = 0
r"""The frame boundary is detected, and the measurement is performed over the number of slots specified by the
:py:attr:`~nirfmxcdma2k.attributes.AttributeID.CDA_MEASUREMENT_LENGTH` attribute starting at the CDA measurement offset
slots from the frame boundary."""
SLOT = 1
r"""The slot boundary is detected, and the measurement is performed over the number of slots specified by the CDA Meas
Length attribute starting at the CDA measurement offset slots from the slot boundary."""
ARBITRARY = 2
r"""The symbol boundary is detected, and the measurement is performed over the number of slots specified by the CDA Meas
Length attribute starting at the CDA measurement offset slots from the symbol boundary."""
[docs]
class CdaMeasurementChannelBranch(Enum):
"""CdaMeasurementChannelBranch."""
I = 0
r"""Specifies the in-phase branch."""
Q = 1
r"""Specifies the quadrature branch."""
[docs]
class CdaPowerUnit(Enum):
"""CdaPowerUnit."""
DB = 0
r"""The CDA measurement results are reported in dB."""
DBM = 1
r"""The CDA measurement results are reported in dBm."""
[docs]
class CdaSpectrumInverted(Enum):
"""CdaSpectrumInverted."""
FALSE = 0
r"""The measured spectrum is normal."""
TRUE = 1
r"""The measured spectrum is inverted."""
[docs]
class CdaIQOffsetRemovalEnabled(Enum):
"""CdaIQOffsetRemovalEnabled."""
FALSE = 0
r"""I/Q offset is not removed before the CDA measurement."""
TRUE = 1
r"""I/Q offset is removed before the CDA measurement."""
[docs]
class CdaIQGainImbalanceRemovalEnabled(Enum):
"""CdaIQGainImbalanceRemovalEnabled."""
FALSE = 0
r"""I/Q gain imbalance is not removed before the CDA measurement."""
TRUE = 1
r"""I/Q gain imbalance is removed before the CDA measurement."""
[docs]
class CdaIQQuadratureErrorRemovalEnabled(Enum):
"""CdaIQQuadratureErrorRemovalEnabled."""
FALSE = 0
r"""I/Q quadrature error is not removed before the CDA measurement."""
TRUE = 1
r"""I/Q quadrature error is removed before the CDA measurement."""
[docs]
class CdaReceiveFilterEnabled(Enum):
"""CdaReceiveFilterEnabled."""
FALSE = 0
r"""Disables receive filtering for the CDA measurement."""
TRUE = 1
r"""Enables receive filtering for the CDA measurement."""
[docs]
class SlotPowerSynchronizationMode(Enum):
"""SlotPowerSynchronizationMode."""
FRAME = 0
r"""The frame boundary is detected, and the measurement is performed over the number of slots specified by the
:py:attr:`~nirfmxcdma2k.attributes.AttributeID.SLOTPOWER_MEASUREMENT_LENGTH` attribute starting at the
:py:attr:`~nirfmxcdma2k.attributes.AttributeID.SLOTPOWER_MEASUREMENT_OFFSET` slots from the frame boundary."""
SLOT = 1
r"""The slot boundary is detected, and the measurement is performed over the number of slots specified by the SlotPower
Meas Length attribute starting at the SlotPower measurement offset slots from the slot boundary."""
[docs]
class SlotPowerSpectrumInverted(Enum):
"""SlotPowerSpectrumInverted."""
FALSE = 0
r"""The measurement spectrum is normal."""
TRUE = 1
r"""The measurement spectrum is inverted."""
[docs]
class SlotPowerReceiveFilterEnabled(Enum):
"""SlotPowerReceiveFilterEnabled."""
FALSE = 0
r"""Disables received filtering for the SlotPower measurement."""
TRUE = 1
r"""Enables received filtering for the SlotPower measurement."""
[docs]
class SlotPhaseSynchronizationMode(Enum):
"""SlotPhaseSynchronizationMode."""
FRAME = 0
r"""The frame boundary is detected, and the measurement is performed over the number of slots specified by the
:py:attr:`~nirfmxcdma2k.attributes.AttributeID.SLOTPHASE_MEASUREMENT_LENGTH` attribute starting at the
:py:attr:`~nirfmxcdma2k.attributes.AttributeID.SLOTPHASE_MEASUREMENT_LENGTH` slots from the frame boundary."""
SLOT = 1
r"""The slot boundary is detected, and the measurement is performed over the number of slots specified by the SlotPhase
Meas Length attribute starting at the SlotPhase measurement offset slots from the slot boundary."""
[docs]
class SlotPhaseSpectrumInverted(Enum):
"""SlotPhaseSpectrumInverted."""
FALSE = 0
r"""The measured spectrum is not inverted."""
TRUE = 1
r"""The measured spectrum is inverted."""
[docs]
class SlotPhaseReceiveFilterEnabled(Enum):
"""SlotPhaseReceiveFilterEnabled."""
FALSE = 0
r"""Disables received filtering for the SlotPhase measurement."""
TRUE = 1
r"""Enables received filtering for the SlotPhase 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:`~nirfmxcdma2k.attributes.AttributeID.CENTER_FREQUENCY` and
:py:attr:`~nirfmxcdma2k.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:`~nirfmxcdma2k.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:`~nirfmxcdma2k.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."""
QEVM = 1 << 5
r"""Selects QEVM measurement."""
CDA = 1 << 6
r"""Selects CDA measurement."""
SLOTPHASE = 1 << 7
r"""Selects SLOTPHASE measurement."""
SLOTPOWER = 1 << 8
r"""Selects SLOTPOWER measurement."""