Struct DynpickSensor 

pub struct DynpickSensor { /* private fields */ }

Dynpick 6-axis force-torque sensor.

Implementations

impl DynpickSensor

pub fn last_wrench(&self) -> Wrench

Returns the latest wrench that is stored in this instance without communicaing the sensor.

Use Self::update instead to obtain a new wrench from the sensor.

Returns

Ok(sensor) if successfully connected, Err(reason) if failed.

pub fn sensitivity(&self) -> Sensitivity

Returns the sensitivity of this sensor.

pub fn update(&mut self) -> Result<Wrench, Error>

Communicating to the sensor, updates the latest wrench.

Returns

Ok(wrench) if succeeds, Err(reason) if failed.

Examples found in repository

examples/demo.rs (line 79)

fn main() {
    println!("dynpick-force-torque-sensor demo started.");
    println!("Make sure that the sensor is connected to the computer.");
    println!("Make sure setting udev rule. See examples/setup_udev_rule.sh in detail.");

    // Search USB-connected dynpick sensor.
    let path = match search_usb_sensor_path() {
        Ok(Some(path)) => path,
        Ok(None) => {
            println!("No dynpick sensor is connected.");
            return;
        }
        Err(e) => {
            println!("{}", e);
            return;
        }
    };
    println!("Found a sensor. Path: {}", path);

    // Specify the sensitivity manually.
    let sensitivity = {
        let force = Triplet::new(24.9, 24.6, 24.5);
        let torque = Triplet::new(1664.7, 1639.7, 1638.0);
        Sensitivity::new(force, torque)
    };

    // Connect the found sensor.
    let sensor = DynpickSensorBuilder::open(path)
        .map(|b| b.set_sensitivity_manually(sensitivity))
        .and_then(|b| b.build());
    let mut sensor = match sensor {
        Ok(s) => s,
        Err(e) => {
            println!("{}", e);
            return;
        }
    };
    println!("Successfully opened the sensor.");

    // Correct zero-point
    match sensor.zeroed_next() {
        Ok(_) => println!("Offset the sensor."),
        Err(e) => {
            println!("An error occurred during offset: {}", e);
            return;
        }
    }

    // Repeatedly receive wrenches from the sensor.
    let measurement_count = 1000;
    for i in 0..measurement_count {
        std::thread::sleep(sensor.inner_port().timeout());

        match sensor.update() {
            Ok(w) => println!("[{}/{}] {:?}", i + 1, measurement_count, w),
            Err(e) => println!("[{}/{}] {}", i + 1, measurement_count, e),
        }
    }

    // Info
    println!("Product info: {:?}", sensor.receive_product_info());

    println!("dynpick-force-torque-sensor demo finished.");
}

pub fn zeroed_next(&mut self) -> Result<(), Error>

If this method succeeds, the next wrench acquired by Self::update will be zeroed.
This methos is useful for zero-point calibration.

Examples

use dynpick_force_torque_sensor::{DynpickSensorBuilder, Triplet};

let mut sensor = DynpickSensorBuilder::open("/dev/ttyUSB0")
    .and_then(|b| b.set_sensitivity_by_builtin_data())
    .and_then(|b| b.build())
    .unwrap();

sensor.zeroed_next().unwrap();

let wrench = sensor.update().unwrap();

assert_eq!(wrench.force, Triplet::new(0.0, 0.0, 0.0));
assert_eq!(wrench.torque, Triplet::new(0.0, 0.0, 0.0));

Examples found in repository

examples/demo.rs (line 66)

fn main() {
    println!("dynpick-force-torque-sensor demo started.");
    println!("Make sure that the sensor is connected to the computer.");
    println!("Make sure setting udev rule. See examples/setup_udev_rule.sh in detail.");

    // Search USB-connected dynpick sensor.
    let path = match search_usb_sensor_path() {
        Ok(Some(path)) => path,
        Ok(None) => {
            println!("No dynpick sensor is connected.");
            return;
        }
        Err(e) => {
            println!("{}", e);
            return;
        }
    };
    println!("Found a sensor. Path: {}", path);

    // Specify the sensitivity manually.
    let sensitivity = {
        let force = Triplet::new(24.9, 24.6, 24.5);
        let torque = Triplet::new(1664.7, 1639.7, 1638.0);
        Sensitivity::new(force, torque)
    };

    // Connect the found sensor.
    let sensor = DynpickSensorBuilder::open(path)
        .map(|b| b.set_sensitivity_manually(sensitivity))
        .and_then(|b| b.build());
    let mut sensor = match sensor {
        Ok(s) => s,
        Err(e) => {
            println!("{}", e);
            return;
        }
    };
    println!("Successfully opened the sensor.");

    // Correct zero-point
    match sensor.zeroed_next() {
        Ok(_) => println!("Offset the sensor."),
        Err(e) => {
            println!("An error occurred during offset: {}", e);
            return;
        }
    }

    // Repeatedly receive wrenches from the sensor.
    let measurement_count = 1000;
    for i in 0..measurement_count {
        std::thread::sleep(sensor.inner_port().timeout());

        match sensor.update() {
            Ok(w) => println!("[{}/{}] {:?}", i + 1, measurement_count, w),
            Err(e) => println!("[{}/{}] {}", i + 1, measurement_count, e),
        }
    }

    // Info
    println!("Product info: {:?}", sensor.receive_product_info());

    println!("dynpick-force-torque-sensor demo finished.");
}

pub fn receive_product_info(&mut self) -> Result<String, Error>

Reads the product info from the sensor.

Returns

Ok(product_info) if succeeds, Err(reason) if failed.

Examples found in repository

examples/demo.rs (line 86)

fn main() {
    println!("dynpick-force-torque-sensor demo started.");
    println!("Make sure that the sensor is connected to the computer.");
    println!("Make sure setting udev rule. See examples/setup_udev_rule.sh in detail.");

    // Search USB-connected dynpick sensor.
    let path = match search_usb_sensor_path() {
        Ok(Some(path)) => path,
        Ok(None) => {
            println!("No dynpick sensor is connected.");
            return;
        }
        Err(e) => {
            println!("{}", e);
            return;
        }
    };
    println!("Found a sensor. Path: {}", path);

    // Specify the sensitivity manually.
    let sensitivity = {
        let force = Triplet::new(24.9, 24.6, 24.5);
        let torque = Triplet::new(1664.7, 1639.7, 1638.0);
        Sensitivity::new(force, torque)
    };

    // Connect the found sensor.
    let sensor = DynpickSensorBuilder::open(path)
        .map(|b| b.set_sensitivity_manually(sensitivity))
        .and_then(|b| b.build());
    let mut sensor = match sensor {
        Ok(s) => s,
        Err(e) => {
            println!("{}", e);
            return;
        }
    };
    println!("Successfully opened the sensor.");

    // Correct zero-point
    match sensor.zeroed_next() {
        Ok(_) => println!("Offset the sensor."),
        Err(e) => {
            println!("An error occurred during offset: {}", e);
            return;
        }
    }

    // Repeatedly receive wrenches from the sensor.
    let measurement_count = 1000;
    for i in 0..measurement_count {
        std::thread::sleep(sensor.inner_port().timeout());

        match sensor.update() {
            Ok(w) => println!("[{}/{}] {:?}", i + 1, measurement_count, w),
            Err(e) => println!("[{}/{}] {}", i + 1, measurement_count, e),
        }
    }

    // Info
    println!("Product info: {:?}", sensor.receive_product_info());

    println!("dynpick-force-torque-sensor demo finished.");
}

pub fn inner_port(&self) -> &Box<dyn SerialPort>

Returns the reference to the serial port for the sensor.

Examples found in repository

examples/demo.rs (line 77)

fn main() {
    println!("dynpick-force-torque-sensor demo started.");
    println!("Make sure that the sensor is connected to the computer.");
    println!("Make sure setting udev rule. See examples/setup_udev_rule.sh in detail.");

    // Search USB-connected dynpick sensor.
    let path = match search_usb_sensor_path() {
        Ok(Some(path)) => path,
        Ok(None) => {
            println!("No dynpick sensor is connected.");
            return;
        }
        Err(e) => {
            println!("{}", e);
            return;
        }
    };
    println!("Found a sensor. Path: {}", path);

    // Specify the sensitivity manually.
    let sensitivity = {
        let force = Triplet::new(24.9, 24.6, 24.5);
        let torque = Triplet::new(1664.7, 1639.7, 1638.0);
        Sensitivity::new(force, torque)
    };

    // Connect the found sensor.
    let sensor = DynpickSensorBuilder::open(path)
        .map(|b| b.set_sensitivity_manually(sensitivity))
        .and_then(|b| b.build());
    let mut sensor = match sensor {
        Ok(s) => s,
        Err(e) => {
            println!("{}", e);
            return;
        }
    };
    println!("Successfully opened the sensor.");

    // Correct zero-point
    match sensor.zeroed_next() {
        Ok(_) => println!("Offset the sensor."),
        Err(e) => {
            println!("An error occurred during offset: {}", e);
            return;
        }
    }

    // Repeatedly receive wrenches from the sensor.
    let measurement_count = 1000;
    for i in 0..measurement_count {
        std::thread::sleep(sensor.inner_port().timeout());

        match sensor.update() {
            Ok(w) => println!("[{}/{}] {:?}", i + 1, measurement_count, w),
            Err(e) => println!("[{}/{}] {}", i + 1, measurement_count, e),
        }
    }

    // Info
    println!("Product info: {:?}", sensor.receive_product_info());

    println!("dynpick-force-torque-sensor demo finished.");
}