striqt.sensor.bindings

A registry of data class <-> IQ acquisition control class bindings. These are taken to define sensors. Extension classes can implement peripherals and expanded data fields elsewhere.

—

class striqt.sensor.bindings.air7101b(*, master_clock_rate=125000000.0, trigger_strobe=None, signal_trigger=None, array_backend='cupy', calibration=None, time_source='host', time_sync_at='acquire', clock_source='internal', receive_retries=3, adc_overload_limit=-1, if_overload_limit=None, gapless=False)

Bases: Controller

Open and control the backend striqt.sensor.lib.sources.deepwave.Airstack1Source.

Parameters:

  • master_clock_rate (float): Base sample rate used inside the source (Constraints: > 0, units: Hz)

  • trigger_strobe (float | None):

  • signal_trigger (str | AnalysisGroup | None):

  • array_backend (one of [‘numpy’, ‘cupy’]): array module to use to set compute device: numpy = cpu, cupy = gpu

  • calibration (str | None):

  • time_source (one of [‘host’, ‘internal’, ‘external’, ‘gps’]): Hardware source for timestamps

  • time_sync_at (one of [‘open’, ‘acquire’]): when to sync the hardware clock: on connection, or before each capture

  • clock_source (one of [‘internal’, ‘external’, ‘gps’]): Hardware source for the frequency reference

  • receive_retries (int): number of acquisition retry attempts on stream error (Constraints: >= 0)

  • adc_overload_limit (float | None): dataset adc_overload=True when the peak ADC level exceeds this threshold (Constraints: <= 0, units: dBfs)

  • if_overload_limit (float | None): the maximum level at maximum gain before IF/baseband overload (Constraints: units: dBfs)

  • gapless (bool): whether to raise an exception on overflows between identical captures

arm(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis=<factory>, center_frequency, gain)
Parameters:

  • duration (float): Duration of the analysis waveform (Constraints: units: s)

  • sample_rate (float): Analysis sample rate (Constraints: units: S/s)

  • analysis_bandwidth (float): Analysis bandwidth (Constraints: units: Hz)

  • port (int | tuple[int, …]): Input port indices (Constraints: >= 0, >= 0)

  • lo_shift (one of [‘left’, ‘right’, ‘none’]): LO shift direction

  • host_resample (bool):

  • backend_sample_rate (float | None): Source sample rate (Constraints: > 0, units: Hz)

  • adjust_analysis (dict[str, Any]): changes to apply across each analysis for any matching parameter

  • center_frequency (float | tuple[float, …]): Center frequency for each port (Constraints: units: Hz, > 0, units: Hz, > 0, units: Hz)

  • gain (float | tuple[float, …]): Gain setting for each channel (Constraints: units: dB, units: dB, units: dB)

acquire(overlaps=None)

acquire IQ samples needed for the armed capture.

—

class striqt.sensor.bindings.air7101b_calibration(*, master_clock_rate=125000000.0, trigger_strobe=None, signal_trigger=None, array_backend='cupy', calibration=None, time_source='host', time_sync_at='acquire', clock_source='internal', receive_retries=3, adc_overload_limit=-1, if_overload_limit=None, gapless=False)

Bases: Controller

Open and control the backend striqt.sensor.lib.sources.deepwave.Airstack1Source.

Parameters:

  • master_clock_rate (float): Base sample rate used inside the source (Constraints: > 0, units: Hz)

  • trigger_strobe (float | None):

  • signal_trigger (str | AnalysisGroup | None):

  • array_backend (one of [‘numpy’, ‘cupy’]): array module to use to set compute device: numpy = cpu, cupy = gpu

  • calibration (str | None):

  • time_source (one of [‘host’, ‘internal’, ‘external’, ‘gps’]): Hardware source for timestamps

  • time_sync_at (one of [‘open’, ‘acquire’]): when to sync the hardware clock: on connection, or before each capture

  • clock_source (one of [‘internal’, ‘external’, ‘gps’]): Hardware source for the frequency reference

  • receive_retries (int): number of acquisition retry attempts on stream error (Constraints: >= 0)

  • adc_overload_limit (float | None): dataset adc_overload=True when the peak ADC level exceeds this threshold (Constraints: <= 0, units: dBfs)

  • if_overload_limit (float | None): the maximum level at maximum gain before IF/baseband overload (Constraints: units: dBfs)

  • gapless (bool): whether to raise an exception on overflows between identical captures

arm(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis=<factory>, center_frequency, gain, noise_diode_enabled=False)
Parameters:

  • duration (float): Duration of the analysis waveform (Constraints: units: s)

  • sample_rate (float): Analysis sample rate (Constraints: units: S/s)

  • analysis_bandwidth (float): Analysis bandwidth (Constraints: units: Hz)

  • port (int | tuple[int, …]): Input port indices (Constraints: >= 0, >= 0)

  • lo_shift (one of [‘left’, ‘right’, ‘none’]): LO shift direction

  • host_resample (bool):

  • backend_sample_rate (float | None): Source sample rate (Constraints: > 0, units: Hz)

  • adjust_analysis (dict[str, Any]): changes to apply across each analysis for any matching parameter

  • center_frequency (float | tuple[float, …]): Center frequency for each port (Constraints: units: Hz, > 0, units: Hz, > 0, units: Hz)

  • gain (float | tuple[float, …]): Gain setting for each channel (Constraints: units: dB, units: dB, units: dB)

  • noise_diode_enabled (bool): Noise diode enabled

acquire(overlaps=None)

acquire IQ samples needed for the armed capture.

—

class striqt.sensor.bindings.air7201b(*, master_clock_rate=125000000.0, trigger_strobe=None, signal_trigger=None, array_backend='cupy', calibration=None, time_source='host', time_sync_at='acquire', clock_source='internal', receive_retries=3, adc_overload_limit=-1, if_overload_limit=None, gapless=False)

Bases: Controller

Open and control the backend striqt.sensor.lib.sources.deepwave.Airstack1Source.

Parameters:

  • master_clock_rate (float): Base sample rate used inside the source (Constraints: > 0, units: Hz)

  • trigger_strobe (float | None):

  • signal_trigger (str | AnalysisGroup | None):

  • array_backend (one of [‘numpy’, ‘cupy’]): array module to use to set compute device: numpy = cpu, cupy = gpu

  • calibration (str | None):

  • time_source (one of [‘host’, ‘internal’, ‘external’, ‘gps’]): Hardware source for timestamps

  • time_sync_at (one of [‘open’, ‘acquire’]): when to sync the hardware clock: on connection, or before each capture

  • clock_source (one of [‘internal’, ‘external’, ‘gps’]): Hardware source for the frequency reference

  • receive_retries (int): number of acquisition retry attempts on stream error (Constraints: >= 0)

  • adc_overload_limit (float | None): dataset adc_overload=True when the peak ADC level exceeds this threshold (Constraints: <= 0, units: dBfs)

  • if_overload_limit (float | None): the maximum level at maximum gain before IF/baseband overload (Constraints: units: dBfs)

  • gapless (bool): whether to raise an exception on overflows between identical captures

arm(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis=<factory>, center_frequency, gain)
Parameters:

  • duration (float): Duration of the analysis waveform (Constraints: units: s)

  • sample_rate (float): Analysis sample rate (Constraints: units: S/s)

  • analysis_bandwidth (float): Analysis bandwidth (Constraints: units: Hz)

  • port (int | tuple[int, …]): Input port indices (Constraints: >= 0, >= 0)

  • lo_shift (one of [‘left’, ‘right’, ‘none’]): LO shift direction

  • host_resample (bool):

  • backend_sample_rate (float | None): Source sample rate (Constraints: > 0, units: Hz)

  • adjust_analysis (dict[str, Any]): changes to apply across each analysis for any matching parameter

  • center_frequency (float | tuple[float, …]): Center frequency for each port (Constraints: units: Hz, > 0, units: Hz, > 0, units: Hz)

  • gain (float | tuple[float, …]): Gain setting for each channel (Constraints: units: dB, units: dB, units: dB)

acquire(overlaps=None)

acquire IQ samples needed for the armed capture.

—

class striqt.sensor.bindings.air7201b_calibration(*, master_clock_rate=125000000.0, trigger_strobe=None, signal_trigger=None, array_backend='cupy', calibration=None, time_source='host', time_sync_at='acquire', clock_source='internal', receive_retries=3, adc_overload_limit=-1, if_overload_limit=None, gapless=False)

Bases: Controller

Open and control the backend striqt.sensor.lib.sources.deepwave.Airstack1Source.

Parameters:

  • master_clock_rate (float): Base sample rate used inside the source (Constraints: > 0, units: Hz)

  • trigger_strobe (float | None):

  • signal_trigger (str | AnalysisGroup | None):

  • array_backend (one of [‘numpy’, ‘cupy’]): array module to use to set compute device: numpy = cpu, cupy = gpu

  • calibration (str | None):

  • time_source (one of [‘host’, ‘internal’, ‘external’, ‘gps’]): Hardware source for timestamps

  • time_sync_at (one of [‘open’, ‘acquire’]): when to sync the hardware clock: on connection, or before each capture

  • clock_source (one of [‘internal’, ‘external’, ‘gps’]): Hardware source for the frequency reference

  • receive_retries (int): number of acquisition retry attempts on stream error (Constraints: >= 0)

  • adc_overload_limit (float | None): dataset adc_overload=True when the peak ADC level exceeds this threshold (Constraints: <= 0, units: dBfs)

  • if_overload_limit (float | None): the maximum level at maximum gain before IF/baseband overload (Constraints: units: dBfs)

  • gapless (bool): whether to raise an exception on overflows between identical captures

arm(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis=<factory>, center_frequency, gain, noise_diode_enabled=False)
Parameters:

  • duration (float): Duration of the analysis waveform (Constraints: units: s)

  • sample_rate (float): Analysis sample rate (Constraints: units: S/s)

  • analysis_bandwidth (float): Analysis bandwidth (Constraints: units: Hz)

  • port (int | tuple[int, …]): Input port indices (Constraints: >= 0, >= 0)

  • lo_shift (one of [‘left’, ‘right’, ‘none’]): LO shift direction

  • host_resample (bool):

  • backend_sample_rate (float | None): Source sample rate (Constraints: > 0, units: Hz)

  • adjust_analysis (dict[str, Any]): changes to apply across each analysis for any matching parameter

  • center_frequency (float | tuple[float, …]): Center frequency for each port (Constraints: units: Hz, > 0, units: Hz, > 0, units: Hz)

  • gain (float | tuple[float, …]): Gain setting for each channel (Constraints: units: dB, units: dB, units: dB)

  • noise_diode_enabled (bool): Noise diode enabled

acquire(overlaps=None)

acquire IQ samples needed for the armed capture.

—

class striqt.sensor.bindings.air8201b(*, master_clock_rate=125000000.0, trigger_strobe=None, signal_trigger=None, array_backend='cupy', calibration=None, time_source='host', time_sync_at='acquire', clock_source='internal', receive_retries=3, adc_overload_limit=-1, if_overload_limit=None, gapless=False)

Bases: Controller

Open and control the backend striqt.sensor.lib.sources.deepwave.Airstack1Source.

Parameters:

  • master_clock_rate (float): Base sample rate used inside the source (Constraints: > 0, units: Hz)

  • trigger_strobe (float | None):

  • signal_trigger (str | AnalysisGroup | None):

  • array_backend (one of [‘numpy’, ‘cupy’]): array module to use to set compute device: numpy = cpu, cupy = gpu

  • calibration (str | None):

  • time_source (one of [‘host’, ‘internal’, ‘external’, ‘gps’]): Hardware source for timestamps

  • time_sync_at (one of [‘open’, ‘acquire’]): when to sync the hardware clock: on connection, or before each capture

  • clock_source (one of [‘internal’, ‘external’, ‘gps’]): Hardware source for the frequency reference

  • receive_retries (int): number of acquisition retry attempts on stream error (Constraints: >= 0)

  • adc_overload_limit (float | None): dataset adc_overload=True when the peak ADC level exceeds this threshold (Constraints: <= 0, units: dBfs)

  • if_overload_limit (float | None): the maximum level at maximum gain before IF/baseband overload (Constraints: units: dBfs)

  • gapless (bool): whether to raise an exception on overflows between identical captures

arm(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis=<factory>, center_frequency, gain)
Parameters:

  • duration (float): Duration of the analysis waveform (Constraints: units: s)

  • sample_rate (float): Analysis sample rate (Constraints: units: S/s)

  • analysis_bandwidth (float): Analysis bandwidth (Constraints: units: Hz)

  • port (int | tuple[int, …]): Input port indices (Constraints: >= 0, >= 0)

  • lo_shift (one of [‘left’, ‘right’, ‘none’]): LO shift direction

  • host_resample (bool):

  • backend_sample_rate (float | None): Source sample rate (Constraints: > 0, units: Hz)

  • adjust_analysis (dict[str, Any]): changes to apply across each analysis for any matching parameter

  • center_frequency (float | tuple[float, …]): Center frequency for each port (Constraints: units: Hz, > 0, units: Hz, > 0, units: Hz)

  • gain (float | tuple[float, …]): Gain setting for each channel (Constraints: units: dB, units: dB, units: dB)

acquire(overlaps=None)

acquire IQ samples needed for the armed capture.

—

class striqt.sensor.bindings.air8201b_calibration(*, master_clock_rate=125000000.0, trigger_strobe=None, signal_trigger=None, array_backend='cupy', calibration=None, time_source='host', time_sync_at='acquire', clock_source='internal', receive_retries=3, adc_overload_limit=-1, if_overload_limit=None, gapless=False)

Bases: Controller

Open and control the backend striqt.sensor.lib.sources.deepwave.Airstack1Source.

Parameters:

  • master_clock_rate (float): Base sample rate used inside the source (Constraints: > 0, units: Hz)

  • trigger_strobe (float | None):

  • signal_trigger (str | AnalysisGroup | None):

  • array_backend (one of [‘numpy’, ‘cupy’]): array module to use to set compute device: numpy = cpu, cupy = gpu

  • calibration (str | None):

  • time_source (one of [‘host’, ‘internal’, ‘external’, ‘gps’]): Hardware source for timestamps

  • time_sync_at (one of [‘open’, ‘acquire’]): when to sync the hardware clock: on connection, or before each capture

  • clock_source (one of [‘internal’, ‘external’, ‘gps’]): Hardware source for the frequency reference

  • receive_retries (int): number of acquisition retry attempts on stream error (Constraints: >= 0)

  • adc_overload_limit (float | None): dataset adc_overload=True when the peak ADC level exceeds this threshold (Constraints: <= 0, units: dBfs)

  • if_overload_limit (float | None): the maximum level at maximum gain before IF/baseband overload (Constraints: units: dBfs)

  • gapless (bool): whether to raise an exception on overflows between identical captures

arm(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis=<factory>, center_frequency, gain, noise_diode_enabled=False)
Parameters:

  • duration (float): Duration of the analysis waveform (Constraints: units: s)

  • sample_rate (float): Analysis sample rate (Constraints: units: S/s)

  • analysis_bandwidth (float): Analysis bandwidth (Constraints: units: Hz)

  • port (int | tuple[int, …]): Input port indices (Constraints: >= 0, >= 0)

  • lo_shift (one of [‘left’, ‘right’, ‘none’]): LO shift direction

  • host_resample (bool):

  • backend_sample_rate (float | None): Source sample rate (Constraints: > 0, units: Hz)

  • adjust_analysis (dict[str, Any]): changes to apply across each analysis for any matching parameter

  • center_frequency (float | tuple[float, …]): Center frequency for each port (Constraints: units: Hz, > 0, units: Hz, > 0, units: Hz)

  • gain (float | tuple[float, …]): Gain setting for each channel (Constraints: units: dB, units: dB, units: dB)

  • noise_diode_enabled (bool): Noise diode enabled

acquire(overlaps=None)

acquire IQ samples needed for the armed capture.

—

class striqt.sensor.bindings.dirac_delta(*, master_clock_rate, trigger_strobe=None, signal_trigger=None, array_backend='numpy', num_rx_ports)

Bases: Controller

Open and control the backend striqt.sensor.lib.sources.function.DiracDeltaSource.

Parameters:

  • master_clock_rate (float): Base sample rate used inside the source (Constraints: > 0, units: Hz)

  • trigger_strobe (float | None):

  • signal_trigger (str | AnalysisGroup | None):

  • array_backend (one of [‘numpy’, ‘cupy’]): array module to use to set compute device: numpy = cpu, cupy = gpu

  • num_rx_ports (int):

arm(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis=<factory>, time=0, power=0)
Parameters:

  • duration (float): Duration of the analysis waveform (Constraints: units: s)

  • sample_rate (float): Analysis sample rate (Constraints: units: S/s)

  • analysis_bandwidth (float): Analysis bandwidth (Constraints: units: Hz)

  • port (int | tuple[int, …]): Input port indices (Constraints: >= 0, >= 0)

  • lo_shift (one of [‘left’, ‘right’, ‘none’]): LO shift direction

  • host_resample (bool):

  • backend_sample_rate (float | None): Source sample rate (Constraints: > 0, units: Hz)

  • adjust_analysis (dict[str, Any]): changes to apply across each analysis for any matching parameter

  • time (float): start time offset (Constraints: units: s)

  • power (float): peak power level (Constraints: units: dB)

acquire(overlaps=None)

acquire IQ samples needed for the armed capture.

—

class striqt.sensor.bindings.mat_file(*, master_clock_rate, trigger_strobe=None, signal_trigger=None, array_backend='numpy', path, file_format='auto', file_metadata=None, loop=False)

Bases: Controller

Open and control the backend striqt.sensor.lib.sources.file.MATSource.

returns IQ waveforms from a .mat file

Parameters:

  • master_clock_rate (float): Base sample rate used inside the source (Constraints: > 0, units: Hz)

  • trigger_strobe (float | None):

  • signal_trigger (str | AnalysisGroup | None):

  • array_backend (one of [‘numpy’, ‘cupy’]): array module to use to set compute device: numpy = cpu, cupy = gpu

  • path (str): path to the waveform data file

  • file_format (one of [‘auto’, ‘mat’, ‘tdms’]): data format or auto to guess by extension

  • file_metadata (dict[str, Any] | None): any capture fields not included in the file

  • loop (bool): whether to loop the file to create longer IQ waveforms

arm(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis=<factory>)
Parameters:

  • duration (float): Duration of the analysis waveform (Constraints: units: s)

  • sample_rate (float): Analysis sample rate (Constraints: units: S/s)

  • analysis_bandwidth (float): Analysis bandwidth (Constraints: units: Hz)

  • port (int | tuple[int, …]): Input port indices (Constraints: >= 0, >= 0)

  • lo_shift (one of [‘left’, ‘right’, ‘none’]): LO shift direction

  • host_resample (bool):

  • backend_sample_rate (float | None): Source sample rate (Constraints: > 0, units: Hz)

  • adjust_analysis (dict[str, Any]): changes to apply across each analysis for any matching parameter

acquire(overlaps=None)

acquire IQ samples needed for the armed capture.

—

class striqt.sensor.bindings.noise(*, master_clock_rate, trigger_strobe=None, signal_trigger=None, array_backend='numpy', num_rx_ports)

Bases: Controller

Open and control the backend striqt.sensor.lib.sources.function.NoiseSource.

Parameters:

  • master_clock_rate (float): Base sample rate used inside the source (Constraints: > 0, units: Hz)

  • trigger_strobe (float | None):

  • signal_trigger (str | AnalysisGroup | None):

  • array_backend (one of [‘numpy’, ‘cupy’]): array module to use to set compute device: numpy = cpu, cupy = gpu

  • num_rx_ports (int):

arm(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis=<factory>, noise_psd=1e-17)
Parameters:

  • duration (float): Duration of the analysis waveform (Constraints: units: s)

  • sample_rate (float): Analysis sample rate (Constraints: units: S/s)

  • analysis_bandwidth (float): Analysis bandwidth (Constraints: units: Hz)

  • port (int | tuple[int, …]): Input port indices (Constraints: >= 0, >= 0)

  • lo_shift (one of [‘left’, ‘right’, ‘none’]): LO shift direction

  • host_resample (bool):

  • backend_sample_rate (float | None): Source sample rate (Constraints: > 0, units: Hz)

  • adjust_analysis (dict[str, Any]): changes to apply across each analysis for any matching parameter

  • noise_psd (float): noise total channel power (Constraints: >= 0, units: mW/Hz)

acquire(overlaps=None)

acquire IQ samples needed for the armed capture.

—

class striqt.sensor.bindings.sawtooth(*, master_clock_rate, trigger_strobe=None, signal_trigger=None, array_backend='numpy', num_rx_ports)

Bases: Controller

Open and control the backend striqt.sensor.lib.sources.function.SawtoothSource.

Parameters:

  • master_clock_rate (float): Base sample rate used inside the source (Constraints: > 0, units: Hz)

  • trigger_strobe (float | None):

  • signal_trigger (str | AnalysisGroup | None):

  • array_backend (one of [‘numpy’, ‘cupy’]): array module to use to set compute device: numpy = cpu, cupy = gpu

  • num_rx_ports (int):

arm(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis=<factory>, period=0.01, power=0)
Parameters:

  • duration (float): Duration of the analysis waveform (Constraints: units: s)

  • sample_rate (float): Analysis sample rate (Constraints: units: S/s)

  • analysis_bandwidth (float): Analysis bandwidth (Constraints: units: Hz)

  • port (int | tuple[int, …]): Input port indices (Constraints: >= 0, >= 0)

  • lo_shift (one of [‘left’, ‘right’, ‘none’]): LO shift direction

  • host_resample (bool):

  • backend_sample_rate (float | None): Source sample rate (Constraints: > 0, units: Hz)

  • adjust_analysis (dict[str, Any]): changes to apply across each analysis for any matching parameter

  • period (float): waveform period (Constraints: >= 0, units: s)

  • power (float): peak power level (Constraints: units: dB)

acquire(overlaps=None)

acquire IQ samples needed for the armed capture.

—

class striqt.sensor.bindings.single_tone(*, master_clock_rate, trigger_strobe=None, signal_trigger=None, array_backend='numpy', num_rx_ports)

Bases: Controller

Open and control the backend striqt.sensor.lib.sources.function.SingleToneSource.

Parameters:

  • master_clock_rate (float): Base sample rate used inside the source (Constraints: > 0, units: Hz)

  • trigger_strobe (float | None):

  • signal_trigger (str | AnalysisGroup | None):

  • array_backend (one of [‘numpy’, ‘cupy’]): array module to use to set compute device: numpy = cpu, cupy = gpu

  • num_rx_ports (int):

arm(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis=<factory>, frequency_offset=0, snr=None)
Parameters:

  • duration (float): Duration of the analysis waveform (Constraints: units: s)

  • sample_rate (float): Analysis sample rate (Constraints: units: S/s)

  • analysis_bandwidth (float): Analysis bandwidth (Constraints: units: Hz)

  • port (int | tuple[int, …]): Input port indices (Constraints: >= 0, >= 0)

  • lo_shift (one of [‘left’, ‘right’, ‘none’]): LO shift direction

  • host_resample (bool):

  • backend_sample_rate (float | None): Source sample rate (Constraints: > 0, units: Hz)

  • adjust_analysis (dict[str, Any]): changes to apply across each analysis for any matching parameter

  • frequency_offset (float): Baseband frequency offset (Constraints: units: Hz)

  • snr (float | None): Add circular white gaussian noise to achieve this SNR (Constraints: units: dB)

acquire(overlaps=None)

acquire IQ samples needed for the armed capture.

—

class striqt.sensor.bindings.tdms_file(*, master_clock_rate, trigger_strobe=None, signal_trigger=None, array_backend='numpy', path)

Bases: Controller

Open and control the backend striqt.sensor.lib.sources.file.TDMSSource.

a source of IQ waveforms from a TDMS file

Parameters:

  • master_clock_rate (float): Base sample rate used inside the source (Constraints: > 0, units: Hz)

  • trigger_strobe (float | None):

  • signal_trigger (str | AnalysisGroup | None):

  • array_backend (one of [‘numpy’, ‘cupy’]): array module to use to set compute device: numpy = cpu, cupy = gpu

  • path (str): path to the waveform data file

arm(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis=<factory>)
Parameters:

  • duration (float): Duration of the analysis waveform (Constraints: units: s)

  • sample_rate (float): Analysis sample rate (Constraints: units: S/s)

  • analysis_bandwidth (float): Analysis bandwidth (Constraints: units: Hz)

  • port (int | tuple[int, …]): Input port indices (Constraints: >= 0, >= 0)

  • lo_shift (one of [‘left’, ‘right’, ‘none’]): LO shift direction

  • host_resample (bool):

  • backend_sample_rate (float | None): Source sample rate (Constraints: > 0, units: Hz)

  • adjust_analysis (dict[str, Any]): changes to apply across each analysis for any matching parameter

acquire(overlaps=None)

acquire IQ samples needed for the armed capture.

—

class striqt.sensor.bindings.warmup(*, master_clock_rate, trigger_strobe=None, signal_trigger=None, array_backend='numpy', num_rx_ports)

Bases: Controller

Open and control the backend striqt.sensor.lib.sources.base.NoSource.

fast paths to acquire empty buffers

Parameters:

  • master_clock_rate (float): Base sample rate used inside the source (Constraints: > 0, units: Hz)

  • trigger_strobe (float | None):

  • signal_trigger (str | AnalysisGroup | None):

  • array_backend (one of [‘numpy’, ‘cupy’]): array module to use to set compute device: numpy = cpu, cupy = gpu

  • num_rx_ports (int):

arm(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis=<factory>)
Parameters:

  • duration (float): Duration of the analysis waveform (Constraints: units: s)

  • sample_rate (float): Analysis sample rate (Constraints: units: S/s)

  • analysis_bandwidth (float): Analysis bandwidth (Constraints: units: Hz)

  • port (int | tuple[int, …]): Input port indices (Constraints: >= 0, >= 0)

  • lo_shift (one of [‘left’, ‘right’, ‘none’]): LO shift direction

  • host_resample (bool):

  • backend_sample_rate (float | None): Source sample rate (Constraints: > 0, units: Hz)

  • adjust_analysis (dict[str, Any]): changes to apply across each analysis for any matching parameter

acquire(overlaps=None)

acquire IQ samples needed for the armed capture.

—

class striqt.sensor.bindings.zarr_iq(*, master_clock_rate, trigger_strobe=None, signal_trigger=None, array_backend='numpy', path, center_frequency, select=<factory>)

Bases: Controller

Open and control the backend striqt.sensor.lib.sources.file.ZarrIQSource.

a sources of IQ samples from iq_waveform variables in a zarr store

Parameters:

  • master_clock_rate (float): Base sample rate used inside the source (Constraints: > 0, units: Hz)

  • trigger_strobe (float | None):

  • signal_trigger (str | AnalysisGroup | None):

  • array_backend (one of [‘numpy’, ‘cupy’]): array module to use to set compute device: numpy = cpu, cupy = gpu

  • path (str): path to the waveform data file

  • center_frequency (float | tuple[float, …]): Center frequency for each port (Constraints: units: Hz, > 0, units: Hz, > 0, units: Hz)

  • select (dict): dictionary to select in the data as .sel(**select)

arm(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis=<factory>)
Parameters:

  • duration (float): Duration of the analysis waveform (Constraints: units: s)

  • sample_rate (float): Analysis sample rate (Constraints: units: S/s)

  • analysis_bandwidth (float): Analysis bandwidth (Constraints: units: Hz)

  • port (int | tuple[int, …]): Input port indices (Constraints: >= 0, >= 0)

  • lo_shift (one of [‘left’, ‘right’, ‘none’]): LO shift direction

  • host_resample (bool):

  • backend_sample_rate (float | None): Source sample rate (Constraints: > 0, units: Hz)

  • adjust_analysis (dict[str, Any]): changes to apply across each analysis for any matching parameter

acquire(overlaps=None)

acquire IQ samples needed for the armed capture.

class striqt.sensor.bindings.Controller(*args: ~PS, **kwargs: ~PS)

Bases: Generic[SS, SP, SC, PS, PC]

Open the source backend for control and acquisition.

acquire(overlaps: tuple[int, int] | None = None) → AcquiredIQ

acquire IQ samples needed for the armed capture.

arm(*args: ~PC, **kwargs: ~PC) → SC | None
backend: SourceBackend[SS, SC]
property capture_spec: SC

return the specification of the currently armed capture

close()
classmethod from_source_spec(spec: SS, reuse_iq: bool = False, rx_ports: tuple[int, ...] | None = None, format_path: PathFormatter | None = None) → Controller[SS, SP, SC, PS, PC]
classmethod from_sweep_spec(spec: Sweep[SS, Any, SC], format_path: PathFormatter | None = None) → Controller[SS, SP, SC, PS, PC]
get_resampler() → ResamplerDesign
is_open(wait=True) → bool
read_iq(overlaps: tuple[int, int] = (0, 0)) → tuple[Array, int | None]

read IQ for the armed capture

schema: specs.Schema[SS, SP, SC, PS, PC]
sensor: bindings.SensorBinding[SS, SP, SC]
set_calibration_formatter(format_path: PathFormatter | None = None)

set the formatter to use to expand calibration file formatting fields.

This is needed if calibration is defined in the source spec with format fields like {name}.

property source_id: str
property source_info: SourceInfo
property source_spec: SS
target_analysis(analysis: AnalysisGroup | None)

sets or disables an analysis target to auto-select acquisition overlap

class striqt.sensor.bindings.Schema(source: 'type[SS]', capture: 'type[SC]', peripherals: 'type[SP]', init_like: 'Callable[PS, Any]', arm_like: 'Callable[PC, Any]')

Bases: Generic[SS, SP, SC, PS, PC]

arm_like: Callable[PC, Any]
capture: type[SC]
init_like: Callable[PS, Any]
peripherals: type[SP]
source: type[SS]
class striqt.sensor.bindings.Sensor(source_cls: 'type[SourceBackend[SS, SC]]', sink_cls: 'type[sinks.SinkBase[SC]]' = <class 'striqt.sensor.lib.sinks.ZarrCaptureSink'>, sweep_spec_cls: 'type[specs.Sweep[SS, SP, SC]]'=<class 'striqt.sensor.specs.Sweep'>, peripherals_cls: 'type[Peripherals[SP, SC]]'=<class 'striqt.sensor.lib.peripherals.NoPeripherals'>)

Bases: Generic[SS, SP, SC]

peripherals_cls

alias of NoPeripherals

sink_cls

alias of ZarrCaptureSink

source_cls: type[SourceBackend[SS, SC]]
sweep_spec_cls

alias of Sweep

class striqt.sensor.bindings.SensorBinding(source_cls: 'type[SourceBackend[SS, SC]]', sink_cls: 'type[sinks.SinkBase[SC]]' = <class 'striqt.sensor.lib.sinks.ZarrCaptureSink'>, sweep_spec_cls: 'type[BoundSweep[SS, SP, SC]]'=<class 'striqt.sensor.specs.Sweep'>, peripherals_cls: 'type[Peripherals[SP, SC]]'=<class 'striqt.sensor.lib.peripherals.NoPeripherals'>)

Bases: Sensor[SS, SP, SC]

striqt.sensor.bindings.bind_manual_yfactor_calibration(name: str, ctrl_cls: type[Controller[SS, SP, Any, PS, PC]]) → type[Controller[SS, SP, Any, PS, PC]]

extend an existing binding with a y-factor calibration

striqt.sensor.bindings.bind_sensor(key: str, sensor: Sensor[TS2, TP2, TC2], schema: Schema[SS, SP, SC, PS, PC], register: bool = True) → type[Controller[SS, SP, SC, PS, PC]]

register a binding between specifications and controller classes.

Parameters:

  • key – the key used when instantiating from yaml/json

  • sensor – the binding classes