tekhsi_rs 0.1.1

High-performance client for Tektronix TekHSI enabled oscilloscopes
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use crate::data::{AnalogWaveform, IqWaveform};
use crate::fft::core::{FftResult, ReusableFftStateComplex, ReusableFftStateReal};
use crate::fft::window::FftWindow;

/// A Waveform that can be converted to an FFT magnitude
pub trait FftWaveform {
    /// Computes the FFT magnitude of the waveform
    ///
    /// ```rust
    /// use tekhsi_rs::data::{AnalogSamples, AnalogWaveform};
    /// use tekhsi_rs::fft::{FftWaveform, FftWindow};
    /// use smol_str::SmolStr;
    ///
    /// let waveform = AnalogWaveform {
    ///     source_name: SmolStr::new("ch1"),
    ///     y_axis_values: AnalogSamples::I16(vec![1, 2, 3, 4]),
    ///     y_axis_spacing: 1.0,
    ///     y_axis_offset: 0.0,
    ///     y_axis_units: SmolStr::new("V"),
    ///     x_axis_spacing: 1.0,
    ///     x_axis_units: SmolStr::new("s"),
    ///     trigger_index: 0.0,
    /// };
    /// let fft = waveform.fft_mag(FftWindow::Rectangular, None);
    /// assert!(!fft.bins.is_empty());
    /// ```
    fn fft_mag(&self, window: FftWindow, fft_len: Option<usize>) -> FftResult;

    /// Computes the FFT magnitude of the waveform while reusing existing allocations.
    ///
    /// The returned result is stored in `state` and is overwritten on the next call
    /// that uses the same `ReusableFftStateReal`.
    fn fft_mag_cached<'a>(
        &self,
        state: &'a mut ReusableFftStateReal,
        window: FftWindow,
        fft_len: Option<usize>,
    ) -> &'a mut FftResult;
}

impl FftWaveform for AnalogWaveform {
    fn fft_mag(&self, window: FftWindow, fft_len: Option<usize>) -> FftResult {
        ReusableFftStateReal::new()
            .fft_points_mag(
                self.iter_normalized_values(),
                analog_sample_rate(self),
                fft_len,
                window,
            )
            .clone()
    }

    fn fft_mag_cached<'a>(
        &self,
        state: &'a mut ReusableFftStateReal,
        window: FftWindow,
        fft_len: Option<usize>,
    ) -> &'a mut FftResult {
        state.fft_points_mag(
            self.iter_normalized_values(),
            analog_sample_rate(self),
            fft_len,
            window,
        )
    }
}

impl FftWaveform for IqWaveform {
    /// Computes the complex FFT of the waveform
    fn fft_mag(&self, window: FftWindow, fft_len: Option<usize>) -> FftResult {
        ReusableFftStateReal::new()
            .fft_points_mag(
                self.iter_normalized_values()
                    .map(|value| (value.re * value.re + value.im * value.im).sqrt()),
                iq_sample_rate(self),
                fft_len,
                window,
            )
            .clone()
    }

    /// Computes the complex FFT of the waveform while reusing existing allocations
    fn fft_mag_cached<'a>(
        &self,
        state: &'a mut ReusableFftStateReal,
        window: FftWindow,
        fft_len: Option<usize>,
    ) -> &'a mut FftResult {
        state.fft_points_mag(
            self.iter_normalized_values()
                .map(|value| (value.re * value.re + value.im * value.im).sqrt()),
            iq_sample_rate(self),
            fft_len,
            window,
        )
    }
}

/// A Waveform that can be converted to complex FFT values
pub trait ComplexFftWaveform {
    fn fft_complex(&self, window: FftWindow, fft_len: Option<usize>) -> FftResult;

    /// Computes the complex FFT of the waveform while reusing existing allocations.
    ///
    /// The returned result is stored in `state` and is overwritten on the next call
    /// that uses the same `ReusableFftStateComplex`.
    fn fft_complex_cached<'a>(
        &self,
        state: &'a mut ReusableFftStateComplex,
        window: FftWindow,
        fft_len: Option<usize>,
    ) -> &'a mut FftResult;
}

impl ComplexFftWaveform for IqWaveform {
    fn fft_complex(&self, window: FftWindow, fft_len: Option<usize>) -> FftResult {
        ReusableFftStateComplex::new()
            .fft_points_complex(
                self.iter_normalized_values(),
                iq_sample_rate(self),
                self.meta_info.iq_center_frequency,
                fft_len,
                window,
            )
            .clone()
    }

    fn fft_complex_cached<'a>(
        &self,
        state: &'a mut ReusableFftStateComplex,
        window: FftWindow,
        fft_len: Option<usize>,
    ) -> &'a mut FftResult {
        state.fft_points_complex(
            self.iter_normalized_values(),
            iq_sample_rate(self),
            self.meta_info.iq_center_frequency,
            fft_len,
            window,
        )
    }
}

fn analog_sample_rate(analog: &AnalogWaveform) -> f64 {
    if analog.x_axis_spacing > 0.0 {
        1.0 / analog.x_axis_spacing
    } else {
        0.0
    }
}

fn iq_sample_rate(iq: &IqWaveform) -> f64 {
    if iq.meta_info.iq_sample_rate > 0.0 {
        iq.meta_info.iq_sample_rate
    } else if iq.x_axis_spacing > 0.0 {
        1.0 / iq.x_axis_spacing
    } else {
        0.0
    }
}