lasprs 0.14.1

Library for Acoustic Signal Processing (Rust edition, with optional Python bindings via pyo3)
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

use anyhow::Result;
use crossbeam::channel::{Receiver, TryRecvError, unbounded};
use lasprs::daq::{StreamDirection, StreamMgr, StreamStatus};
use lasprs::siggen::{SiggenCommand, SourceDescriptor, SweepSettings, SweepType};
use std::io;
use std::{thread, time};
// use

/// Spawns a thread and waits for a single line, pushes it to the receiver and  returns
fn stdin_channel_wait_for_return() -> Receiver<String> {
    let (tx, rx) = unbounded();
    thread::spawn(move || {
        let mut buffer = String::new();
        io::stdin().read_line(&mut buffer).unwrap();
        // Do not care whether we succeed here.
        let _ = tx.send(buffer);
    });
    rx
}
fn sleep(millis: u64) {
    let duration = time::Duration::from_millis(millis);
    thread::sleep(duration);
}
fn main() -> Result<()> {
    let mut smgr = StreamMgr::new_with_devices();

    let stdin_channel = stdin_channel_wait_for_return();

    println!("Creating signal generator...");
    // let mut siggen = Siggen::newSine(44100., 2, 432.)?;
    // Apply signal generator
    let src = SourceDescriptor::Sweep {
        settings: SweepSettings::new(10., 10000., 1., SweepType::ContinuousLog, None, None)?,
    };
    smgr.setSiggenSource(src)?;
    smgr.siggenCommand(SiggenCommand::SetAllGains {
        g: 0.1.try_into().unwrap(),
    })?;
    smgr.siggenCommand(SiggenCommand::SetMuteAllChannels { mute: false })?;

    println!("Starting stream...");
    smgr.startDefaultOutputStream()?;

    println!("Press <enter> key to quit...");
    'infy: loop {
        match stdin_channel.try_recv() {
            Ok(_key) => break 'infy,
            Err(TryRecvError::Empty) => {}
            Err(TryRecvError::Disconnected) => panic!("Channel disconnected"),
        }
        sleep(100);
        match smgr.getStatus(StreamDirection::Output) {
            StreamStatus::NotRunning {} => {
                println!("Stream is not running?");
                break 'infy;
            }
            StreamStatus::Running { .. } => {}
            StreamStatus::Error { e } => {
                println!("Stream error: {e}");
                break 'infy;
            }
        }
    }

    Ok(())
}