Struct Signal

pub struct Signal { /* private fields */ }

Implementations

impl Signal

pub fn get_status(&self) -> SignalStatus

Get the status of the signal instance. Calling this function will reset the flags was_set_remote and was_set_local and return their pre-reset values.

Examples

Use this function to check if you should push or read data from the signal:

use libmapper_rs::device::Device;
use libmapper_rs::signal::Signal;
use std::time::Duration;
fn main_loop(dev: &Device, sig: &mut Signal, value: &mut f64) {
    loop {
       dev.poll_and_block(Duration::from_millis(10));
 
       if sig.get_status().was_set_remote() { // check if there's a new value waiting for us
         let (new_value, _) = sig.get_value_single::<f64>().unwrap();
         *value = new_value;
       } else {
         sig.set_value_single(value);
       }
    }
}

Examples found in repository

examples/vector_signal.rs (line 27)

fn main() {
    let dev = Device::create("rustmapper");
    loop {
        dev.poll_and_block(Duration::from_millis(10));
        if dev.is_ready() {
            break;
        }
    }

    println!("Device became ready!");
    let mut sig = dev.create_vector_signal::<f64>("test_sin", mpr_dir::MPR_DIR_OUT, 2);
    let debug_sig = dev.create_vector_signal::<f64>("debug_msg", mpr_dir::MPR_DIR_IN, 2);
    loop {
        dev.poll_and_block(Duration::from_millis(100));
        let time = (SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64) as f64
            / 1000f64;

        let values = [time.sin(), time.cos()];
        sig.set_value(&values).unwrap();
        if debug_sig.get_status().was_set_remote() {
            println!(
                "Received debug message: {:?}",
                debug_sig.get_value::<f64>().unwrap().0
            );
        }
    }
}

examples/signal.rs (line 31)

fn main() {
    let dev = Device::create("rustmapper");
    loop {
        dev.poll_and_block(Duration::from_millis(10));
        if dev.is_ready() {
            break;
        }
    }

    println!("Device became ready!");
    let mut sig = dev.create_signal::<f64>("test_sin", mpr_dir::MPR_DIR_OUT);
    sig.set_property(mpr_prop::MPR_PROP_MIN, -1.0);
    sig.set_property(mpr_prop::MPR_PROP_MAX, 1.0);
    
    let debug_sig = dev.create_signal::<f64>("debug_msg", mpr_dir::MPR_DIR_IN);

    assert!(debug_sig.get_property::<f64>(mpr_prop::MPR_PROP_MIN).is_err());
    loop {
        dev.poll_and_block(Duration::from_millis(100));
        let time = ((SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64) as f64
            / 1000f64)
            .sin();
        sig.set_value_single(&time).unwrap();
        if debug_sig.get_status().was_set_remote() {
            println!(
                "Received debug message: {:?}",
                debug_sig.get_value_single::<f64>().unwrap()
            );
        }
    }
}

pub fn get_data_type(&self) -> mpr_type

Get the type of data this signal is storing.

pub fn get_vector_length(&self) -> u32

Get the length of the vector this signal is storing. This will be how long the slice returned from Signal::get_value is.

If this is 1, you should use Signal::get_value_single instead.

Examples found in repository

examples/scanner.rs (line 29)

fn main() {
  let graph = Graph::create();
  let mut count = 0;

  // Have to subscribe to all devices first in order to discover devices we don't own!
  graph.subscribe(None, &[mpr_type::MPR_DEV, mpr_type::MPR_SIG]);

  loop {

    graph.poll_and_block(Duration::from_millis(100));
    let list = graph.get_devices();

    if list.len() != 0 {
      for dev in list {
        println!("Device: {}", dev.get_property_str(mpr_prop::MPR_PROP_NAME).unwrap());
        let signals = dev.get_signals(libmapper_rs::constants::mpr_dir::MPR_DIR_ANY);
        for sig in signals {
          println!("\tSignal: {}", sig.get_property_str(mpr_prop::MPR_PROP_NAME).unwrap());
          println!("\t\tType: {:?}", sig.get_property::<mpr_type>(mpr_prop::MPR_PROP_TYPE).unwrap());
          println!("\t\tVector Length: {:?}", sig.get_vector_length());
          println!("\t\tMin: {:?}", sig.get_property::<f32>(mpr_prop::MPR_PROP_MIN));
          println!("\t\tMax: {:?}", sig.get_property::<f32>(mpr_prop::MPR_PROP_MAX));
          println!("\t\tUnit: {:?}", sig.get_property_str(mpr_prop::MPR_PROP_UNIT));
          println!("\t\tNum instances: {:?}", sig.get_property::<i32>(mpr_prop::MPR_PROP_NUM_INST).unwrap());
          println!("");
        }
      }
      break;
    }
    
    println!("Loop {}", count);
    count += 1;
  }
  
}

impl Signal

pub fn set_value_single<T: MappableType + Copy>( &mut self, value: &T, ) -> Result<(), SignalError>

Set the value of the signal. This function will return SignalError::WrongType if the passed generic type doesn’t match the signal’s type.

If this signal is a vector, only the first element of the vector will be set.

Examples found in repository

examples/maps.rs (line 28)

pub fn main() {
    let dev = Device::create("rustmapper");
    loop {
        dev.poll_and_block(Duration::from_millis(10));
        if dev.is_ready() {
            break;
        }
    }

    println!("Device became ready!");
    let mut sig_a =
        dev.create_signal::<i32>("output", libmapper_rs::constants::mpr_dir::MPR_DIR_OUT);
    let sig_b = dev.create_signal::<i32>("input", libmapper_rs::constants::mpr_dir::MPR_DIR_IN);
    let map = Map::create(&sig_a, &sig_b);
    map.push();
    loop {
        dev.poll_and_block(Duration::from_millis(100));
        if map.is_ready() {
            break;
        }
    }
    println!("Map created!");
    for i in 0..100 {
        sig_a.set_value_single(&i).unwrap();
        dev.poll_and_block(Duration::from_millis(10));
        let val = sig_b
            .get_value_single::<i32>()
            .expect("Signal didn't send!");
        println!("Sent: {}, Received: {}", i, val.0);
        assert_eq!(i, val.0)
    }
}

examples/signal.rs (line 30)

fn main() {
    let dev = Device::create("rustmapper");
    loop {
        dev.poll_and_block(Duration::from_millis(10));
        if dev.is_ready() {
            break;
        }
    }

    println!("Device became ready!");
    let mut sig = dev.create_signal::<f64>("test_sin", mpr_dir::MPR_DIR_OUT);
    sig.set_property(mpr_prop::MPR_PROP_MIN, -1.0);
    sig.set_property(mpr_prop::MPR_PROP_MAX, 1.0);
    
    let debug_sig = dev.create_signal::<f64>("debug_msg", mpr_dir::MPR_DIR_IN);

    assert!(debug_sig.get_property::<f64>(mpr_prop::MPR_PROP_MIN).is_err());
    loop {
        dev.poll_and_block(Duration::from_millis(100));
        let time = ((SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64) as f64
            / 1000f64)
            .sin();
        sig.set_value_single(&time).unwrap();
        if debug_sig.get_status().was_set_remote() {
            println!(
                "Received debug message: {:?}",
                debug_sig.get_value_single::<f64>().unwrap()
            );
        }
    }
}

pub fn get_value_single<T: MappableType + Copy>( &self, ) -> Result<(T, u64), SignalError>

Get the value of the signal. This function will return SignalError::WrongType if the passed generic type doesn’t match the signal’s type.

If this signal is a vector, only the first element of the vector will be returned.

Examples found in repository

examples/maps.rs (line 31)

pub fn main() {
    let dev = Device::create("rustmapper");
    loop {
        dev.poll_and_block(Duration::from_millis(10));
        if dev.is_ready() {
            break;
        }
    }

    println!("Device became ready!");
    let mut sig_a =
        dev.create_signal::<i32>("output", libmapper_rs::constants::mpr_dir::MPR_DIR_OUT);
    let sig_b = dev.create_signal::<i32>("input", libmapper_rs::constants::mpr_dir::MPR_DIR_IN);
    let map = Map::create(&sig_a, &sig_b);
    map.push();
    loop {
        dev.poll_and_block(Duration::from_millis(100));
        if map.is_ready() {
            break;
        }
    }
    println!("Map created!");
    for i in 0..100 {
        sig_a.set_value_single(&i).unwrap();
        dev.poll_and_block(Duration::from_millis(10));
        let val = sig_b
            .get_value_single::<i32>()
            .expect("Signal didn't send!");
        println!("Sent: {}, Received: {}", i, val.0);
        assert_eq!(i, val.0)
    }
}

examples/signal.rs (line 34)

fn main() {
    let dev = Device::create("rustmapper");
    loop {
        dev.poll_and_block(Duration::from_millis(10));
        if dev.is_ready() {
            break;
        }
    }

    println!("Device became ready!");
    let mut sig = dev.create_signal::<f64>("test_sin", mpr_dir::MPR_DIR_OUT);
    sig.set_property(mpr_prop::MPR_PROP_MIN, -1.0);
    sig.set_property(mpr_prop::MPR_PROP_MAX, 1.0);
    
    let debug_sig = dev.create_signal::<f64>("debug_msg", mpr_dir::MPR_DIR_IN);

    assert!(debug_sig.get_property::<f64>(mpr_prop::MPR_PROP_MIN).is_err());
    loop {
        dev.poll_and_block(Duration::from_millis(100));
        let time = ((SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64) as f64
            / 1000f64)
            .sin();
        sig.set_value_single(&time).unwrap();
        if debug_sig.get_status().was_set_remote() {
            println!(
                "Received debug message: {:?}",
                debug_sig.get_value_single::<f64>().unwrap()
            );
        }
    }
}

pub fn get_value<T: MappableType + Copy>( &self, ) -> Result<(Vec<T>, u64), SignalError>

Get the value of the signal. This function will return SignalError::WrongType if the passed generic type doesn’t match the signal’s type.

The length of the returned slice will be equal to the value returned by get_vector_length.

Examples found in repository

examples/vector_signal.rs (line 30)

fn main() {
    let dev = Device::create("rustmapper");
    loop {
        dev.poll_and_block(Duration::from_millis(10));
        if dev.is_ready() {
            break;
        }
    }

    println!("Device became ready!");
    let mut sig = dev.create_vector_signal::<f64>("test_sin", mpr_dir::MPR_DIR_OUT, 2);
    let debug_sig = dev.create_vector_signal::<f64>("debug_msg", mpr_dir::MPR_DIR_IN, 2);
    loop {
        dev.poll_and_block(Duration::from_millis(100));
        let time = (SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64) as f64
            / 1000f64;

        let values = [time.sin(), time.cos()];
        sig.set_value(&values).unwrap();
        if debug_sig.get_status().was_set_remote() {
            println!(
                "Received debug message: {:?}",
                debug_sig.get_value::<f64>().unwrap().0
            );
        }
    }
}

pub fn set_value<T: MappableType + Copy>( &mut self, values: &[T], ) -> Result<(), SignalError>

Set the value of the signal. This function will return SignalError::WrongType if the passed generic type doesn’t match the signal’s type.

The length of the slice must be equal to the value returned by get_vector_length. If the lengths are not equal this function return an Err of SignalError::WrongLengthArg.

Examples found in repository

examples/vector_signal.rs (line 26)

fn main() {
    let dev = Device::create("rustmapper");
    loop {
        dev.poll_and_block(Duration::from_millis(10));
        if dev.is_ready() {
            break;
        }
    }

    println!("Device became ready!");
    let mut sig = dev.create_vector_signal::<f64>("test_sin", mpr_dir::MPR_DIR_OUT, 2);
    let debug_sig = dev.create_vector_signal::<f64>("debug_msg", mpr_dir::MPR_DIR_IN, 2);
    loop {
        dev.poll_and_block(Duration::from_millis(100));
        let time = (SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64) as f64
            / 1000f64;

        let values = [time.sin(), time.cos()];
        sig.set_value(&values).unwrap();
        if debug_sig.get_status().was_set_remote() {
            println!(
                "Received debug message: {:?}",
                debug_sig.get_value::<f64>().unwrap().0
            );
        }
    }
}

pub fn get_direction(&self) -> mpr_dir

Get the direction of the signal. This value determines how signal data can flow to/from this signal.

For example, you cannot map to a signal with direction MPR_DIR_OUT.

Trait Implementations

impl AsMprObject for Signal

fn as_mpr_object(&self) -> *mut c_void

impl Drop for Signal

fn drop(&mut self)

Executes the destructor for this type.

impl Send for Signal

impl Sync for Signal