Struct NSRT 

pub struct NSRT { /* private fields */ }

The main driver for the NSRT_mk4 device

Implementations

impl NSRT

pub fn apply(self) -> Result<Self>

Apply stabilization wait after configuration

Call this after performing multiple chained configuration methods to apply a single stabilization wait.

Examples found in repository

examples/simple_monitor.rs (line 12)

fn main() -> Result<()> {
    println!("Opening NSRT_mk4 device...");

    let mut nsrt = NSRT::open()?
        .weighting(Weighting::A)?
        .time_constant(1.0)?
        .sampling_frequency(SamplingFrequency::Freq48kHz)?
        .apply()?;

    let model = nsrt.read_model()?;
    let serial = nsrt.read_serial_number()?;
    let firmware = nsrt.read_firmware_revision()?;

    println!("Connected to:");
    println!("  Model: {}", model);
    println!("  Serial: {}", serial);
    println!("  Firmware: {}", firmware);

    println!("Monitoring sound levels:");
    println!("Level (dBA) | LEQ (dBA) | Temp (°C)");
    println!("------------+-----------+----------");

    loop {
        let level = nsrt.read_level()?;
        let leq = nsrt.read_leq()?;
        let temp = nsrt.read_temperature()?;

        println!("{:10.1} | {:9.1} | {:8.1}", level, leq, temp);

        thread::sleep(Duration::from_secs(1));
    }
}

pub fn open() -> Result<Self>

Open the NSRT_mk4 device

This method automatically finds and opens the first NSRT_mk4 device connected to the system using the Convergence Instruments VID/PID.

Examples found in repository

examples/simple_monitor.rs (line 8)

fn main() -> Result<()> {
    println!("Opening NSRT_mk4 device...");

    let mut nsrt = NSRT::open()?
        .weighting(Weighting::A)?
        .time_constant(1.0)?
        .sampling_frequency(SamplingFrequency::Freq48kHz)?
        .apply()?;

    let model = nsrt.read_model()?;
    let serial = nsrt.read_serial_number()?;
    let firmware = nsrt.read_firmware_revision()?;

    println!("Connected to:");
    println!("  Model: {}", model);
    println!("  Serial: {}", serial);
    println!("  Firmware: {}", firmware);

    println!("Monitoring sound levels:");
    println!("Level (dBA) | LEQ (dBA) | Temp (°C)");
    println!("------------+-----------+----------");

    loop {
        let level = nsrt.read_level()?;
        let leq = nsrt.read_leq()?;
        let temp = nsrt.read_temperature()?;

        println!("{:10.1} | {:9.1} | {:8.1}", level, leq, temp);

        thread::sleep(Duration::from_secs(1));
    }
}

pub fn read_level(&mut self) -> Result<f32>

Read the current sound level in dB

Examples found in repository

examples/simple_monitor.rs (line 28)

fn main() -> Result<()> {
    println!("Opening NSRT_mk4 device...");

    let mut nsrt = NSRT::open()?
        .weighting(Weighting::A)?
        .time_constant(1.0)?
        .sampling_frequency(SamplingFrequency::Freq48kHz)?
        .apply()?;

    let model = nsrt.read_model()?;
    let serial = nsrt.read_serial_number()?;
    let firmware = nsrt.read_firmware_revision()?;

    println!("Connected to:");
    println!("  Model: {}", model);
    println!("  Serial: {}", serial);
    println!("  Firmware: {}", firmware);

    println!("Monitoring sound levels:");
    println!("Level (dBA) | LEQ (dBA) | Temp (°C)");
    println!("------------+-----------+----------");

    loop {
        let level = nsrt.read_level()?;
        let leq = nsrt.read_leq()?;
        let temp = nsrt.read_temperature()?;

        println!("{:10.1} | {:9.1} | {:8.1}", level, leq, temp);

        thread::sleep(Duration::from_secs(1));
    }
}

pub fn read_leq(&mut self) -> Result<f32>

Read the current LEQ (Equivalent Continuous Sound Level) in dB and restart integration for the next LEQ measurement

Examples found in repository

examples/simple_monitor.rs (line 29)

fn main() -> Result<()> {
    println!("Opening NSRT_mk4 device...");

    let mut nsrt = NSRT::open()?
        .weighting(Weighting::A)?
        .time_constant(1.0)?
        .sampling_frequency(SamplingFrequency::Freq48kHz)?
        .apply()?;

    let model = nsrt.read_model()?;
    let serial = nsrt.read_serial_number()?;
    let firmware = nsrt.read_firmware_revision()?;

    println!("Connected to:");
    println!("  Model: {}", model);
    println!("  Serial: {}", serial);
    println!("  Firmware: {}", firmware);

    println!("Monitoring sound levels:");
    println!("Level (dBA) | LEQ (dBA) | Temp (°C)");
    println!("------------+-----------+----------");

    loop {
        let level = nsrt.read_level()?;
        let leq = nsrt.read_leq()?;
        let temp = nsrt.read_temperature()?;

        println!("{:10.1} | {:9.1} | {:8.1}", level, leq, temp);

        thread::sleep(Duration::from_secs(1));
    }
}

pub fn read_temperature(&mut self) -> Result<f32>

Read the current temperature in degrees Celsius

Examples found in repository

examples/simple_monitor.rs (line 30)

fn main() -> Result<()> {
    println!("Opening NSRT_mk4 device...");

    let mut nsrt = NSRT::open()?
        .weighting(Weighting::A)?
        .time_constant(1.0)?
        .sampling_frequency(SamplingFrequency::Freq48kHz)?
        .apply()?;

    let model = nsrt.read_model()?;
    let serial = nsrt.read_serial_number()?;
    let firmware = nsrt.read_firmware_revision()?;

    println!("Connected to:");
    println!("  Model: {}", model);
    println!("  Serial: {}", serial);
    println!("  Firmware: {}", firmware);

    println!("Monitoring sound levels:");
    println!("Level (dBA) | LEQ (dBA) | Temp (°C)");
    println!("------------+-----------+----------");

    loop {
        let level = nsrt.read_level()?;
        let leq = nsrt.read_leq()?;
        let temp = nsrt.read_temperature()?;

        println!("{:10.1} | {:9.1} | {:8.1}", level, leq, temp);

        thread::sleep(Duration::from_secs(1));
    }
}

pub fn read_weighting(&mut self) -> Result<Weighting>

Read the current weighting curve

pub fn weighting(self, weighting: Weighting) -> Result<Self>

Set the weighting curve using fluent API

This method can be chained with other setters during initialization.

Examples found in repository

examples/simple_monitor.rs (line 9)

fn main() -> Result<()> {
    println!("Opening NSRT_mk4 device...");

    let mut nsrt = NSRT::open()?
        .weighting(Weighting::A)?
        .time_constant(1.0)?
        .sampling_frequency(SamplingFrequency::Freq48kHz)?
        .apply()?;

    let model = nsrt.read_model()?;
    let serial = nsrt.read_serial_number()?;
    let firmware = nsrt.read_firmware_revision()?;

    println!("Connected to:");
    println!("  Model: {}", model);
    println!("  Serial: {}", serial);
    println!("  Firmware: {}", firmware);

    println!("Monitoring sound levels:");
    println!("Level (dBA) | LEQ (dBA) | Temp (°C)");
    println!("------------+-----------+----------");

    loop {
        let level = nsrt.read_level()?;
        let leq = nsrt.read_leq()?;
        let temp = nsrt.read_temperature()?;

        println!("{:10.1} | {:9.1} | {:8.1}", level, leq, temp);

        thread::sleep(Duration::from_secs(1));
    }
}

pub fn read_sampling_frequency(&mut self) -> Result<SamplingFrequency>

Read the current sampling frequency

pub fn sampling_frequency(self, freq: SamplingFrequency) -> Result<Self>

Set the sampling frequency using fluent API

Examples found in repository

examples/simple_monitor.rs (line 11)

fn main() -> Result<()> {
    println!("Opening NSRT_mk4 device...");

    let mut nsrt = NSRT::open()?
        .weighting(Weighting::A)?
        .time_constant(1.0)?
        .sampling_frequency(SamplingFrequency::Freq48kHz)?
        .apply()?;

    let model = nsrt.read_model()?;
    let serial = nsrt.read_serial_number()?;
    let firmware = nsrt.read_firmware_revision()?;

    println!("Connected to:");
    println!("  Model: {}", model);
    println!("  Serial: {}", serial);
    println!("  Firmware: {}", firmware);

    println!("Monitoring sound levels:");
    println!("Level (dBA) | LEQ (dBA) | Temp (°C)");
    println!("------------+-----------+----------");

    loop {
        let level = nsrt.read_level()?;
        let leq = nsrt.read_leq()?;
        let temp = nsrt.read_temperature()?;

        println!("{:10.1} | {:9.1} | {:8.1}", level, leq, temp);

        thread::sleep(Duration::from_secs(1));
    }
}

pub fn read_time_constant(&mut self) -> Result<f32>

Read the current time constant in seconds

pub fn time_constant(self, tau: f32) -> Result<Self>

Set the time constant using fluent API

This method can be chained with other setters during initialization.

Examples found in repository

examples/simple_monitor.rs (line 10)

fn main() -> Result<()> {
    println!("Opening NSRT_mk4 device...");

    let mut nsrt = NSRT::open()?
        .weighting(Weighting::A)?
        .time_constant(1.0)?
        .sampling_frequency(SamplingFrequency::Freq48kHz)?
        .apply()?;

    let model = nsrt.read_model()?;
    let serial = nsrt.read_serial_number()?;
    let firmware = nsrt.read_firmware_revision()?;

    println!("Connected to:");
    println!("  Model: {}", model);
    println!("  Serial: {}", serial);
    println!("  Firmware: {}", firmware);

    println!("Monitoring sound levels:");
    println!("Level (dBA) | LEQ (dBA) | Temp (°C)");
    println!("------------+-----------+----------");

    loop {
        let level = nsrt.read_level()?;
        let leq = nsrt.read_leq()?;
        let temp = nsrt.read_temperature()?;

        println!("{:10.1} | {:9.1} | {:8.1}", level, leq, temp);

        thread::sleep(Duration::from_secs(1));
    }
}

pub fn read_model(&mut self) -> Result<String>

Read the model name

Examples found in repository

examples/simple_monitor.rs (line 14)

fn main() -> Result<()> {
    println!("Opening NSRT_mk4 device...");

    let mut nsrt = NSRT::open()?
        .weighting(Weighting::A)?
        .time_constant(1.0)?
        .sampling_frequency(SamplingFrequency::Freq48kHz)?
        .apply()?;

    let model = nsrt.read_model()?;
    let serial = nsrt.read_serial_number()?;
    let firmware = nsrt.read_firmware_revision()?;

    println!("Connected to:");
    println!("  Model: {}", model);
    println!("  Serial: {}", serial);
    println!("  Firmware: {}", firmware);

    println!("Monitoring sound levels:");
    println!("Level (dBA) | LEQ (dBA) | Temp (°C)");
    println!("------------+-----------+----------");

    loop {
        let level = nsrt.read_level()?;
        let leq = nsrt.read_leq()?;
        let temp = nsrt.read_temperature()?;

        println!("{:10.1} | {:9.1} | {:8.1}", level, leq, temp);

        thread::sleep(Duration::from_secs(1));
    }
}

pub fn read_serial_number(&mut self) -> Result<String>

Read the serial number

Examples found in repository

examples/simple_monitor.rs (line 15)

fn main() -> Result<()> {
    println!("Opening NSRT_mk4 device...");

    let mut nsrt = NSRT::open()?
        .weighting(Weighting::A)?
        .time_constant(1.0)?
        .sampling_frequency(SamplingFrequency::Freq48kHz)?
        .apply()?;

    let model = nsrt.read_model()?;
    let serial = nsrt.read_serial_number()?;
    let firmware = nsrt.read_firmware_revision()?;

    println!("Connected to:");
    println!("  Model: {}", model);
    println!("  Serial: {}", serial);
    println!("  Firmware: {}", firmware);

    println!("Monitoring sound levels:");
    println!("Level (dBA) | LEQ (dBA) | Temp (°C)");
    println!("------------+-----------+----------");

    loop {
        let level = nsrt.read_level()?;
        let leq = nsrt.read_leq()?;
        let temp = nsrt.read_temperature()?;

        println!("{:10.1} | {:9.1} | {:8.1}", level, leq, temp);

        thread::sleep(Duration::from_secs(1));
    }
}

pub fn read_firmware_revision(&mut self) -> Result<String>

Read the firmware revision

Examples found in repository

examples/simple_monitor.rs (line 16)

fn main() -> Result<()> {
    println!("Opening NSRT_mk4 device...");

    let mut nsrt = NSRT::open()?
        .weighting(Weighting::A)?
        .time_constant(1.0)?
        .sampling_frequency(SamplingFrequency::Freq48kHz)?
        .apply()?;

    let model = nsrt.read_model()?;
    let serial = nsrt.read_serial_number()?;
    let firmware = nsrt.read_firmware_revision()?;

    println!("Connected to:");
    println!("  Model: {}", model);
    println!("  Serial: {}", serial);
    println!("  Firmware: {}", firmware);

    println!("Monitoring sound levels:");
    println!("Level (dBA) | LEQ (dBA) | Temp (°C)");
    println!("------------+-----------+----------");

    loop {
        let level = nsrt.read_level()?;
        let leq = nsrt.read_leq()?;
        let temp = nsrt.read_temperature()?;

        println!("{:10.1} | {:9.1} | {:8.1}", level, leq, temp);

        thread::sleep(Duration::from_secs(1));
    }
}

pub fn read_calibration_date(&mut self) -> Result<u64>

Read the date of last calibration

pub fn read_birth_date(&mut self) -> Result<u64>

Read the date of birth (manufacturing date)

pub fn read_user_id(&mut self) -> Result<String>

Read the user ID