Struct SignalConfig 

pub struct SignalConfig(/* private fields */);

The configuration component of a Signal. Allows for configuration of its properties, managing its streaming sources, and sending packets through its connections. The Signal config is most often accessible only to the devices or function blocks that own the signal. They react on property, or input signal changes to modify a signal’s data descriptor, and send processed/acquired data down its signal path. Wrapper over the openDAQ daqSignalConfig interface.

Implementations

impl SignalConfig

pub fn add_related_signal(&self, signal: &Signal) -> Result<()>

Adds a related signal to the list of related signals.

Parameters

• signal: The signal to be added.

Errors

• OPENDAQ_ERR_DUPLICATEITEM: if the signal is already present in the list.

Calls the openDAQ C function daqSignalConfig_addRelatedSignal().

pub fn clear_related_signals(&self) -> Result<()>

Clears the list of related signals.

Calls the openDAQ C function daqSignalConfig_clearRelatedSignals().

pub fn signal( context: &Context, parent: Option<&Component>, local_id: &str, class_name: Option<&str>, ) -> Result<SignalConfig>

Calls the openDAQ C function daqSignalConfig_createSignal().

Examples found in repository

examples/create_signal.rs (line 84)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    let context = instance.context()?.expect("instance context");

    let domain_descriptor = {
        let builder = DataDescriptorBuilder::new()?;
        builder.set_sample_type(SampleType::Int64)?;
        builder.set_name("time")?;
        // Origin stays at the epoch; the wall-clock time lives in the ticks.
        builder.set_origin("1970-01-01T00:00:00Z")?;
        builder.set_tick_resolution(TICK_RESOLUTION)?;
        builder.set_unit(&Unit::new(-1, "s", "second", "time")?)?;
        builder.set_rule(&DataRule::linear(TICKS_PER_SAMPLE, 0)?)?;
        builder.build()?.expect("domain descriptor")
    };
    let value_descriptor = {
        let builder = DataDescriptorBuilder::new()?;
        builder.set_sample_type(SampleType::Float64)?;
        builder.set_name("values")?;
        builder.build()?.expect("value descriptor")
    };

    let domain_signal = SignalConfig::signal(&context, None, "time", None)?;
    domain_signal.set_descriptor(&domain_descriptor)?;
    let signal = SignalConfig::signal(&context, None, "values", None)?;
    signal.set_descriptor(&value_descriptor)?;
    signal.set_domain_signal(&domain_signal)?;

    let reader = StreamReader::<f64, i64>::with_options(
        &signal,
        StreamReaderOptions {
            timeout_type: ReadTimeoutType::Any,
            ..Default::default()
        },
    )?;

    // Stream a few seconds of a 5 Hz signal in real time.  Each one-second
    // batch is one packet of 5 samples; the ticks stay contiguous across
    // batches (batch k starts at start_tick + k*1000 ms), so the whole run is
    // an unbroken 5 Hz stream anchored to when the program started.
    let batches = 3;
    let start_tick = now_ticks();
    let to_timestamp = TickConverter::from_signal(&signal)?;
    println!(
        "Streaming {SAMPLES_PER_SECOND} samples/second, starting at {}",
        time_of_day(to_timestamp.tick_to_unix_nanos(start_tick))
    );
    for batch in 0..batches {
        let base_sample = batch * SAMPLES_PER_SECOND;
        let offset = start_tick + base_sample as i64 * TICKS_PER_SAMPLE;
        let samples: Vec<f64> = (0..SAMPLES_PER_SECOND)
            .map(|i| (2.0 * PI * ((base_sample + i) as f64 / 25.0)).sin())
            .collect();
        send_chunk(
            &signal,
            &domain_descriptor,
            &value_descriptor,
            offset,
            &samples,
        )?;

        let (values, ticks) = reader.read_with_domain(100, 1000)?;
        for (value, tick) in values.iter().zip(&ticks) {
            println!(
                "  {}  ->  {value:.4}",
                time_of_day(to_timestamp.tick_to_unix_nanos(*tick))
            );
        }
        std::thread::sleep(Duration::from_secs(1));
    }
    Ok(())
}

pub fn with_descriptor( context: &Context, descriptor: &DataDescriptor, parent: Option<&Component>, local_id: &str, class_name: Option<&str>, ) -> Result<SignalConfig>

Calls the openDAQ C function daqSignalConfig_createSignalWithDescriptor().

pub fn remove_related_signal(&self, signal: &Signal) -> Result<()>

Removes a signal from the list of related signal.

Parameters

• signal: The signal to be removed.

Errors

• OPENDAQ_ERR_NOTFOUND: if the signal is not part of the list.

Calls the openDAQ C function daqSignalConfig_removeRelatedSignal().

pub fn send_packet(&self, packet: &Packet) -> Result<()>

Sends a packet through all connections of the signal.

Parameters

• packet: The packet to be sent.

Calls the openDAQ C function daqSignalConfig_sendPacket().

Examples found in repository

examples/create_signal.rs (line 59)

fn send_chunk(
    signal: &SignalConfig,
    domain_descriptor: &DataDescriptor,
    value_descriptor: &DataDescriptor,
    offset: i64,
    samples: &[f64],
) -> opendaq::Result<()> {
    let count = samples.len();
    let domain_packet = DataPacket::new(domain_descriptor, count, offset)?;
    let packet = DataPacket::with_domain(&domain_packet, value_descriptor, count, 0)?;
    packet.set_data::<f64>(samples)?;
    signal.send_packet(&packet)
}

pub fn send_packet_and_steal_ref(&self, packet: &Packet) -> Result<()>

Sends a packet through all connections of the signal. Ownership of the packet is transfered.

Parameters

• packet: The packet to be sent. After calling the method, the packet should not be touched again. The ownership of the packet is taken by underlying connections and it could be destroyed before the function returns.

Calls the openDAQ C function daqSignalConfig_sendPacketAndStealRef().

pub fn send_packets(&self, packets: &[Packet]) -> Result<()>

Sends multiple packets through all connections of the signal.

Parameters

• packets: The packets to be sent. Sending multiple packets creates a single notification to input port.

Calls the openDAQ C function daqSignalConfig_sendPackets().

pub fn send_packets_and_steal_ref(&self, packets: &[Packet]) -> Result<()>

Sends multiple packets through all connections of the signal. Ownership of the packets is transfered.

Parameters

• packets: The packets to be sent. After calling the method, the packets should not be touched again. The ownership of the packets is taken by underlying connections and they could be destroyed before the function returns.

Calls the openDAQ C function daqSignalConfig_sendPacketsAndStealRef().

pub fn set_descriptor(&self, descriptor: &DataDescriptor) -> Result<()>

Sets the data descriptor.

Parameters

• descriptor: The data descriptor. Setting the data descriptor triggers a Descriptor changed event packet to be sent to all connections of the signal. If the signal is a domain signal of another, that signal also sends a Descriptor changed event to all its connections.

Calls the openDAQ C function daqSignalConfig_setDescriptor().

Examples found in repository

examples/create_signal.rs (line 85)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    let context = instance.context()?.expect("instance context");

    let domain_descriptor = {
        let builder = DataDescriptorBuilder::new()?;
        builder.set_sample_type(SampleType::Int64)?;
        builder.set_name("time")?;
        // Origin stays at the epoch; the wall-clock time lives in the ticks.
        builder.set_origin("1970-01-01T00:00:00Z")?;
        builder.set_tick_resolution(TICK_RESOLUTION)?;
        builder.set_unit(&Unit::new(-1, "s", "second", "time")?)?;
        builder.set_rule(&DataRule::linear(TICKS_PER_SAMPLE, 0)?)?;
        builder.build()?.expect("domain descriptor")
    };
    let value_descriptor = {
        let builder = DataDescriptorBuilder::new()?;
        builder.set_sample_type(SampleType::Float64)?;
        builder.set_name("values")?;
        builder.build()?.expect("value descriptor")
    };

    let domain_signal = SignalConfig::signal(&context, None, "time", None)?;
    domain_signal.set_descriptor(&domain_descriptor)?;
    let signal = SignalConfig::signal(&context, None, "values", None)?;
    signal.set_descriptor(&value_descriptor)?;
    signal.set_domain_signal(&domain_signal)?;

    let reader = StreamReader::<f64, i64>::with_options(
        &signal,
        StreamReaderOptions {
            timeout_type: ReadTimeoutType::Any,
            ..Default::default()
        },
    )?;

    // Stream a few seconds of a 5 Hz signal in real time.  Each one-second
    // batch is one packet of 5 samples; the ticks stay contiguous across
    // batches (batch k starts at start_tick + k*1000 ms), so the whole run is
    // an unbroken 5 Hz stream anchored to when the program started.
    let batches = 3;
    let start_tick = now_ticks();
    let to_timestamp = TickConverter::from_signal(&signal)?;
    println!(
        "Streaming {SAMPLES_PER_SECOND} samples/second, starting at {}",
        time_of_day(to_timestamp.tick_to_unix_nanos(start_tick))
    );
    for batch in 0..batches {
        let base_sample = batch * SAMPLES_PER_SECOND;
        let offset = start_tick + base_sample as i64 * TICKS_PER_SAMPLE;
        let samples: Vec<f64> = (0..SAMPLES_PER_SECOND)
            .map(|i| (2.0 * PI * ((base_sample + i) as f64 / 25.0)).sin())
            .collect();
        send_chunk(
            &signal,
            &domain_descriptor,
            &value_descriptor,
            offset,
            &samples,
        )?;

        let (values, ticks) = reader.read_with_domain(100, 1000)?;
        for (value, tick) in values.iter().zip(&ticks) {
            println!(
                "  {}  ->  {value:.4}",
                time_of_day(to_timestamp.tick_to_unix_nanos(*tick))
            );
        }
        std::thread::sleep(Duration::from_secs(1));
    }
    Ok(())
}

pub fn set_domain_signal(&self, signal: &Signal) -> Result<()>

Sets the domain signal reference.

Parameters

• signal: The domain signal. Setting a new domain signal triggers a Descriptor changed event packet to be sent to all connections of the signal.

Calls the openDAQ C function daqSignalConfig_setDomainSignal().

Examples found in repository

examples/create_signal.rs (line 88)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    let context = instance.context()?.expect("instance context");

    let domain_descriptor = {
        let builder = DataDescriptorBuilder::new()?;
        builder.set_sample_type(SampleType::Int64)?;
        builder.set_name("time")?;
        // Origin stays at the epoch; the wall-clock time lives in the ticks.
        builder.set_origin("1970-01-01T00:00:00Z")?;
        builder.set_tick_resolution(TICK_RESOLUTION)?;
        builder.set_unit(&Unit::new(-1, "s", "second", "time")?)?;
        builder.set_rule(&DataRule::linear(TICKS_PER_SAMPLE, 0)?)?;
        builder.build()?.expect("domain descriptor")
    };
    let value_descriptor = {
        let builder = DataDescriptorBuilder::new()?;
        builder.set_sample_type(SampleType::Float64)?;
        builder.set_name("values")?;
        builder.build()?.expect("value descriptor")
    };

    let domain_signal = SignalConfig::signal(&context, None, "time", None)?;
    domain_signal.set_descriptor(&domain_descriptor)?;
    let signal = SignalConfig::signal(&context, None, "values", None)?;
    signal.set_descriptor(&value_descriptor)?;
    signal.set_domain_signal(&domain_signal)?;

    let reader = StreamReader::<f64, i64>::with_options(
        &signal,
        StreamReaderOptions {
            timeout_type: ReadTimeoutType::Any,
            ..Default::default()
        },
    )?;

    // Stream a few seconds of a 5 Hz signal in real time.  Each one-second
    // batch is one packet of 5 samples; the ticks stay contiguous across
    // batches (batch k starts at start_tick + k*1000 ms), so the whole run is
    // an unbroken 5 Hz stream anchored to when the program started.
    let batches = 3;
    let start_tick = now_ticks();
    let to_timestamp = TickConverter::from_signal(&signal)?;
    println!(
        "Streaming {SAMPLES_PER_SECOND} samples/second, starting at {}",
        time_of_day(to_timestamp.tick_to_unix_nanos(start_tick))
    );
    for batch in 0..batches {
        let base_sample = batch * SAMPLES_PER_SECOND;
        let offset = start_tick + base_sample as i64 * TICKS_PER_SAMPLE;
        let samples: Vec<f64> = (0..SAMPLES_PER_SECOND)
            .map(|i| (2.0 * PI * ((base_sample + i) as f64 / 25.0)).sin())
            .collect();
        send_chunk(
            &signal,
            &domain_descriptor,
            &value_descriptor,
            offset,
            &samples,
        )?;

        let (values, ticks) = reader.read_with_domain(100, 1000)?;
        for (value, tick) in values.iter().zip(&ticks) {
            println!(
                "  {}  ->  {value:.4}",
                time_of_day(to_timestamp.tick_to_unix_nanos(*tick))
            );
        }
        std::thread::sleep(Duration::from_secs(1));
    }
    Ok(())
}

pub fn set_last_value(&self, last_value: impl Into<Value>) -> Result<()>

Sets the last value of the signal.

Parameters

• last_value: The lastValue. This method is used to manually set the last value of the signal. Useful when automatic calculation of last value is disabled, usually due to performance reasons.

Calls the openDAQ C function daqSignalConfig_setLastValue().

pub fn set_related_signals(&self, signals: &[Signal]) -> Result<()>

Sets the list of related signals.

Parameters

• signals: The list of related signals.

Calls the openDAQ C function daqSignalConfig_setRelatedSignals().

Methods from Deref<Target = Signal>

pub fn connections(&self) -> Result<Vec<Connection>>

Gets the list of connections to input ports formed by the signal.

Returns

• connections: The list of connections.

Calls the openDAQ C function daqSignal_getConnections().

pub fn descriptor(&self) -> Result<Option<DataDescriptor>>

Gets the signal’s data descriptor.

Returns

• descriptor: The signal’s data descriptor. The descriptor contains metadata about the signal, providing information about its name, description,… and defines how the data in it’s packet’s buffers should be interpreted.

Calls the openDAQ C function daqSignal_getDescriptor().

Examples found in repository

examples/streamreader_2d_signal.rs (line 31)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    instance.add_device("daqref://device0")?;

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;
    channel.set_property_value("Waveform", 0)?; // 0 = Sine
    channel.set_property_value("Frequency", 125.0)?;
    channel.set_property_value("Amplitude", 5.0)?;
    channel.set_property_value("NoiseAmplitude", 0.1)?;

    let fft = instance
        .add_function_block("RefFBModuleFFT")?
        .expect("FFT function block not found");
    fft.set_property_value("BlockSize", 16)?;
    fft.input_ports()?[0].connect(&channel.signals()?[0])?;
    let signal = &fft.signals()?[0];

    // Wait for the block to publish its output descriptor, then read the
    // frequency axis off the value descriptor's single dimension.
    std::thread::sleep(std::time::Duration::from_secs(1));
    let descriptor = signal
        .descriptor()?
        .expect("output descriptor not published");
    let dimension = &descriptor.dimensions()?[0];
    let axis: Vec<f64> = dimension
        .labels()?
        .iter()
        .map(|label| label.as_f64().expect("numeric frequency label"))
        .collect();

    // Read 5 samples.  Each sample is a full spectrum, so `read` returns a
    // (samples x bins) matrix; retry until 5 rows have arrived (the first
    // reads may come back short while the stream warms up).
    let reader = StreamReader::<f64>::new(signal)?;
    let mut spectra = reader.read(5, 1000)?;
    for _ in 0..50 {
        if spectra.sample_count() == 5 {
            break;
        }
        spectra = reader.read(5, 1000)?;
    }

    // Print the axis down the rows and one column of amplitudes per sample.
    // The 125 Hz tone dominates a single bin (~5, our amplitude) while noise
    // fills the rest with small values.  The reference block labels its bins
    // one step (31.25 Hz) below the true bin centre, so the tone lands in the
    // 93.75 Hz row.
    println!(
        "{} spectrum, {} bins, {}\n",
        dimension.name()?,
        axis.len(),
        dimension.unit()?.expect("dimension unit").symbol()?
    );
    print!("{:>12}", "freq (Hz)");
    for sample in 1..=spectra.sample_count() {
        print!("{:>14}", format!("sample {sample}"));
    }
    println!();
    let rows: Vec<&[f64]> = spectra.rows().collect();
    for (bin, frequency) in axis.iter().enumerate() {
        print!("{frequency:>12.2}");
        for row in &rows {
            print!("{:>14.4}", row[bin]);
        }
        println!();
    }
    Ok(())
}

pub fn domain_signal(&self) -> Result<Option<Signal>>

Gets the signal that carries its domain data.

Returns

• signal: The domain signal. The domain signal contains domain (most often time) data that is used to interpret a signal’s data in a given domain. It has the same sampling rate as the signal.

Calls the openDAQ C function daqSignal_getDomainSignal().

pub fn last_value(&self) -> Result<Value>

Gets the signal last value.

Returns

• value: The IBaseObject value can be a nullptr if there is no value, or if the data type is not supported by the function. If a value is assigned, it can be cast based on the signal description to IFloat if the type is Float32 or Float64, to IInteger if the type is Int8 through Int64 or UInt8 through UInt64, to IComplexNumber if the type is ComplexFloat32 or ComplexFloat64, to IRange if the type is RangeInt64, to IString if the type is String, to IStruct if the type is Struct, and to IList of the forementioned types if there is exactly one dimension. For String type signals in binary data packets, the string data must be encoded as UTF-8 strings. The string length is determined by the sample size, and the string does not need to be null-terminated. The method extracts the string value from the packet data and returns it as an IString object.

Calls the openDAQ C function daqSignal_getLastValue().

pub fn public(&self) -> Result<bool>

Returns true if the signal is public; false otherwise.

Returns

• is_public: True if the signal is public; false otherwise. Public signals are visible to clients connected to the device, and are streamed.

Calls the openDAQ C function daqSignal_getPublic().

pub fn related_signals(&self) -> Result<Vec<Signal>>

Gets a list of related signals.

Returns

• signals: The list of related signals. Signals within the related signals list are facilitate the interpretation of a given signal’s data, or are otherwise relevant when working with the signal.

Calls the openDAQ C function daqSignal_getRelatedSignals().

pub fn streamed(&self) -> Result<bool>

Returns true if the signal is streamed; false otherwise.

Returns

• streamed: True if the signal is streamed; false otherwise. A streamed signal receives packets from a streaming server and forwards packets on the signal path. Method always sets streamed parameter to False if the signal is local to the current Instance.

Calls the openDAQ C function daqSignal_getStreamed().

pub fn set_public(&self, is_public: bool) -> Result<()>

Sets the signal to be either public or private.

Parameters

• is_public: If false, the signal is set to private; if true, the signal is set to be public. Public signals are visible to clients connected to the device, and are streamed.

Calls the openDAQ C function daqSignal_setPublic().

pub fn set_streamed(&self, streamed: bool) -> Result<()>

Sets the signal to be either streamed or not.

Parameters

• streamed: The new streamed state of the signal. A streamed signal receives packets from a streaming server and forwards packets on the signal path. Setting the “Streamed” flag has no effect if the signal is local to the current Instance. Method returns OPENDAQ_IGNORED if that is the case.

Calls the openDAQ C function daqSignal_setStreamed().

Methods from Deref<Target = Component>

pub fn find_component(&self, id: &str) -> Result<Option<Component>>

Finds the component (signal/device/function block) with the specified (global) id.

Parameters

• id: The id of the component to search for.

Returns

• out_component: The resulting component. If the component parameter is true, the starting component is the root device. The id provided should be in relative form from the starting component. E.g., to find a signal in the starting component, the id should be in the form of “Dev/dev_id/Ch/ch_id/Sig/sig_id.

Calls the openDAQ C function daqComponent_findComponent().

Examples found in repository

examples/multireader.rs (line 22)

fn find_channel(instance: &Instance, path: &str) -> opendaq::Result<Channel> {
    instance
        .find_component(path)?
        .unwrap_or_else(|| panic!("channel {path} not found"))
        .cast::<Channel>()
}

examples/streamreader.rs (line 13)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    instance.add_device("daqref://device0")?;

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;
    let signal = &channel.signals()?[0];

    let reader = StreamReader::<f64>::new(signal)?;
    println!("some samples: {:?}", reader.read(100, 1000)?.values());
    println!("and more samples: {:?}", reader.read(100, 1000)?.values());
    println!("and more still: {:?}", reader.read(100, 1000)?.values());
    Ok(())
}

examples/streamreader_with_timestamps.rs (line 44)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    instance.add_device("daqref://device0")?;

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;
    let signal = &channel.signals()?[0];

    let reader = StreamReader::<f64>::new(signal)?;
    let converter = TickConverter::from_signal(signal)?;

    let (values, ticks) = reader.read_with_domain(10, 2000)?;
    println!("Read {} samples:", values.sample_count());
    for (value, tick) in values.iter().zip(&ticks) {
        println!(
            "  {value:.6} @ {}",
            timestamp_to_string(converter.tick_to_unix_nanos(*tick))
        );
    }
    Ok(())
}

examples/core_events.rs (line 15)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    instance.add_device("daqref://device0")?;

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;

    let core_event = instance
        .context()?
        .expect("context")
        .on_core_event()?
        .expect("core event");

    // The handler may run on openDAQ's own threads.  Its args come in as a
    // generic object; cast to CoreEventArgs for the event name and the
    // per-event-type parameters ("Name" holds the changed property's name).
    let handler = core_event.subscribe(|_sender, args| {
        let Some(args) = args else { return };
        let Ok(event) = args.cast::<CoreEventArgs>() else {
            return;
        };
        let name = event.event_name().unwrap_or_default();
        let parameters = event.parameters().unwrap_or_default();
        let changed = parameters
            .get("Name")
            .map(ToString::to_string)
            .unwrap_or_default();
        println!("  {name}: {changed}");
    })?;

    // While subscribed, each property change is reported by the handler above.
    println!("subscribed:");
    channel.set_property_value("Frequency", 25.0)?;
    channel.set_property_value("Amplitude", 7.5)?;

    // Unsubscribing removes the handler; further changes fire nothing.
    core_event.unsubscribe(&handler)?;
    println!("unsubscribed (no lines expected below):");
    channel.set_property_value("Frequency", 50.0)?;

    Ok(())
}

examples/smoke.rs (line 19)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;

    println!("Available devices:");
    for info in instance.available_devices()? {
        println!(" - {}: {}", info.connection_string()?, info.name()?);
    }

    let device = instance.add_device("daqref://device0")?.expect("device");
    println!("Added device: {}", device.name()?);

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;
    let signal = &channel.signals()?[0];

    // Batched property updates.
    {
        let batch = BatchedPropertyUpdate::new(&[&device, &channel])?;
        device.set_property_value("GlobalSampleRate", 1000)?;
        channel.set_property_value("Frequency", 50.0)?;
        batch.commit()?;
    }
    println!(
        "GlobalSampleRate = {}",
        device.property_value("GlobalSampleRate")?
    );

    // Stream reading with domain + tick conversion.
    let reader = StreamReader::<f64>::new(signal)?;
    let (samples, ticks) = reader.read_with_domain(100, 2000)?;
    println!(
        "read {} samples, {} ticks",
        samples.sample_count(),
        ticks.len()
    );
    let converter = TickConverter::from_signal(signal)?;
    if let Some(first) = ticks.first() {
        println!(
            "first tick {} -> {:?}",
            first,
            converter.tick_to_system_time(*first)
        );
    }

    // Callables: a Rust closure as an openDAQ function, called through openDAQ.
    let sum = FunctionObject::from_fn(|args| {
        let a = args[0].as_i64().unwrap_or(0);
        let b = args[1].as_i64().unwrap_or(0);
        Ok(Value::from(a + b))
    })?;
    let result = sum.call(&[Value::from(20), Value::from(22)])?;
    println!("sum(20, 22) = {result}");

    // Events: subscribe to property changes on the channel.
    let events = channel
        .on_property_value_write("Amplitude")?
        .expect("event");
    let handler = events.subscribe(|_sender, args| {
        if let Some(args) = args {
            println!("  event fired: {args}");
        }
    })?;
    channel.set_property_value("Amplitude", 2.5)?;
    events.unsubscribe(&handler)?;
    channel.set_property_value("Amplitude", 1.0)?;
    println!("Amplitude = {}", channel.property_value("Amplitude")?);

    Ok(())
}

examples/add_function_block.rs (line 31)

fn main() -> opendaq::Result<()> {
    // Instance::new() already loads the bundled modules; build from an
    // InstanceBuilder when you want to control the module search path.
    let builder = InstanceBuilder::new()?;
    // The bundled modules (reference device, function blocks, streaming):
    let bundled = opendaq::native_library_directory().expect("native libraries");
    builder.set_module_path(&bundled.to_string_lossy())?;
    // Your own modules folder:
    // builder.add_module_path("/path/to/your/modules")?;
    let instance = Instance::from_builder(&builder)?;
    instance.add_device("daqref://device0")?;

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;
    channel.set_property_value("Amplitude", 5.0)?;
    channel.set_property_value("DC", 1.0)?;

    let statistics = instance
        .add_function_block("RefFBModuleStatistics")?
        .expect("statistics function block");
    statistics.set_property_value("BlockSize", 100)?;

    let status = statistics.status_container()?.expect("status container");
    println!(
        "Before connect: {} ({})",
        status.status("ComponentStatus")?.expect("status").value()?,
        status.status_message("ComponentStatus")?
    );

    let port = &statistics.input_ports()?[0];
    let signal = &channel.signals()?[0];
    port.connect(signal)?;

    println!(
        "After connect:  {} ({})",
        status.status("ComponentStatus")?.expect("status").value()?,
        status.status_message("ComponentStatus")?
    );

    let outputs = statistics.signals()?;
    let avg = signal_by_local_id(&outputs, "avg")?.expect("avg signal");
    let rms = signal_by_local_id(&outputs, "rms")?.expect("rms signal");
    let reader = MultiReader::<f64>::new(&[avg, rms])?;

    // The first reads may return nothing while the block waits for a complete
    // input descriptor (the multi reader by default doesn't skip events), so
    // retry until samples arrive.
    for _attempt in 0..20 {
        let values = reader.read(5, 1000)?;
        if !values[0].is_empty() {
            println!("{:>10}{:>12}", "avg", "rms");
            for (a, r) in values[0].iter().zip(&values[1]) {
                println!("{a:>10.4}{r:>12.4}");
            }
            return Ok(());
        }
    }
    println!("Statistics block produced no samples in time.");
    Ok(())
}

Additional examples can be found in:

• examples/reader_invalidation_recovery.rs
• examples/streamreader_2d_signal.rs
• examples/stateful_callback.rs
• examples/reading_incompatible_signals_together.rs

pub fn active(&self) -> Result<bool>

Returns true if the component is active; false otherwise.

Returns

• active: True if the component is active; false otherwise. A component is active if its local active state is true and its parent is active. An active component acquires data, performs calculations and send packets on the signal path.

Calls the openDAQ C function daqComponent_getActive().

pub fn context(&self) -> Result<Option<Context>>

Gets the context object.

Returns

• context: The context object.

Calls the openDAQ C function daqComponent_getContext().

Examples found in repository

examples/core_events.rs (line 20)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    instance.add_device("daqref://device0")?;

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;

    let core_event = instance
        .context()?
        .expect("context")
        .on_core_event()?
        .expect("core event");

    // The handler may run on openDAQ's own threads.  Its args come in as a
    // generic object; cast to CoreEventArgs for the event name and the
    // per-event-type parameters ("Name" holds the changed property's name).
    let handler = core_event.subscribe(|_sender, args| {
        let Some(args) = args else { return };
        let Ok(event) = args.cast::<CoreEventArgs>() else {
            return;
        };
        let name = event.event_name().unwrap_or_default();
        let parameters = event.parameters().unwrap_or_default();
        let changed = parameters
            .get("Name")
            .map(ToString::to_string)
            .unwrap_or_default();
        println!("  {name}: {changed}");
    })?;

    // While subscribed, each property change is reported by the handler above.
    println!("subscribed:");
    channel.set_property_value("Frequency", 25.0)?;
    channel.set_property_value("Amplitude", 7.5)?;

    // Unsubscribing removes the handler; further changes fire nothing.
    core_event.unsubscribe(&handler)?;
    println!("unsubscribed (no lines expected below):");
    channel.set_property_value("Frequency", 50.0)?;

    Ok(())
}

examples/download_log_files.rs (line 47)

fn main() -> opendaq::Result<()> {
    let work_dir = std::env::temp_dir().join("opendaq-rs-log-example");
    let downloads = work_dir.join("downloads");
    fs::create_dir_all(&downloads).expect("create working directories");
    let device_log = work_dir.join("ref_device_simulator.log");
    let device_log_path = device_log.to_string_lossy().into_owned();

    // Start from a clean log so the reported size reflects only this run.
    let _ = fs::remove_file(&device_log);

    let builder = InstanceBuilder::new()?;
    // Find the bundled modules.
    let modules = opendaq::native_library_directory().expect("bundled native modules");
    builder.set_module_path(&modules.to_string_lossy())?;
    builder.add_logger_sink(&LoggerSink::basic_file(&device_log_path)?)?;
    let instance = Instance::from_builder(&builder)?;

    // The reference device reads these two properties from its add-device config.
    let config = PropertyObject::new()?;
    config.add_property(&Property::bool("EnableLogging", true, true)?)?;
    config.add_property(&Property::string("LoggingPath", &device_log_path, true)?)?;

    let device = instance
        .add_device_with("daqref://device0", Some(&config))?
        .expect("reference device");

    // Flush the logger so everything buffered so far is actually on disk
    // before we read it.
    let context = instance.context()?.expect("instance context");
    context.logger()?.expect("instance logger").flush()?;

    let infos = device.log_file_infos()?;
    if infos.is_empty() {
        println!("Device exposes no log files.");
        return Ok(());
    }
    println!("Device exposes {} log file(s):", infos.len());
    println!();
    for info in infos {
        let id = info.id()?;
        let destination = downloads.join(info.name()?);
        println!("- {}", info.name()?);
        println!("    id:            {id}");
        println!("    size:          {} bytes", info.size()?);
        println!("    encoding:      {}", info.encoding()?);
        println!("    last-modified: {}", info.last_modified()?);
        // Size/offset let you fetch just part of a file; here, a short head preview.
        println!("    preview:       {:?}", device.log_with(&id, 60, 0)?);
        // Plain `log` fetches the whole file in one call.
        let content = device.log(&id)?;
        fs::write(&destination, &content).expect("write the downloaded log");
        println!(
            "    downloaded {} chars -> {}",
            content.len(),
            destination.display()
        );
        println!();
    }
    Ok(())
}

examples/create_signal.rs (line 64)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    let context = instance.context()?.expect("instance context");

    let domain_descriptor = {
        let builder = DataDescriptorBuilder::new()?;
        builder.set_sample_type(SampleType::Int64)?;
        builder.set_name("time")?;
        // Origin stays at the epoch; the wall-clock time lives in the ticks.
        builder.set_origin("1970-01-01T00:00:00Z")?;
        builder.set_tick_resolution(TICK_RESOLUTION)?;
        builder.set_unit(&Unit::new(-1, "s", "second", "time")?)?;
        builder.set_rule(&DataRule::linear(TICKS_PER_SAMPLE, 0)?)?;
        builder.build()?.expect("domain descriptor")
    };
    let value_descriptor = {
        let builder = DataDescriptorBuilder::new()?;
        builder.set_sample_type(SampleType::Float64)?;
        builder.set_name("values")?;
        builder.build()?.expect("value descriptor")
    };

    let domain_signal = SignalConfig::signal(&context, None, "time", None)?;
    domain_signal.set_descriptor(&domain_descriptor)?;
    let signal = SignalConfig::signal(&context, None, "values", None)?;
    signal.set_descriptor(&value_descriptor)?;
    signal.set_domain_signal(&domain_signal)?;

    let reader = StreamReader::<f64, i64>::with_options(
        &signal,
        StreamReaderOptions {
            timeout_type: ReadTimeoutType::Any,
            ..Default::default()
        },
    )?;

    // Stream a few seconds of a 5 Hz signal in real time.  Each one-second
    // batch is one packet of 5 samples; the ticks stay contiguous across
    // batches (batch k starts at start_tick + k*1000 ms), so the whole run is
    // an unbroken 5 Hz stream anchored to when the program started.
    let batches = 3;
    let start_tick = now_ticks();
    let to_timestamp = TickConverter::from_signal(&signal)?;
    println!(
        "Streaming {SAMPLES_PER_SECOND} samples/second, starting at {}",
        time_of_day(to_timestamp.tick_to_unix_nanos(start_tick))
    );
    for batch in 0..batches {
        let base_sample = batch * SAMPLES_PER_SECOND;
        let offset = start_tick + base_sample as i64 * TICKS_PER_SAMPLE;
        let samples: Vec<f64> = (0..SAMPLES_PER_SECOND)
            .map(|i| (2.0 * PI * ((base_sample + i) as f64 / 25.0)).sin())
            .collect();
        send_chunk(
            &signal,
            &domain_descriptor,
            &value_descriptor,
            offset,
            &samples,
        )?;

        let (values, ticks) = reader.read_with_domain(100, 1000)?;
        for (value, tick) in values.iter().zip(&ticks) {
            println!(
                "  {}  ->  {value:.4}",
                time_of_day(to_timestamp.tick_to_unix_nanos(*tick))
            );
        }
        std::thread::sleep(Duration::from_secs(1));
    }
    Ok(())
}

pub fn description(&self) -> Result<String>

Gets the description of the component.

Returns

• description: The description of the component. Empty if not configured. The object that implements this interface defines how the description is specified.

Calls the openDAQ C function daqComponent_getDescription().

pub fn global_id(&self) -> Result<String>

Gets the global ID of the component.

Returns

• global_id: The global ID of the component. Represents the identifier that is globally unique. Globally unique identifier is composed from local identifiers from the parent components separated by ‘/’ character. Device component must make sure that its ID is globally unique.

Calls the openDAQ C function daqComponent_getGlobalId().

pub fn local_active(&self) -> Result<bool>

Returns true if the component is local active; false otherwise.

Returns

• local_active: True if the component is local active; false otherwise. An active component acquires data, performs calculations and send packets on the signal path. Note that is local active is True, the component may still be inactive if its parents are inactive.

Calls the openDAQ C function daqComponent_getLocalActive().

pub fn local_id(&self) -> Result<String>

Gets the local ID of the component.

Returns

• local_id: The local ID of the component. Represents the identifier that is unique in a relation to the parent component. There is no predefined format for local ID. It is a string defined by its parent component.

Calls the openDAQ C function daqComponent_getLocalId().

Examples found in repository

examples/add_function_block.rs (line 11)

fn signal_by_local_id(signals: &[Signal], local_id: &str) -> opendaq::Result<Option<Signal>> {
    for signal in signals {
        if signal.local_id()? == local_id {
            return Ok(Some(signal.clone()));
        }
    }
    Ok(None)
}

examples/search_filter.rs (line 25)

fn show<T: Interface>(label: &str, components: Vec<T>) -> opendaq::Result<()> {
    let ids = components
        .iter()
        .map(|c| c.to_base_object().cast::<Component>()?.local_id())
        .collect::<opendaq::Result<Vec<_>>>()?;
    let listing = if ids.is_empty() {
        "(none)".to_string()
    } else {
        ids.join(", ")
    };
    println!("{label}\n    => {listing}\n");
    Ok(())
}

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    instance.add_device("daqref://device0")?;
    let root = instance.root_device()?.expect("root device");

    // Give a couple of channels some tags, so the tag filter has something to
    // match.  (RefCh0 and RefCh1 come from the reference device unlabelled.)
    let everything = SearchFilter::recursive(&SearchFilter::any()?)?;
    for channel in root.channels_with(Some(&everything))? {
        let tags = channel.tags()?.expect("tags").cast::<TagsPrivate>()?;
        tags.add("analog")?;
        if channel.local_id()? == "RefCh0" {
            tags.add("primary")?;
        }
    }

    show(
        "channels, no filter (immediate children only)",
        root.channels()?,
    )?;

    show(
        "channels, recursive(any)",
        root.channels_with(Some(&SearchFilter::recursive(&SearchFilter::any()?)?))?,
    )?;

    show(
        "channels, recursive(id = RefCh1)",
        root.channels_with(Some(&SearchFilter::recursive(&SearchFilter::local_id(
            "RefCh1",
        )?)?))?,
    )?;

    let ai0_or_ai1 = SearchFilter::or(
        &SearchFilter::local_id("AI0")?,
        &SearchFilter::local_id("AI1")?,
    )?;
    show(
        "signals, recursive(id = AI0 OR id = AI1)",
        root.signals_with(Some(&SearchFilter::recursive(&ai0_or_ai1)?))?,
    )?;

    let not_ref_ch1 = SearchFilter::not(&SearchFilter::local_id("RefCh1")?)?;
    show(
        "channels, recursive(NOT id = RefCh1)",
        root.channels_with(Some(&SearchFilter::recursive(&not_ref_ch1)?))?,
    )?;

    let analog_and_not_ref_ch1 = SearchFilter::and(
        &SearchFilter::required_tags(vec!["analog"])?,
        &SearchFilter::not(&SearchFilter::local_id("RefCh1")?)?,
    )?;
    show(
        "channels, recursive(tag = analog AND NOT id = RefCh1)",
        root.channels_with(Some(&SearchFilter::recursive(&analog_and_not_ref_ch1)?))?,
    )?;

    Ok(())
}

examples/component_tree.rs (line 64)

fn draw_children(component: &Component, prefix: &str) -> opendaq::Result<()> {
    let kids = children(component)?;
    for (index, child) in kids.iter().enumerate() {
        let last = index + 1 == kids.len();
        let child_prefix = format!("{prefix}{}", if last { "   " } else { "│  " });
        println!(
            "{prefix}{}{} : {} ({})",
            if last { "└─ " } else { "├─ " },
            child.name()?,
            type_label(child),
            child.local_id()?
        );
        draw_properties(child, &child_prefix)?;
        draw_children(child, &child_prefix)?;
    }
    Ok(())
}

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    instance.add_device("daqref://device0")?;

    let root = instance.root_device()?.expect("root device");
    println!(
        "{} : {} ({})",
        root.name()?,
        type_label(&root),
        root.local_id()?
    );
    draw_properties(&root, "")?;
    draw_children(&root, "")
}

pub fn locked_attributes(&self) -> Result<Vec<String>>

Gets a list of the component’s locked attributes. The locked attributes cannot be modified via their respective setters.

Returns

• attributes: A list of strings containing the names of locked attributes in capital case (eg. “Name”, “Description”).

Calls the openDAQ C function daqComponent_getLockedAttributes().

pub fn name(&self) -> Result<String>

Gets the name of the component.

Returns

• name: The name of the component. Local ID if name is not configured. The object that implements this interface defines how the name is specified.

Calls the openDAQ C function daqComponent_getName().

Examples found in repository

examples/batch_properties.rs (line 10)

fn show_settings(label: &str, channel: &Channel) -> opendaq::Result<()> {
    println!(
        "{label} {}:  Amplitude={}  Frequency={}  Waveform={}",
        channel.name()?,
        channel.property_value("Amplitude")?,
        channel.property_value("Frequency")?,
        channel.property_value("Waveform")?
    );
    Ok(())
}

examples/component_tree.rs (line 62)

fn draw_children(component: &Component, prefix: &str) -> opendaq::Result<()> {
    let kids = children(component)?;
    for (index, child) in kids.iter().enumerate() {
        let last = index + 1 == kids.len();
        let child_prefix = format!("{prefix}{}", if last { "   " } else { "│  " });
        println!(
            "{prefix}{}{} : {} ({})",
            if last { "└─ " } else { "├─ " },
            child.name()?,
            type_label(child),
            child.local_id()?
        );
        draw_properties(child, &child_prefix)?;
        draw_children(child, &child_prefix)?;
    }
    Ok(())
}

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    instance.add_device("daqref://device0")?;

    let root = instance.root_device()?.expect("root device");
    println!(
        "{} : {} ({})",
        root.name()?,
        type_label(&root),
        root.local_id()?
    );
    draw_properties(&root, "")?;
    draw_children(&root, "")
}

examples/connect_view_only_client.rs (line 28)

fn probe_view_only_device(device: &Device) -> opendaq::Result<()> {
    println!("Connected to {} as a view-only client.", device.name()?);
    println!("Visible signals: {}", device.signals_recursive()?.len());
    match first_writable_property_name(device)? {
        Some(name) => {
            // Write the property's current value back to itself: harmless if
            // it were allowed, but a view-only connection must reject it.
            let value = device.property_value(&name)?;
            match device.set_property_value(&name, value) {
                Ok(()) => println!("Unexpected: writing {name:?} was allowed."),
                Err(err) => {
                    println!("Write to {name:?} refused, as expected for view-only: {err}")
                }
            }
        }
        None => println!("Device exposes no writable property to probe."),
    }
    Ok(())
}

examples/smoke.rs (line 16)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;

    println!("Available devices:");
    for info in instance.available_devices()? {
        println!(" - {}: {}", info.connection_string()?, info.name()?);
    }

    let device = instance.add_device("daqref://device0")?.expect("device");
    println!("Added device: {}", device.name()?);

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;
    let signal = &channel.signals()?[0];

    // Batched property updates.
    {
        let batch = BatchedPropertyUpdate::new(&[&device, &channel])?;
        device.set_property_value("GlobalSampleRate", 1000)?;
        channel.set_property_value("Frequency", 50.0)?;
        batch.commit()?;
    }
    println!(
        "GlobalSampleRate = {}",
        device.property_value("GlobalSampleRate")?
    );

    // Stream reading with domain + tick conversion.
    let reader = StreamReader::<f64>::new(signal)?;
    let (samples, ticks) = reader.read_with_domain(100, 2000)?;
    println!(
        "read {} samples, {} ticks",
        samples.sample_count(),
        ticks.len()
    );
    let converter = TickConverter::from_signal(signal)?;
    if let Some(first) = ticks.first() {
        println!(
            "first tick {} -> {:?}",
            first,
            converter.tick_to_system_time(*first)
        );
    }

    // Callables: a Rust closure as an openDAQ function, called through openDAQ.
    let sum = FunctionObject::from_fn(|args| {
        let a = args[0].as_i64().unwrap_or(0);
        let b = args[1].as_i64().unwrap_or(0);
        Ok(Value::from(a + b))
    })?;
    let result = sum.call(&[Value::from(20), Value::from(22)])?;
    println!("sum(20, 22) = {result}");

    // Events: subscribe to property changes on the channel.
    let events = channel
        .on_property_value_write("Amplitude")?
        .expect("event");
    let handler = events.subscribe(|_sender, args| {
        if let Some(args) = args {
            println!("  event fired: {args}");
        }
    })?;
    channel.set_property_value("Amplitude", 2.5)?;
    events.unsubscribe(&handler)?;
    channel.set_property_value("Amplitude", 1.0)?;
    println!("Amplitude = {}", channel.property_value("Amplitude")?);

    Ok(())
}

pub fn on_component_core_event(&self) -> Result<Option<Event>>

Gets the Core Event object that triggers whenever a change to this component happens within the openDAQ core structure.

Returns

• event: The Core Event object. The event triggers with a Component reference and a CoreEventArgs object as arguments. The Core Event is triggered on various changes to the openDAQ Components. This includes changes to property values, addition/removal of child components, connecting signals to input ports and others. The event type can be identified via the event ID available within the CoreEventArgs object. Each event type has a set of predetermined parameters available in the parameters field of the arguments. These can be used by any openDAQ server, or other listener to react to changes within the core structure.

Calls the openDAQ C function daqComponent_getOnComponentCoreEvent().

pub fn operation_mode(&self) -> Result<OperationModeType>

Gets the operation mode of the device.

Returns

• mode_type: The current operation mode.

Calls the openDAQ C function daqComponent_getOperationMode().

Examples found in repository

examples/device_lock_and_operation_mode.rs (line 18)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    let device = instance
        .add_device("daqref://device0")?
        .expect("reference device");

    let modes: Vec<String> = device
        .available_operation_modes()?
        .into_iter()
        .filter_map(|mode| OperationModeType::from_raw(mode as u32))
        .map(|mode| format!("{mode:?}"))
        .collect();
    println!("Available operation modes: {}", modes.join(", "));
    println!("Current operation mode:    {:?}", device.operation_mode()?);

    device.set_operation_mode(OperationModeType::Operation)?;
    device.lock()?;
    println!("After setting Operation:   {:?}", device.operation_mode()?);
    println!("Device locked: {}", device.is_locked()?);

    device.unlock()?;
    device.set_operation_mode(OperationModeType::SafeOperation)?;
    println!();
    println!("Device locked: {}", device.is_locked()?);
    println!("Final operation mode:      {:?}", device.operation_mode()?);
    Ok(())
}

pub fn parent(&self) -> Result<Option<Component>>

Gets the parent of the component.

Returns

• parent: The parent of the component. Every openDAQ component has a parent, except for instance. Parent should be passed as a parameter to the constructor/factory. Once the component is created, the parent cannot be changed.

Calls the openDAQ C function daqComponent_getParent().

pub fn parent_active(&self) -> Result<bool>

Returns true if the component’s parent is active; false otherwise.

Returns

• parent_active: True if the component’s parent is active; false otherwise.

Calls the openDAQ C function daqComponent_getParentActive().

pub fn status_container(&self) -> Result<Option<ComponentStatusContainer>>

Gets the container of Component statuses.

Returns

• status_container: The container of Component statuses.

Calls the openDAQ C function daqComponent_getStatusContainer().

Examples found in repository

examples/add_function_block.rs (line 42)

fn main() -> opendaq::Result<()> {
    // Instance::new() already loads the bundled modules; build from an
    // InstanceBuilder when you want to control the module search path.
    let builder = InstanceBuilder::new()?;
    // The bundled modules (reference device, function blocks, streaming):
    let bundled = opendaq::native_library_directory().expect("native libraries");
    builder.set_module_path(&bundled.to_string_lossy())?;
    // Your own modules folder:
    // builder.add_module_path("/path/to/your/modules")?;
    let instance = Instance::from_builder(&builder)?;
    instance.add_device("daqref://device0")?;

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;
    channel.set_property_value("Amplitude", 5.0)?;
    channel.set_property_value("DC", 1.0)?;

    let statistics = instance
        .add_function_block("RefFBModuleStatistics")?
        .expect("statistics function block");
    statistics.set_property_value("BlockSize", 100)?;

    let status = statistics.status_container()?.expect("status container");
    println!(
        "Before connect: {} ({})",
        status.status("ComponentStatus")?.expect("status").value()?,
        status.status_message("ComponentStatus")?
    );

    let port = &statistics.input_ports()?[0];
    let signal = &channel.signals()?[0];
    port.connect(signal)?;

    println!(
        "After connect:  {} ({})",
        status.status("ComponentStatus")?.expect("status").value()?,
        status.status_message("ComponentStatus")?
    );

    let outputs = statistics.signals()?;
    let avg = signal_by_local_id(&outputs, "avg")?.expect("avg signal");
    let rms = signal_by_local_id(&outputs, "rms")?.expect("rms signal");
    let reader = MultiReader::<f64>::new(&[avg, rms])?;

    // The first reads may return nothing while the block waits for a complete
    // input descriptor (the multi reader by default doesn't skip events), so
    // retry until samples arrive.
    for _attempt in 0..20 {
        let values = reader.read(5, 1000)?;
        if !values[0].is_empty() {
            println!("{:>10}{:>12}", "avg", "rms");
            for (a, r) in values[0].iter().zip(&values[1]) {
                println!("{a:>10.4}{r:>12.4}");
            }
            return Ok(());
        }
    }
    println!("Statistics block produced no samples in time.");
    Ok(())
}

pub fn tags(&self) -> Result<Option<Tags>>

Gets the tags of the component.

Returns

• tags: The tags of the component. Tags are user definable labels that can be attached to the component.

Calls the openDAQ C function daqComponent_getTags().

Examples found in repository

examples/search_filter.rs (line 45)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    instance.add_device("daqref://device0")?;
    let root = instance.root_device()?.expect("root device");

    // Give a couple of channels some tags, so the tag filter has something to
    // match.  (RefCh0 and RefCh1 come from the reference device unlabelled.)
    let everything = SearchFilter::recursive(&SearchFilter::any()?)?;
    for channel in root.channels_with(Some(&everything))? {
        let tags = channel.tags()?.expect("tags").cast::<TagsPrivate>()?;
        tags.add("analog")?;
        if channel.local_id()? == "RefCh0" {
            tags.add("primary")?;
        }
    }

    show(
        "channels, no filter (immediate children only)",
        root.channels()?,
    )?;

    show(
        "channels, recursive(any)",
        root.channels_with(Some(&SearchFilter::recursive(&SearchFilter::any()?)?))?,
    )?;

    show(
        "channels, recursive(id = RefCh1)",
        root.channels_with(Some(&SearchFilter::recursive(&SearchFilter::local_id(
            "RefCh1",
        )?)?))?,
    )?;

    let ai0_or_ai1 = SearchFilter::or(
        &SearchFilter::local_id("AI0")?,
        &SearchFilter::local_id("AI1")?,
    )?;
    show(
        "signals, recursive(id = AI0 OR id = AI1)",
        root.signals_with(Some(&SearchFilter::recursive(&ai0_or_ai1)?))?,
    )?;

    let not_ref_ch1 = SearchFilter::not(&SearchFilter::local_id("RefCh1")?)?;
    show(
        "channels, recursive(NOT id = RefCh1)",
        root.channels_with(Some(&SearchFilter::recursive(&not_ref_ch1)?))?,
    )?;

    let analog_and_not_ref_ch1 = SearchFilter::and(
        &SearchFilter::required_tags(vec!["analog"])?,
        &SearchFilter::not(&SearchFilter::local_id("RefCh1")?)?,
    )?;
    show(
        "channels, recursive(tag = analog AND NOT id = RefCh1)",
        root.channels_with(Some(&SearchFilter::recursive(&analog_and_not_ref_ch1)?))?,
    )?;

    Ok(())
}

pub fn visible(&self) -> Result<bool>

Gets visible metadata state of the component

Returns

• visible: True if the component is visible; False otherwise. Visible determines whether search/getter methods return find the component by default.

Calls the openDAQ C function daqComponent_getVisible().

pub fn set_active(&self, active: bool) -> Result<()>

Sets the component to be either active or inactive. Sets the local active state and notifies children about the parent active state change.

Parameters

• active: The new local active state of the component.

Errors

• OPENDAQ_IGNORED: if “Active” is part of the component’s list of locked attributes, or if the new active value is equal to the previous. An active component acquires data, performs calculations and send packets on the signal path.

Calls the openDAQ C function daqComponent_setActive().

pub fn set_description(&self, description: &str) -> Result<()>

Sets the description of the component.

Parameters

• description: The description of the component.

Errors

• OPENDAQ_IGNORED: if “Description” is part of the component’s list of locked attributes, or if the new description value is equal to the previous. The object that implements this interface defines how the description is specified.

Calls the openDAQ C function daqComponent_setDescription().

pub fn set_name(&self, name: &str) -> Result<()>

Sets the name of the component.

Parameters

• name: The name of the component.

Errors

• OPENDAQ_IGNORED: if “Name” is part of the component’s list of locked attributes, or if the new name value is equal to the previous. The object that implements this interface defines how the name is specified.

Calls the openDAQ C function daqComponent_setName().

pub fn set_visible(&self, visible: bool) -> Result<()>

Sets visible attribute state of the component

Parameters

• visible: True if the component is visible; False otherwise.

Errors

• OPENDAQ_IGNORED: if “Visible” is part of the component’s list of locked attributes. Visible determines whether search/getter methods return find the component by default.

Calls the openDAQ C function daqComponent_setVisible().

Methods from Deref<Target = PropertyObject>

pub fn add_property(&self, property: &Property) -> Result<()>

Adds the property to the Property object.

Parameters

• property: The property to be added.

Errors

• OPENDAQ_ERR_INVALIDVALUE: if the property has no name.
• OPENDAQ_ERR_ALREADYEXISTS: if a property with the same name is already part of the Property object.
• OPENDAQ_ERR_FROZEN: if the Property object is frozen. The Property is frozen once added to the Property object, making it immutable. The same Property cannot be added to multiple different Property objects.

Calls the openDAQ C function daqPropertyObject_addProperty().

Examples found in repository

examples/download_log_files.rs (line 38)

fn main() -> opendaq::Result<()> {
    let work_dir = std::env::temp_dir().join("opendaq-rs-log-example");
    let downloads = work_dir.join("downloads");
    fs::create_dir_all(&downloads).expect("create working directories");
    let device_log = work_dir.join("ref_device_simulator.log");
    let device_log_path = device_log.to_string_lossy().into_owned();

    // Start from a clean log so the reported size reflects only this run.
    let _ = fs::remove_file(&device_log);

    let builder = InstanceBuilder::new()?;
    // Find the bundled modules.
    let modules = opendaq::native_library_directory().expect("bundled native modules");
    builder.set_module_path(&modules.to_string_lossy())?;
    builder.add_logger_sink(&LoggerSink::basic_file(&device_log_path)?)?;
    let instance = Instance::from_builder(&builder)?;

    // The reference device reads these two properties from its add-device config.
    let config = PropertyObject::new()?;
    config.add_property(&Property::bool("EnableLogging", true, true)?)?;
    config.add_property(&Property::string("LoggingPath", &device_log_path, true)?)?;

    let device = instance
        .add_device_with("daqref://device0", Some(&config))?
        .expect("reference device");

    // Flush the logger so everything buffered so far is actually on disk
    // before we read it.
    let context = instance.context()?.expect("instance context");
    context.logger()?.expect("instance logger").flush()?;

    let infos = device.log_file_infos()?;
    if infos.is_empty() {
        println!("Device exposes no log files.");
        return Ok(());
    }
    println!("Device exposes {} log file(s):", infos.len());
    println!();
    for info in infos {
        let id = info.id()?;
        let destination = downloads.join(info.name()?);
        println!("- {}", info.name()?);
        println!("    id:            {id}");
        println!("    size:          {} bytes", info.size()?);
        println!("    encoding:      {}", info.encoding()?);
        println!("    last-modified: {}", info.last_modified()?);
        // Size/offset let you fetch just part of a file; here, a short head preview.
        println!("    preview:       {:?}", device.log_with(&id, 60, 0)?);
        // Plain `log` fetches the whole file in one call.
        let content = device.log(&id)?;
        fs::write(&destination, &content).expect("write the downloaded log");
        println!(
            "    downloaded {} chars -> {}",
            content.len(),
            destination.display()
        );
        println!();
    }
    Ok(())
}

pub fn begin_update(&self) -> Result<()>

Begins batch configuration of the object. Batched configuration is used to apply several settings at once. To begin batch configuration, call beginUpdate. When the setPropertyValue is called on the object, the changes are not immediately applied to it. When endUpdate is called, the property values set between the beginUpdate and endUpdate method calls are applied. It triggers the ˙OnPropertyWriteEventfor each property value set, and theOnEndUpdateevent.beginUpdate` is called recursively for each child property object.

Calls the openDAQ C function daqPropertyObject_beginUpdate().

pub fn clear_property_value(&self, property_name: &str) -> Result<()>

Clears the Property value from the Property object

Parameters

• property_name: The name of the Property of which value should be cleared.

Errors

• OPENDAQ_ERR_NOTFOUND: if a Property with given propertyName is not part of the Property object.
• OPENDAQ_ERR_FROZEN: if the Property object is frozen. When a Property value is set, the value is written in the internal dictionary of Property values. This function will remove said value from the dictionary. If the tries to obtain the Property value of a property that does not have a set Property value, then the default value is returned. Importantly, clearing the value of an Object-type property will call clear on all the child object’s properties.

Calls the openDAQ C function daqPropertyObject_clearPropertyValue().

pub fn clear_property_values(&self) -> Result<()>

Clears values of all properties contained in the Property object, including nested child properties. This function clears the values by internally invoking clearPropertyValue(...) for all properties returned by getAllProperties(); for object-type properties it therefore clears their child properties as well. Read-only properties and frozen objects are skipped.

Calls the openDAQ C function daqPropertyObject_clearPropertyValues().

pub fn end_update(&self) -> Result<()>

Ends batch configuration of the object. Batched configuration is used to apply several settings at once. To begin batch configuration, call beginUpdate. When the setPropertyValue is called on the object, the changes are not immediately applied to it. When endUpdate is called, the property values set between the beginUpdate and endUpdate method calls are applied. It triggers the ˙OnPropertyWriteEventfor each property value set, and theOnEndUpdateevent.endUpdate` is called recursively for each child property object.

Calls the openDAQ C function daqPropertyObject_endUpdate().

pub fn find_properties( &self, property_filter: &SearchFilter, ) -> Result<Vec<Property>>

Retrieves a list of properties from the Property object that match the given property filter.

Parameters

• property_filter: A filter used to select relevant properties. Can include a recursive wrapper to search thru nested property objects.
• component_filter: An optional filter to determine which components’ properties are included in the search. A recursive wrapper can be used to enable tree-traversal search.

Returns

• properties: The list containing the matching properties. If the propertyFilter is nullptr, only the visible properties directly associated with the current object are retrieved. When searching for properties within a component, if no componentFilter is provided, only the current component is searched. If a componentFilter is provided but the current component does not match it, the result will be an empty list.

Calls the openDAQ C function daqPropertyObject_findProperties().

pub fn find_properties_with( &self, property_filter: &SearchFilter, component_filter: Option<&SearchFilter>, ) -> Result<Vec<Property>>

Retrieves a list of properties from the Property object that match the given property filter.

Parameters

• property_filter: A filter used to select relevant properties. Can include a recursive wrapper to search thru nested property objects.
• component_filter: An optional filter to determine which components’ properties are included in the search. A recursive wrapper can be used to enable tree-traversal search.

Returns

• properties: The list containing the matching properties. If the propertyFilter is nullptr, only the visible properties directly associated with the current object are retrieved. When searching for properties within a component, if no componentFilter is provided, only the current component is searched. If a componentFilter is provided but the current component does not match it, the result will be an empty list.

Calls the openDAQ C function daqPropertyObject_findProperties().

pub fn all_properties(&self) -> Result<Vec<Property>>

Returns a list of all properties contained in the Property object.

Returns

• properties: The List of properties. Properties are retrieved regardless of their visibility. They are sorted in insertion order unless a custom order is specified. This function returns both the properties added to the Property object, as well as those of its class.

Calls the openDAQ C function daqPropertyObject_getAllProperties().

pub fn class_name(&self) -> Result<String>

Gets the name of the class the Property object was constructed with.

Returns

• class_name: The class’s name. Contains an empty string if the class name is not configured. A Property object inherits all properties of the Property object class of the same name. Such Property objects have access to the Type manager from which they can retrieve its class type and its properties.

Calls the openDAQ C function daqPropertyObject_getClassName().

pub fn on_any_property_value_read(&self) -> Result<Option<Event>>

Gets the Event that is triggered whenever any Property value is read.The event is triggered after the specific Property event.

Returns

• event: The read Event. A handler can be added to the event containing a callback function which is invoked whenever the event is triggered. The callback function requires two parameters - a Property object, as well as a “Property value event args” object. The callback will be invoked with the Property object holding the read value as the first argument. The second argument holds an event args object that contains the read Property value, event type (Read), and a method of overriding the read value. If the read value is overridden, the overridden value is read instead.

Calls the openDAQ C function daqPropertyObject_getOnAnyPropertyValueRead().

pub fn on_any_property_value_write(&self) -> Result<Option<Event>>

Gets the Event that is triggered whenever any Property value is written. The event is triggered after the specific Property event.

Returns

• event: The write Event. A handler can be added to the event containing a callback function which is invoked whenever the event is triggered. The callback function requires two parameters - a Property object, as well as a “Property value event args” object. The callback will be invoked with the Property object holding the written-to property as the first argument The second argument holds an event args object that contains the written value, event type (Update), and a method of overriding the written value. If the written value is overridden, the overridden value is stored in the Property object instead.

Calls the openDAQ C function daqPropertyObject_getOnAnyPropertyValueWrite().

pub fn on_end_update(&self) -> Result<Option<Event>>

Gets the Event that is triggered whenever the batch configuration is applied.

Returns

• event: The Event. A handler can be added to the event containing a callback function which is invoked whenever the event is triggered. The callback function requires one parameter - a “End update value event args” object. The callback will be invoked with the batch configuration is applied, i.e. from the endUpdate method. The first argument holds an event args object that contains a list of properties updated.

Calls the openDAQ C function daqPropertyObject_getOnEndUpdate().

pub fn on_property_value_read( &self, property_name: &str, ) -> Result<Option<Event>>

Gets the Event that is triggered whenever a Property value of a Property named propertyName is read.

Parameters

• property_name: The name of the property.

Returns

• event: The read Event.

Errors

• OPENDAQ_ERR_NOTFOUND: if the Property object does not contain a Property named propertyName. A handler can be added to the event containing a callback function which is invoked whenever the event is triggered. The callback function requires two parameters - a Property object, as well as a “Property value event args” object. The callback will be invoked with the Property object holding the read value as the first argument. The second argument holds an event args object that contains the read Property value, event type (Read), and a method of overriding the read value. If the read value is overridden, the overridden value is read instead.

Calls the openDAQ C function daqPropertyObject_getOnPropertyValueRead().

pub fn on_property_value_write( &self, property_name: &str, ) -> Result<Option<Event>>

Gets the Event that is triggered whenever a Property value is written to the Property named propertyName.

Parameters

• property_name: The name of the property.

Returns

• event: The write Event.

Errors

• OPENDAQ_ERR_NOTFOUND: if the Property object does not contain a Property named propertyName. A handler can be added to the event containing a callback function which is invoked whenever the event is triggered. The callback function requires two parameters - a Property object, as well as a “Property value event args” object. The callback will be invoked with the Property object holding the written-to property as the first argument The second argument holds an event args object that contains the written value, event type (Update), and a method of overriding the written value. If the written value is overridden, the overridden value is stored in the Property object instead.

Calls the openDAQ C function daqPropertyObject_getOnPropertyValueWrite().

Examples found in repository

examples/smoke.rs (line 64)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;

    println!("Available devices:");
    for info in instance.available_devices()? {
        println!(" - {}: {}", info.connection_string()?, info.name()?);
    }

    let device = instance.add_device("daqref://device0")?.expect("device");
    println!("Added device: {}", device.name()?);

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;
    let signal = &channel.signals()?[0];

    // Batched property updates.
    {
        let batch = BatchedPropertyUpdate::new(&[&device, &channel])?;
        device.set_property_value("GlobalSampleRate", 1000)?;
        channel.set_property_value("Frequency", 50.0)?;
        batch.commit()?;
    }
    println!(
        "GlobalSampleRate = {}",
        device.property_value("GlobalSampleRate")?
    );

    // Stream reading with domain + tick conversion.
    let reader = StreamReader::<f64>::new(signal)?;
    let (samples, ticks) = reader.read_with_domain(100, 2000)?;
    println!(
        "read {} samples, {} ticks",
        samples.sample_count(),
        ticks.len()
    );
    let converter = TickConverter::from_signal(signal)?;
    if let Some(first) = ticks.first() {
        println!(
            "first tick {} -> {:?}",
            first,
            converter.tick_to_system_time(*first)
        );
    }

    // Callables: a Rust closure as an openDAQ function, called through openDAQ.
    let sum = FunctionObject::from_fn(|args| {
        let a = args[0].as_i64().unwrap_or(0);
        let b = args[1].as_i64().unwrap_or(0);
        Ok(Value::from(a + b))
    })?;
    let result = sum.call(&[Value::from(20), Value::from(22)])?;
    println!("sum(20, 22) = {result}");

    // Events: subscribe to property changes on the channel.
    let events = channel
        .on_property_value_write("Amplitude")?
        .expect("event");
    let handler = events.subscribe(|_sender, args| {
        if let Some(args) = args {
            println!("  event fired: {args}");
        }
    })?;
    channel.set_property_value("Amplitude", 2.5)?;
    events.unsubscribe(&handler)?;
    channel.set_property_value("Amplitude", 1.0)?;
    println!("Amplitude = {}", channel.property_value("Amplitude")?);

    Ok(())
}

pub fn permission_manager(&self) -> Result<Option<PermissionManager>>

Gets the permission manager of property object.

Returns

• permission_manager: The permission manager of property object.

Calls the openDAQ C function daqPropertyObject_getPermissionManager().

pub fn property(&self, property_name: &str) -> Result<Option<Property>>

Gets the Property with the given propertyName.

Parameters

• property_name: The name of the property.

Returns

• property: The retrieved Property.

Errors

• OPENDAQ_ERR_NOTFOUND: if the Property object does not contain the requested Property. The property is obtained from either the Property object class of the Property object, or the object’s local list of properties. The Property held by the object/class is not returned directly, but is instead cloned, and bound to the Property object. This allows for evaluation of Property metadata that depends on other properties of the Property object. For example, a Property’s visibility might depend on the value of another Property. To make evaluation of the visibility parameter possible, the Property must be able to access its owning Property object. Likewise, Reference properties always point at another Property of a Property object. Again, for this to be possible, the Property must be able to access its owning Property object, to be able to retrieve its referenced Property.

Calls the openDAQ C function daqPropertyObject_getProperty().

Examples found in repository

examples/connect_view_only_client.rs (line 61)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;

    let config = instance
        .create_default_add_device_config()?
        .expect("default add-device config");

    // The "General" child object holds the protocol-independent options,
    // ClientType among them; its selection values name the available modes.
    let general = config
        .property_value("General")?
        .into_object()?
        .cast::<PropertyObject>()?;
    let client_type = general
        .property("ClientType")?
        .expect("ClientType property");
    println!("Available ClientType options:");
    if let Value::Dict(mut options) = client_type.selection_values()? {
        options.sort_by_key(|(key, _)| key.as_i64());
        for (key, name) in options {
            println!("  {key} = {name}");
        }
    }

    config.set_property_value("General.ClientType", 2)?; // 2 = view-only
    let connection_string =
        std::env::var("OPENDAQ_DEVICE").unwrap_or_else(|_| "daq.nd://127.0.0.1".into());

    match instance.add_device_with(&connection_string, Some(&config)) {
        Ok(Some(device)) => probe_view_only_device(&device)?,
        Ok(None) => println!("Could not connect to {connection_string}: no device returned."),
        Err(err) => {
            println!("Could not connect to {connection_string}: {err}");
            println!("Start an openDAQ device/simulator there, or set OPENDAQ_DEVICE.");
        }
    }
    Ok(())
}

examples/call_function_property.rs (line 51)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    let device = instance.add_device("daqref://device0")?.expect("device");

    let sum = function_property(&device, "Protected.Sum")?;
    println!(
        "Protected.Sum(7, 5)   = {}",
        sum.call(&[Value::from(7), Value::from(5)])?
    );
    println!(
        "Protected.Sum(40, 2)  = {}",
        sum.call(&[Value::from(40), Value::from(2)])?
    );
    println!(
        "Protected.Sum(100, 1) = {}",
        function_property(&device, "Protected.Sum")?.call(&[Value::from(100), Value::from(1)])?
    );

    // SumList takes a single argument: a list of numbers.
    let sum_list = function_property(&device, "Protected.SumList")?;
    println!(
        "Protected.SumList([1, 2, 3, 4]) = {}",
        sum_list.call(&[Value::from(vec![1, 2, 3, 4])])?
    );
    println!(
        "Protected.SumList([]) = {}",
        sum_list.call(&[Value::List(Vec::new())])?
    );

    // `call` passes arguments straight through, and an implementation is free
    // to ignore extras (the reference device's Sum does).  The declared
    // signature lives in the property's callable info -- check the arity
    // there before calling when it matters.
    let info = device
        .property("Protected.Sum")?
        .expect("Sum property")
        .callable_info()?
        .expect("callable info");
    let expected = info.arguments()?.len();
    let args = [Value::from(1), Value::from(2), Value::from(3)];
    if args.len() == expected {
        println!("\nProtected.Sum(1, 2, 3) = {}", sum.call(&args)?);
    } else {
        println!(
            "\nWrong arity is rejected: Protected.Sum expects {expected} arguments, got {}.",
            args.len()
        );
    }
    Ok(())
}

pub fn property_selection_value(&self, property_name: &str) -> Result<Value>

Gets the selected value of the Property, if the Property is a Selection property.

Parameters

• property_name: The name of the Property.

Returns

• value: The selected value.

Errors

• OPENDAQ_ERR_NOTFOUND: if a Property with given propertyName is not part of the Property object.
• OPENDAQ_ERR_INVALIDPROPERTY: if the Property either has no Selection values, or the Selection values are not a list or dictionary.
• OPENDAQ_ERR_INVALIDTYPE: if the retrieved value does not match the Property’s item type. This function serves as a shortcut to obtaining the Property value of a Property, and using it to retrieve the currently selected value from the Selection values of the Property. For example, if the Selection values contain the following list “[“banana”, “apple”, “pear”]“, and the corresponding Property value is set to 1, retrieving the Property selection value will return the string “apple”.

Calls the openDAQ C function daqPropertyObject_getPropertySelectionValue().

pub fn property_value(&self, property_name: &str) -> Result<Value>

Gets the value of the Property with the given name.

Parameters

• property_name: The name of the Property.

Returns

• value: The returned Property value.

Errors

• OPENDAQ_ERR_NOTFOUND: if a property with given propertyName is not part of the Property object.
• OPENDAQ_ERR_INVALIDPARAMETER: if attempting to get a value at an index of a non-list Property.
• OPENDAQ_ERR_OUTOFRANGE: if attempting to get a value of a list Property at an out-of-bounds index. The value is retrieved from a local dictionary of Property values where they are stored when set. If a value is not present under the propertyName key, the default value of the corresponding Property is returned. If said property is not part of the Property object, an error occurs. @subsection value_get_child_property_objects Child Property objects The Property value getter allows for direct retrieval of values of child Property objects. To get the Property value of a child Property object, the propertyName parameter should be of the format: “childName.propertyName”. This pattern can also be used to access nested properties - for example “childName1.childName2.childName3.propertyName”. @subsection value_get_list_properties List properties If the requested Property is a list-type object, an item of the list at a selected index can be retrieved instead of the list itself. To do so, add a [index] suffix to the propertyName parameter. For example “ListProperty[1]” retrieves the 2nd item stored in the list Property value of the Property named “ListProperty”. @subsection value_get_selection_properties Selection properties If the requested Property has the Selection values fields configured, the Property value getter returns an index/key of the selected item in the Selection values list/dictionary.

Calls the openDAQ C function daqPropertyObject_getPropertyValue().

Examples found in repository

examples/call_function_property.rs (line 12)

fn function_property(device: &Device, name: &str) -> opendaq::Result<FunctionObject> {
    device
        .property_value(name)?
        .into_object()?
        .cast::<FunctionObject>()
}

examples/batch_properties.rs (line 11)

fn show_settings(label: &str, channel: &Channel) -> opendaq::Result<()> {
    println!(
        "{label} {}:  Amplitude={}  Frequency={}  Waveform={}",
        channel.name()?,
        channel.property_value("Amplitude")?,
        channel.property_value("Frequency")?,
        channel.property_value("Waveform")?
    );
    Ok(())
}

examples/component_tree.rs (line 24)

fn property_value_string(object: &PropertyObject, property: &Property) -> opendaq::Result<String> {
    Ok(match property.value_type()? {
        CoreType::Bool
        | CoreType::Int
        | CoreType::Float
        | CoreType::String
        | CoreType::Ratio
        | CoreType::ComplexNumber => match object.property_value(&property.name()?)? {
            Value::Str(text) => format!("{text:?}"),
            value => value.to_string(),
        },
        other => format!("<{other:?}>"),
    })
}

examples/connect_view_only_client.rs (line 34)

fn probe_view_only_device(device: &Device) -> opendaq::Result<()> {
    println!("Connected to {} as a view-only client.", device.name()?);
    println!("Visible signals: {}", device.signals_recursive()?.len());
    match first_writable_property_name(device)? {
        Some(name) => {
            // Write the property's current value back to itself: harmless if
            // it were allowed, but a view-only connection must reject it.
            let value = device.property_value(&name)?;
            match device.set_property_value(&name, value) {
                Ok(()) => println!("Unexpected: writing {name:?} was allowed."),
                Err(err) => {
                    println!("Write to {name:?} refused, as expected for view-only: {err}")
                }
            }
        }
        None => println!("Device exposes no writable property to probe."),
    }
    Ok(())
}

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;

    let config = instance
        .create_default_add_device_config()?
        .expect("default add-device config");

    // The "General" child object holds the protocol-independent options,
    // ClientType among them; its selection values name the available modes.
    let general = config
        .property_value("General")?
        .into_object()?
        .cast::<PropertyObject>()?;
    let client_type = general
        .property("ClientType")?
        .expect("ClientType property");
    println!("Available ClientType options:");
    if let Value::Dict(mut options) = client_type.selection_values()? {
        options.sort_by_key(|(key, _)| key.as_i64());
        for (key, name) in options {
            println!("  {key} = {name}");
        }
    }

    config.set_property_value("General.ClientType", 2)?; // 2 = view-only
    let connection_string =
        std::env::var("OPENDAQ_DEVICE").unwrap_or_else(|_| "daq.nd://127.0.0.1".into());

    match instance.add_device_with(&connection_string, Some(&config)) {
        Ok(Some(device)) => probe_view_only_device(&device)?,
        Ok(None) => println!("Could not connect to {connection_string}: no device returned."),
        Err(err) => {
            println!("Could not connect to {connection_string}: {err}");
            println!("Start an openDAQ device/simulator there, or set OPENDAQ_DEVICE.");
        }
    }
    Ok(())
}

examples/smoke.rs (line 33)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;

    println!("Available devices:");
    for info in instance.available_devices()? {
        println!(" - {}: {}", info.connection_string()?, info.name()?);
    }

    let device = instance.add_device("daqref://device0")?.expect("device");
    println!("Added device: {}", device.name()?);

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;
    let signal = &channel.signals()?[0];

    // Batched property updates.
    {
        let batch = BatchedPropertyUpdate::new(&[&device, &channel])?;
        device.set_property_value("GlobalSampleRate", 1000)?;
        channel.set_property_value("Frequency", 50.0)?;
        batch.commit()?;
    }
    println!(
        "GlobalSampleRate = {}",
        device.property_value("GlobalSampleRate")?
    );

    // Stream reading with domain + tick conversion.
    let reader = StreamReader::<f64>::new(signal)?;
    let (samples, ticks) = reader.read_with_domain(100, 2000)?;
    println!(
        "read {} samples, {} ticks",
        samples.sample_count(),
        ticks.len()
    );
    let converter = TickConverter::from_signal(signal)?;
    if let Some(first) = ticks.first() {
        println!(
            "first tick {} -> {:?}",
            first,
            converter.tick_to_system_time(*first)
        );
    }

    // Callables: a Rust closure as an openDAQ function, called through openDAQ.
    let sum = FunctionObject::from_fn(|args| {
        let a = args[0].as_i64().unwrap_or(0);
        let b = args[1].as_i64().unwrap_or(0);
        Ok(Value::from(a + b))
    })?;
    let result = sum.call(&[Value::from(20), Value::from(22)])?;
    println!("sum(20, 22) = {result}");

    // Events: subscribe to property changes on the channel.
    let events = channel
        .on_property_value_write("Amplitude")?
        .expect("event");
    let handler = events.subscribe(|_sender, args| {
        if let Some(args) = args {
            println!("  event fired: {args}");
        }
    })?;
    channel.set_property_value("Amplitude", 2.5)?;
    events.unsubscribe(&handler)?;
    channel.set_property_value("Amplitude", 1.0)?;
    println!("Amplitude = {}", channel.property_value("Amplitude")?);

    Ok(())
}

pub fn updating(&self) -> Result<bool>

Returns the state of batch configuration.

Returns

• updating: True if the object is performing batch update of its properties. Batched configuration is used to apply several settings at once. To begin batch configuration, call beginUpdate. When the setPropertyValue is called on the object, the changes are not immediately applied. When endUpdate is called, the property values set between the beginUpdate and endUpdate method calls are applied. This method returns True if beginUpdate method has been called on the objectandendUpdate` has not been called yet.

Calls the openDAQ C function daqPropertyObject_getUpdating().

pub fn visible_properties(&self) -> Result<Vec<Property>>

Returns a list of visible properties contained in the Property object.

Returns

• properties: The List of properties. A Property is visible if both the Visible parameter is set to true, and IsReferenced is false. The properties are sorted in insertion order unless a custom order is specified. This function returns both the properties added to the Property object, as well as those of its class.

Calls the openDAQ C function daqPropertyObject_getVisibleProperties().

Examples found in repository

examples/component_tree.rs (line 34)

fn draw_properties(component: &Component, prefix: &str) -> opendaq::Result<()> {
    for property in component.visible_properties()? {
        println!(
            "{prefix}• {} : {:?} = {}",
            property.name()?,
            property.value_type()?,
            property_value_string(component, &property)?
        );
    }
    Ok(())
}

examples/connect_view_only_client.rs (line 15)

fn first_writable_property_name(object: &PropertyObject) -> opendaq::Result<Option<String>> {
    for property in object.visible_properties()? {
        if property.read_only()? {
            continue;
        }
        if matches!(property.value_type()?, CoreType::Func | CoreType::Proc) {
            continue;
        }
        return Ok(Some(property.name()?));
    }
    Ok(None)
}

pub fn has_property(&self, property_name: &str) -> Result<bool>

Checks if the Property object contains a property named propertyName.

Parameters

• property_name: The name of the property.

Returns

• has_property: True if the Property object contains the Property; false otherwise.

Calls the openDAQ C function daqPropertyObject_hasProperty().

pub fn remove_property(&self, property_name: &str) -> Result<()>

Removes the Property named propertyName from the Property object.

Parameters

• property_name: The name of the Property to be removed.

Errors

• OPENDAQ_ERR_NOTFOUND: if the Property object does not contain a Property named propertyName, or the Property is part of the Property object’s Property object class.
• OPENDAQ_ERR_FROZEN: if the Property object is frozen. A property can only be removed from a Property object, if it was added to the object, and not inherited from its class.

Calls the openDAQ C function daqPropertyObject_removeProperty().

pub fn set_property_order(&self, ordered_property_names: &[&str]) -> Result<()>

Sets a custom order of properties as defined in the list of property names.

Parameters

• ordered_property_names: A list of names of properties. The order of the list is applied to the object’s properties.

Errors

• OPENDAQ_ERR_FROZEN: if the Property object is frozen. The list should contain names of properties available in the object. When retrieving the Property object’s properties, they will be sorted in the order in which the names appear in the provided list. Any properties not in the custom order are kept in insertion order at the end of the Property object’s list of properties.

Calls the openDAQ C function daqPropertyObject_setPropertyOrder().

pub fn set_property_selection_value( &self, property_name: &str, value: impl Into<Value>, ) -> Result<()>

Sets the value of a Selection property by the selection item value (e.g. string, float, or list/dict value).

Parameters

• property_name: The name of the Property.
• value: The selection value to set (must be one of the Property’s selection values). Cannot be null.

Errors

• OPENDAQ_ERR_NOTFOUND: if a Property with given propertyName is not part of the Property object, or the value is not in the selection.
• OPENDAQ_ERR_INVALIDPROPERTY: if the Property has no Selection values.
• OPENDAQ_ERR_ACCESSDENIED: if the property is Read-only.
• OPENDAQ_ERR_FROZEN: if the Property object is frozen. Works for all Selection properties (list or dictionary): the value is the actual selection item (e.g. a string from the list, or the value part of a key-value pair in the dictionary). Use setPropertyValue when setting by index/key.

Calls the openDAQ C function daqPropertyObject_setPropertySelectionValue().

pub fn set_property_value( &self, property_name: &str, value: impl Into<Value>, ) -> Result<()>

Sets the value of the Property with the given name.

Parameters

• property_name: The name of the Property.
• value: The Property value to be set. Cannot be null.

Errors

• OPENDAQ_ERR_NOTFOUND: if a property with given propertyName is not part of the Property object.
• OPENDAQ_ERR_ACCESSDENIED: if the property is Read-only.
• OPENDAQ_ERR_CONVERSIONFAILED: if the value cannot be converted to the Value type of the Property.
• OPENDAQ_ERR_INVALIDTYPE: if the value is a list/dictionary/object with invalid keys/items/fields.
• OPENDAQ_ERR_VALIDATE_FAILED: if the Validator fails to validate the value.
• OPENDAQ_ERR_COERCION_FAILED: if the Coercer fails to coerce the value.
• OPENDAQ_ERR_FROZEN: if the Property object is frozen.
• OPENDAQ_ERR_IGNORED: if the value is the same as the default, or the previously written value. Stores the provided value into an internal dictionary of property name and value pairs. This property value can later be retrieved through the corresponding getter method when invoked with the same propertyName. The provided value must adhere to the restrictions of the corresponding Property (that bears the name propertyName). If such a Property is part of the Property object, the setter call will fail. Some restrictions include: - The core type of the value must match that of the Property Value type. - If the Property is a numeric type, the value must be equal or greater than the Min value, and equal or smaller than the Max value. - If the Property is Read-only, the setter will fail. - The value will be validated by the Property validator causing the setter method to fail if validation is unsuccessful. - The value will be coerced to fit the coercion expression of the Property coercer before being written into the local dictionary of property values. Setting the value of a Property will override either its default value or the value that was set beforehand. @subsection patterns Behaviour patterns of note - When setting the value of a Property with the Selection values field configured (a Selection property), the value must be an integer type, and acts as an index/key into the list/dictionary of Selection values. - If the Property is a Reference property (the Referenced property field is configured), the value is actually written under the key of the referenced Property, not the one specified through the propertyName argument. - When setting a list or dictionary type property, the list items and dictionary keys and items must be homogeneous, and of the same type as specified by the item and key type of the Property. - Setting a Property value will invoke the corresponding onPropertyValueWrite event. @subsection value_set_child_property_objects Child Property objects The Property value setter allows for direct configuration of any child Property objects. To set the Property value of a child Property object, the propertyName parameter should be of the format: “childName.propertyName”. This pattern can also be used to access nested properties - for example “childName1.childName2.childName3.propertyName”.

Calls the openDAQ C function daqPropertyObject_setPropertyValue().

Examples found in repository

examples/connect_view_only_client.rs (line 35)

fn probe_view_only_device(device: &Device) -> opendaq::Result<()> {
    println!("Connected to {} as a view-only client.", device.name()?);
    println!("Visible signals: {}", device.signals_recursive()?.len());
    match first_writable_property_name(device)? {
        Some(name) => {
            // Write the property's current value back to itself: harmless if
            // it were allowed, but a view-only connection must reject it.
            let value = device.property_value(&name)?;
            match device.set_property_value(&name, value) {
                Ok(()) => println!("Unexpected: writing {name:?} was allowed."),
                Err(err) => {
                    println!("Write to {name:?} refused, as expected for view-only: {err}")
                }
            }
        }
        None => println!("Device exposes no writable property to probe."),
    }
    Ok(())
}

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;

    let config = instance
        .create_default_add_device_config()?
        .expect("default add-device config");

    // The "General" child object holds the protocol-independent options,
    // ClientType among them; its selection values name the available modes.
    let general = config
        .property_value("General")?
        .into_object()?
        .cast::<PropertyObject>()?;
    let client_type = general
        .property("ClientType")?
        .expect("ClientType property");
    println!("Available ClientType options:");
    if let Value::Dict(mut options) = client_type.selection_values()? {
        options.sort_by_key(|(key, _)| key.as_i64());
        for (key, name) in options {
            println!("  {key} = {name}");
        }
    }

    config.set_property_value("General.ClientType", 2)?; // 2 = view-only
    let connection_string =
        std::env::var("OPENDAQ_DEVICE").unwrap_or_else(|_| "daq.nd://127.0.0.1".into());

    match instance.add_device_with(&connection_string, Some(&config)) {
        Ok(Some(device)) => probe_view_only_device(&device)?,
        Ok(None) => println!("Could not connect to {connection_string}: no device returned."),
        Err(err) => {
            println!("Could not connect to {connection_string}: {err}");
            println!("Start an openDAQ device/simulator there, or set OPENDAQ_DEVICE.");
        }
    }
    Ok(())
}

examples/batch_properties.rs (line 28)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    let device = instance.add_device("daqref://device0")?.expect("device");
    let channels = device.channels()?;
    let (ch0, ch1) = (&channels[0], &channels[1]);

    show_settings("Before:          ", ch0)?;
    show_settings("Before:          ", ch1)?;

    let batch = BatchedPropertyUpdate::new(&[ch0, ch1])?;
    ch0.set_property_value("Amplitude", 2.5)?;
    ch0.set_property_value("Frequency", 25.0)?;
    ch0.set_property_value("Waveform", 1)?;
    ch1.set_property_value("Amplitude", 4.0)?;
    ch1.set_property_value("Frequency", 50.0)?;
    ch1.set_property_value("Waveform", 2)?;
    // Still inside the batch: the writes above are staged but not yet applied.
    show_settings("During (staged): ", ch0)?;
    show_settings("During (staged): ", ch1)?;
    batch.commit()?;

    show_settings("After the batch: ", ch0)?;
    show_settings("After the batch: ", ch1)?;
    Ok(())
}

examples/multireader.rs (line 35)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    instance.add_device("daqref://device0")?;

    let channels = [
        find_channel(&instance, "Dev/RefDev0/IO/AI/RefCh0")?,
        find_channel(&instance, "Dev/RefDev0/IO/AI/RefCh1")?,
    ];
    channels[0].set_property_value("Frequency", 0.5)?;
    channels[1].set_property_value("Frequency", 2.0)?;

    let signals = [
        channels[0].signals()?[0].clone(),
        channels[1].signals()?[0].clone(),
    ];
    let reader = MultiReader::<f64>::new(&signals)?;

    // The first reads can return nothing while the reader synchronises the
    // signals onto the common domain; retry until rows arrive.
    for _ in 0..10 {
        let (values, domain) = reader.read_with_domain(8, 1000)?;
        if domain[0].is_empty() {
            continue;
        }
        let converter = TickConverter::from_multi_reader(&reader)?;
        print!("{:<16}", "timestamp");
        for index in 0..values.len() {
            print!("{:>14}", format!("signal {index}"));
        }
        println!();
        for (row, tick) in domain[0].iter().enumerate() {
            print!("{:<16}", time_of_day(converter.tick_to_unix_nanos(*tick)));
            for signal_values in &values {
                print!("{:>14.6}", signal_values[row]);
            }
            println!();
        }
        return Ok(());
    }
    println!("Multi reader did not synchronise in time.");
    Ok(())
}

examples/core_events.rs (line 44)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    instance.add_device("daqref://device0")?;

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;

    let core_event = instance
        .context()?
        .expect("context")
        .on_core_event()?
        .expect("core event");

    // The handler may run on openDAQ's own threads.  Its args come in as a
    // generic object; cast to CoreEventArgs for the event name and the
    // per-event-type parameters ("Name" holds the changed property's name).
    let handler = core_event.subscribe(|_sender, args| {
        let Some(args) = args else { return };
        let Ok(event) = args.cast::<CoreEventArgs>() else {
            return;
        };
        let name = event.event_name().unwrap_or_default();
        let parameters = event.parameters().unwrap_or_default();
        let changed = parameters
            .get("Name")
            .map(ToString::to_string)
            .unwrap_or_default();
        println!("  {name}: {changed}");
    })?;

    // While subscribed, each property change is reported by the handler above.
    println!("subscribed:");
    channel.set_property_value("Frequency", 25.0)?;
    channel.set_property_value("Amplitude", 7.5)?;

    // Unsubscribing removes the handler; further changes fire nothing.
    core_event.unsubscribe(&handler)?;
    println!("unsubscribed (no lines expected below):");
    channel.set_property_value("Frequency", 50.0)?;

    Ok(())
}

examples/smoke.rs (line 27)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;

    println!("Available devices:");
    for info in instance.available_devices()? {
        println!(" - {}: {}", info.connection_string()?, info.name()?);
    }

    let device = instance.add_device("daqref://device0")?.expect("device");
    println!("Added device: {}", device.name()?);

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;
    let signal = &channel.signals()?[0];

    // Batched property updates.
    {
        let batch = BatchedPropertyUpdate::new(&[&device, &channel])?;
        device.set_property_value("GlobalSampleRate", 1000)?;
        channel.set_property_value("Frequency", 50.0)?;
        batch.commit()?;
    }
    println!(
        "GlobalSampleRate = {}",
        device.property_value("GlobalSampleRate")?
    );

    // Stream reading with domain + tick conversion.
    let reader = StreamReader::<f64>::new(signal)?;
    let (samples, ticks) = reader.read_with_domain(100, 2000)?;
    println!(
        "read {} samples, {} ticks",
        samples.sample_count(),
        ticks.len()
    );
    let converter = TickConverter::from_signal(signal)?;
    if let Some(first) = ticks.first() {
        println!(
            "first tick {} -> {:?}",
            first,
            converter.tick_to_system_time(*first)
        );
    }

    // Callables: a Rust closure as an openDAQ function, called through openDAQ.
    let sum = FunctionObject::from_fn(|args| {
        let a = args[0].as_i64().unwrap_or(0);
        let b = args[1].as_i64().unwrap_or(0);
        Ok(Value::from(a + b))
    })?;
    let result = sum.call(&[Value::from(20), Value::from(22)])?;
    println!("sum(20, 22) = {result}");

    // Events: subscribe to property changes on the channel.
    let events = channel
        .on_property_value_write("Amplitude")?
        .expect("event");
    let handler = events.subscribe(|_sender, args| {
        if let Some(args) = args {
            println!("  event fired: {args}");
        }
    })?;
    channel.set_property_value("Amplitude", 2.5)?;
    events.unsubscribe(&handler)?;
    channel.set_property_value("Amplitude", 1.0)?;
    println!("Amplitude = {}", channel.property_value("Amplitude")?);

    Ok(())
}

examples/add_function_block.rs (line 34)

fn main() -> opendaq::Result<()> {
    // Instance::new() already loads the bundled modules; build from an
    // InstanceBuilder when you want to control the module search path.
    let builder = InstanceBuilder::new()?;
    // The bundled modules (reference device, function blocks, streaming):
    let bundled = opendaq::native_library_directory().expect("native libraries");
    builder.set_module_path(&bundled.to_string_lossy())?;
    // Your own modules folder:
    // builder.add_module_path("/path/to/your/modules")?;
    let instance = Instance::from_builder(&builder)?;
    instance.add_device("daqref://device0")?;

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;
    channel.set_property_value("Amplitude", 5.0)?;
    channel.set_property_value("DC", 1.0)?;

    let statistics = instance
        .add_function_block("RefFBModuleStatistics")?
        .expect("statistics function block");
    statistics.set_property_value("BlockSize", 100)?;

    let status = statistics.status_container()?.expect("status container");
    println!(
        "Before connect: {} ({})",
        status.status("ComponentStatus")?.expect("status").value()?,
        status.status_message("ComponentStatus")?
    );

    let port = &statistics.input_ports()?[0];
    let signal = &channel.signals()?[0];
    port.connect(signal)?;

    println!(
        "After connect:  {} ({})",
        status.status("ComponentStatus")?.expect("status").value()?,
        status.status_message("ComponentStatus")?
    );

    let outputs = statistics.signals()?;
    let avg = signal_by_local_id(&outputs, "avg")?.expect("avg signal");
    let rms = signal_by_local_id(&outputs, "rms")?.expect("rms signal");
    let reader = MultiReader::<f64>::new(&[avg, rms])?;

    // The first reads may return nothing while the block waits for a complete
    // input descriptor (the multi reader by default doesn't skip events), so
    // retry until samples arrive.
    for _attempt in 0..20 {
        let values = reader.read(5, 1000)?;
        if !values[0].is_empty() {
            println!("{:>10}{:>12}", "avg", "rms");
            for (a, r) in values[0].iter().zip(&values[1]) {
                println!("{a:>10.4}{r:>12.4}");
            }
            return Ok(());
        }
    }
    println!("Statistics block produced no samples in time.");
    Ok(())
}

Additional examples can be found in:

• examples/reader_invalidation_recovery.rs
• examples/streamreader_2d_signal.rs
• examples/stateful_callback.rs
• examples/reading_incompatible_signals_together.rs

Methods from Deref<Target = BaseObject>

pub fn cast<T: Interface>(&self) -> Result<T>

Query this object for interface T, returning a wrapper that owns its own reference.

This is a genuine queryInterface: an object’s interfaces live at different virtual-table offsets, so the pointer for one interface is not binary-compatible with another and must be queried, not merely reinterpreted. Fails with an openDAQ error when the object does not implement T (use BaseObject::try_cast / BaseObject::is_a to probe first).

For the few interfaces the C API exposes no GUID for (T::interface_id() is None), the pointer is reinterpreted unchecked, which is sound only when the object really lies on T’s inheritance chain.

Examples found in repository

examples/call_function_property.rs (line 14)

fn function_property(device: &Device, name: &str) -> opendaq::Result<FunctionObject> {
    device
        .property_value(name)?
        .into_object()?
        .cast::<FunctionObject>()
}

examples/component_tree.rs (line 48)

fn children(component: &Component) -> opendaq::Result<Vec<Component>> {
    if component.is_a::<Folder>() {
        component.cast::<Folder>()?.items()
    } else {
        Ok(Vec::new())
    }
}

examples/multireader.rs (line 24)

fn find_channel(instance: &Instance, path: &str) -> opendaq::Result<Channel> {
    instance
        .find_component(path)?
        .unwrap_or_else(|| panic!("channel {path} not found"))
        .cast::<Channel>()
}

examples/search_filter.rs (line 25)

fn show<T: Interface>(label: &str, components: Vec<T>) -> opendaq::Result<()> {
    let ids = components
        .iter()
        .map(|c| c.to_base_object().cast::<Component>()?.local_id())
        .collect::<opendaq::Result<Vec<_>>>()?;
    let listing = if ids.is_empty() {
        "(none)".to_string()
    } else {
        ids.join(", ")
    };
    println!("{label}\n    => {listing}\n");
    Ok(())
}

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    instance.add_device("daqref://device0")?;
    let root = instance.root_device()?.expect("root device");

    // Give a couple of channels some tags, so the tag filter has something to
    // match.  (RefCh0 and RefCh1 come from the reference device unlabelled.)
    let everything = SearchFilter::recursive(&SearchFilter::any()?)?;
    for channel in root.channels_with(Some(&everything))? {
        let tags = channel.tags()?.expect("tags").cast::<TagsPrivate>()?;
        tags.add("analog")?;
        if channel.local_id()? == "RefCh0" {
            tags.add("primary")?;
        }
    }

    show(
        "channels, no filter (immediate children only)",
        root.channels()?,
    )?;

    show(
        "channels, recursive(any)",
        root.channels_with(Some(&SearchFilter::recursive(&SearchFilter::any()?)?))?,
    )?;

    show(
        "channels, recursive(id = RefCh1)",
        root.channels_with(Some(&SearchFilter::recursive(&SearchFilter::local_id(
            "RefCh1",
        )?)?))?,
    )?;

    let ai0_or_ai1 = SearchFilter::or(
        &SearchFilter::local_id("AI0")?,
        &SearchFilter::local_id("AI1")?,
    )?;
    show(
        "signals, recursive(id = AI0 OR id = AI1)",
        root.signals_with(Some(&SearchFilter::recursive(&ai0_or_ai1)?))?,
    )?;

    let not_ref_ch1 = SearchFilter::not(&SearchFilter::local_id("RefCh1")?)?;
    show(
        "channels, recursive(NOT id = RefCh1)",
        root.channels_with(Some(&SearchFilter::recursive(&not_ref_ch1)?))?,
    )?;

    let analog_and_not_ref_ch1 = SearchFilter::and(
        &SearchFilter::required_tags(vec!["analog"])?,
        &SearchFilter::not(&SearchFilter::local_id("RefCh1")?)?,
    )?;
    show(
        "channels, recursive(tag = analog AND NOT id = RefCh1)",
        root.channels_with(Some(&SearchFilter::recursive(&analog_and_not_ref_ch1)?))?,
    )?;

    Ok(())
}

examples/streamreader.rs (line 15)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    instance.add_device("daqref://device0")?;

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;
    let signal = &channel.signals()?[0];

    let reader = StreamReader::<f64>::new(signal)?;
    println!("some samples: {:?}", reader.read(100, 1000)?.values());
    println!("and more samples: {:?}", reader.read(100, 1000)?.values());
    println!("and more still: {:?}", reader.read(100, 1000)?.values());
    Ok(())
}

examples/streamreader_with_timestamps.rs (line 46)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    instance.add_device("daqref://device0")?;

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;
    let signal = &channel.signals()?[0];

    let reader = StreamReader::<f64>::new(signal)?;
    let converter = TickConverter::from_signal(signal)?;

    let (values, ticks) = reader.read_with_domain(10, 2000)?;
    println!("Read {} samples:", values.sample_count());
    for (value, tick) in values.iter().zip(&ticks) {
        println!(
            "  {value:.6} @ {}",
            timestamp_to_string(converter.tick_to_unix_nanos(*tick))
        );
    }
    Ok(())
}

Additional examples can be found in:

• examples/connect_view_only_client.rs
• examples/core_events.rs
• examples/smoke.rs
• examples/add_function_block.rs
• examples/reader_invalidation_recovery.rs
• examples/streamreader_2d_signal.rs
• examples/stateful_callback.rs
• examples/reading_incompatible_signals_together.rs

pub fn try_cast<T: Interface>(&self) -> Option<T>

Like BaseObject::cast, but returns None when the object does not implement T.

pub fn is_a<T: Interface>(&self) -> bool

True when the object implements interface T (a borrowInterface probe; adds no reference). Returns false for interfaces without a GUID in the C API, which cannot be probed.

Examples found in repository

examples/component_tree.rs (line 47)

fn children(component: &Component) -> opendaq::Result<Vec<Component>> {
    if component.is_a::<Folder>() {
        component.cast::<Folder>()?.items()
    } else {
        Ok(Vec::new())
    }
}

pub fn hash_code(&self) -> Result<usize>

The object’s hash code.

pub fn equals<T: Interface>(&self, other: &T) -> Result<bool>

True when openDAQ considers the two objects equal.

pub fn ptr_eq<T: Interface>(&self, other: &T) -> bool

Identity comparison: both wrappers refer to the same native object. (Note that pointers to different interfaces of one object differ; this compares the raw interface pointers.)

pub fn dispose(&self) -> Result<()>

Release the object’s internal resources early (openDAQ dispose). The wrapper itself stays alive; most callers never need this.

pub fn component_kind(&self) -> Option<ComponentKind>

The most-derived component interface this object implements (probed most-derived first), or None when it is not a component.

Examples found in repository

examples/component_tree.rs (line 10)

fn type_label(component: &Component) -> String {
    component
        .component_kind()
        .map_or_else(|| "Component".to_string(), |kind| format!("{kind:?}"))
}

pub fn to_value(&self) -> Result<Value>

The natural Rust value of this object: a boxed scalar yields its native value, a daq list a Vec, a daq dict key/value pairs – with elements converted recursively – and an object with no natural Rust form (a device, a property object, …) comes back as Value::Object, for the caller to BaseObject::cast.

Trait Implementations

impl Clone for SignalConfig

fn clone(&self) -> SignalConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SignalConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for SignalConfig

type Target = Signal

The resulting type after dereferencing.

fn deref(&self) -> &Signal

Dereferences the value.

impl Display for SignalConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<&SignalConfig> for Value

fn from(value: &SignalConfig) -> Value

Converts to this type from the input type.

impl From<SignalConfig> for Value

fn from(value: SignalConfig) -> Value

Converts to this type from the input type.

impl Interface for SignalConfig

const NAME: &'static str = "daqSignalConfig"

The openDAQ interface name, e.g. "daqDevice".

fn interface_id() -> Option<IntfID>

The interface’s GUID, or None for the few coretypes interfaces the C API exposes no id for (IBaseObject, IFunction, IProcedure, …).

unsafe fn from_raw(ptr: *mut c_void) -> Option<Self>

Adopt an owned raw interface pointer (takes ownership of one reference; does not add one). Returns None for null.

fn as_base_object(&self) -> &BaseObject

This wrapper viewed as the root IBaseObject interface.

fn as_raw(&self) -> *mut c_void

The raw interface pointer (still owned by this wrapper).

fn to_base_object(&self) -> BaseObject

A new owning BaseObject handle to the same underlying object.