215 lines
5.4 KiB
Rust
215 lines
5.4 KiB
Rust
//! This module provide signal generators.
|
|
//!
|
|
//! # Examples
|
|
//!
|
|
//! ## Create some white noise and print it.
|
|
//!
|
|
//! ```
|
|
//! let mut wn = Siggen::newWhiteNoise();
|
|
//! wn.setGain(0.1);
|
|
//! wn.setMute(false);
|
|
//! let mut sig = [0. ; 1024];
|
|
//! wn.genSignal(&mut sig);
|
|
//! println!("{:?}", &sig);
|
|
//!
|
|
//! ```
|
|
use super::config::*;
|
|
use super::filter::Filter;
|
|
use pyo3::prelude::*;
|
|
use rand::prelude::*;
|
|
use rand::rngs::ThreadRng;
|
|
use rand_distr::StandardNormal;
|
|
|
|
trait Source: Send {
|
|
/// Generate the 'pure' source signal. Output is placed inside the `sig` argument.
|
|
fn genSignal_unscaled(&mut self, sig: &mut [Flt]);
|
|
/// Reset the source state, i.e. set phase to 0, etc
|
|
fn reset(&mut self, fs: Flt);
|
|
/// Used to make the Siggen struct cloneable
|
|
fn clone_dyn(&self) -> Box<dyn Source>;
|
|
}
|
|
impl Clone for Box<dyn Source> {
|
|
fn clone(&self) -> Self {
|
|
self.clone_dyn()
|
|
}
|
|
}
|
|
|
|
/// White noise source
|
|
#[derive(Clone)]
|
|
struct WhiteNoise {}
|
|
impl WhiteNoise {
|
|
/// Generate new WhiteNoise generator
|
|
fn new() -> WhiteNoise {
|
|
WhiteNoise {}
|
|
}
|
|
}
|
|
impl Source for WhiteNoise {
|
|
fn genSignal_unscaled(&mut self, sig: &mut [Flt]) {
|
|
sig.iter_mut()
|
|
.for_each(|s| *s = thread_rng().sample(StandardNormal));
|
|
}
|
|
fn reset(&mut self, _fs: Flt) {}
|
|
fn clone_dyn(&self) -> Box<dyn Source> {
|
|
Box::new(self.clone())
|
|
}
|
|
}
|
|
|
|
/// Sine wave, with configurable frequency
|
|
#[derive(Clone)]
|
|
struct Sine {
|
|
// Sampling freq [Hz]
|
|
fs: Flt,
|
|
// current stored phase
|
|
phase: Flt,
|
|
// Signal frequency [rad/s]
|
|
omg: Flt,
|
|
}
|
|
impl Sine {
|
|
/// Create new sine source signal
|
|
///
|
|
/// Args:
|
|
///
|
|
/// * fs: Sampling freq [Hz]
|
|
/// *
|
|
fn new(freq: Flt) -> Sine {
|
|
Sine {
|
|
fs: -1.,
|
|
phase: 0.,
|
|
omg: 2. * pi * freq,
|
|
}
|
|
}
|
|
}
|
|
impl Source for Sine {
|
|
fn genSignal_unscaled(&mut self, sig: &mut [Flt]) {
|
|
if self.fs < 0. {
|
|
sig.iter_mut().for_each(|s| {
|
|
*s = 0.;
|
|
});
|
|
return;
|
|
}
|
|
sig.iter_mut().for_each(|s| {
|
|
*s = Flt::sin(self.phase);
|
|
self.phase += self.omg / self.fs;
|
|
});
|
|
while self.phase > 2. * pi {
|
|
self.phase -= 2. * pi;
|
|
}
|
|
}
|
|
fn reset(&mut self, fs: Flt) {
|
|
self.fs = fs;
|
|
self.phase = 0.;
|
|
}
|
|
fn clone_dyn(&self) -> Box<dyn Source> {
|
|
Box::new(self.clone())
|
|
}
|
|
}
|
|
|
|
/// Sweep signal
|
|
|
|
#[derive(Clone)]
|
|
/// Signal generator. Able to create acoustic output signals
|
|
pub struct Siggen {
|
|
// The source dynamic signal. Noise, a sine wave, sweep, etc
|
|
source: Box<dyn Source>,
|
|
// Filter applied to the source signal
|
|
prefilter: Option<Box<dyn Filter>>,
|
|
// If set, no dynamic signal source output is given
|
|
muted: bool,
|
|
gain: Flt,
|
|
DCOffset: Flt,
|
|
}
|
|
|
|
/// A struct that implements the Siggen trait is able to generate a signal.
|
|
impl Siggen {
|
|
/// Set new pre-filter that filters the source signal
|
|
pub fn setPreFilter(&mut self, pref: Option<Box<dyn Filter>>) {
|
|
self.prefilter = pref.clone();
|
|
}
|
|
/// Set the gain applied to the source signal
|
|
///
|
|
/// * g: Gain value. Can be any float. If set to 0.0, the source is effectively muted. Only
|
|
/// using (setMute) is a more efficient way to do this.
|
|
pub fn setGain(&mut self, g: Flt) {
|
|
self.gain = g;
|
|
}
|
|
/// Create a white noise signal generator.
|
|
pub fn newWhiteNoise() -> Siggen {
|
|
Siggen::new(Box::new(WhiteNoise::new()))
|
|
}
|
|
/// Create a sine wave signal generator
|
|
///
|
|
/// * freq: Frequency of the sine wave in [Hz]
|
|
pub fn newSineWave(freq: Flt) -> Siggen {
|
|
Siggen::new(Box::new(Sine::new(freq)))
|
|
}
|
|
|
|
/// Create a new signal generator wiht an arbitrary source.
|
|
pub fn new(source: Box<dyn Source>) -> Siggen {
|
|
Siggen {
|
|
source,
|
|
prefilter: None,
|
|
muted: false,
|
|
gain: 1.0,
|
|
DCOffset: 0.0,
|
|
}
|
|
}
|
|
|
|
/// Generate new signal data.
|
|
///
|
|
/// # Args
|
|
///
|
|
/// sig: Reference of array of float values to be filled with signal data.
|
|
///
|
|
/// # Details
|
|
///
|
|
/// - When muted, the DC offset is still applied
|
|
/// - The order of the generation is:
|
|
/// - First, the source is generated.
|
|
/// - If a prefilter is installed, this pre-filter is applied to the source signal.
|
|
/// - Gain is applied.
|
|
/// - Offset is applied (thus, no gain is applied to the DC offset).
|
|
///
|
|
pub fn genSignal(&mut self, sig: &mut [Flt]) {
|
|
if self.muted {
|
|
sig.iter_mut().for_each(|x| {
|
|
*x = 0.0;
|
|
});
|
|
} else {
|
|
self.source.genSignal_unscaled(sig);
|
|
if let Some(f) = &mut self.prefilter {
|
|
f.filter(sig);
|
|
}
|
|
}
|
|
sig.iter_mut().for_each(|x| {
|
|
// First apply gain, then offset
|
|
*x *= self.gain;
|
|
*x += self.DCOffset;
|
|
});
|
|
}
|
|
|
|
/// Reset signal generator. Applies any kind of cleanup necessary.
|
|
///
|
|
/// Args
|
|
///
|
|
/// * fs: (New) Sampling frequency [Hz]
|
|
///
|
|
pub fn reset(&mut self, fs: Flt) {
|
|
self.source.reset(fs);
|
|
if let Some(f) = &mut self.prefilter {
|
|
f.reset();
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_whitenoise() {
|
|
let mut t = &[0.; 10];
|
|
Siggen::newWiteNoise().genSignal(&mut t);
|
|
println!("{:?}", &t);
|
|
}
|
|
}
|