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
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

use anyhow::{Result, bail};
use argh::FromArgs;
use crossbeam::channel::{Receiver, TryRecvError, unbounded};
use lasprs::Flt;
use lasprs::daq::{RecordSettings, RecordStatus, Recording, StreamMgr, StreamType};
use std::{
    io, thread,
    time::{self, Duration},
};

#[derive(FromArgs, Debug)]
///Record data to h5 file, according to LASP format
struct Cli {
    /// the TOML configuration file for used stream. If not given, it uses the
    /// default stream, if available
    #[argh(option, short = 'c')]
    config_file_daq: Option<String>,

    /// file name to write recording to
    #[argh(positional)]
    filename: String,

    /// recording duration in \[s\]. Rounds down to whole seconds. If not specified, records until user presses a key
    #[argh(option, default = "0.0")]
    duration_s: Flt,

    /// start delay in \[s\]. Rounds down to whole seconds. If not specified, no
    /// start delay will be used.
    #[argh(option, default = "0.0")]
    start_delay_s: Flt,
}

fn main() -> Result<()> {
    use lasprs::daq::DaqConfig;

    let ops: Cli = argh::from_env();

    let mut smgr = StreamMgr::new();
    let stdin_channel = spawn_stdin_channel();

    if ops.start_delay_s < 0. {
        bail!("Start delay cannot be negative");
    }
    if ops.duration_s < 0. {
        bail!("Duration cannot be negative");
    }

    let start_delay = if ops.start_delay_s > 0. {
        Some(Duration::from_secs(ops.start_delay_s as u64))
    } else {
        None
    };
    let duration = if ops.duration_s > 0. {
        Some(Duration::from_secs(ops.duration_s as u64))
    } else {
        None
    };

    let settings = RecordSettings::new(
        &ops.filename,
        false,
        duration,
        start_delay,
        None,
        None,
        false,
        None,
        vec![],
    )?;

    match ops.config_file_daq {
        // No config file is given, start default input stream
        None => smgr.startDefaultInputStream()?,
        Some(filename) => {
            // If config file is given, use that.
            let file = std::fs::read_to_string(filename)?;
            let cfg = DaqConfig::deserialize_TOML_str(&file)?;
            smgr.startStream(StreamType::Input, &cfg)?;
        }
    }

    let mut r = Recording::new(settings, &mut smgr)?;

    // println!("Starting to record... Enter 'c' to cancel.");
    'infy: loop {
        use lasprs::daq::FinishedRecording;

        match r.status() {
            RecordStatus::Idle {} => println!("\nIdle"),
            RecordStatus::Waiting {} => {
                println!("Waiting in start delay...");
            }
            RecordStatus::Finished {
                finishedrecording: FinishedRecording { clipped, error, .. },
            } => {
                println!("\nRecording finished.");
                if clipped {
                    println!("Recording clipped!");
                }
                if let Some(msg) = error {
                    println!("Recording failed with an error: {msg}");
                }
                break 'infy;
            }
            RecordStatus::Recording { recorded, .. } => {
                println!("Recording...   {:.0} ms", recorded * 1000.);
            }
        };

        match stdin_channel.try_recv() {
            Ok(_key) => {
                println!("User pressed key. Manually stopping recording here.");
                match _key.to_lowercase().as_str() {
                    "c" => r.cancel(),
                    _ => r.stop(),
                }
                break 'infy;
            }
            Err(TryRecvError::Empty) => {}
            Err(TryRecvError::Disconnected) => panic!("Channel disconnected"),
        }

        sleep(500);
    }

    Ok(())
}

fn sleep(millis: u64) {
    let duration = time::Duration::from_millis(millis);
    thread::sleep(duration);
}

fn spawn_stdin_channel() -> Receiver<String> {
    let (tx, rx) = unbounded();
    thread::spawn(move || {
        loop {
            let mut buffer = String::new();
            io::stdin().read_line(&mut buffer).unwrap();
            tx.send(buffer).unwrap();
        }
    });
    rx
}