Struct DynpickSensorBuilder 

pub struct DynpickSensorBuilder<C> { /* private fields */ }

Builder of a connection to a dynpick sensor.

Examples

use dynpick_force_torque_sensor::DynpickSensorBuilder;

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

Implementations

impl DynpickSensorBuilder<SensitivityNotSetYet>

pub fn open<'a>( path: impl Into<Cow<'a, str>>, ) -> Result<DynpickSensorBuilder<SensitivityNotSetYet>, Error>

Connects to the dynpick force torque sensor.

Params

1. path The sensor’s path.

Returns

Ok(builder) if successfully connected, Err(reason) if failed.
Before you use the sensor, you need to calibrate the sensor by calling Self::set_sensitivity_by_builtin_data or Self::set_sensitivity_manually.

Examples

See the example here.

Examples found in repository

examples/demo.rs (line 53)

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 set_sensitivity_manually( self, sensitivity: Sensitivity, ) -> DynpickSensorBuilder<Ready>

Set the Sensitivity of the connected sensor by using the specified sensitivity.

Examples

use dynpick_force_torque_sensor::{DynpickSensorBuilder, Sensitivity, Triplet};

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)
};

let sensor = DynpickSensorBuilder::open("/dev/ttyUSB0")
    .map(|b| b.set_sensitivity_manually(sensitivity))
    .and_then(|b| b.build())
    .unwrap();

Examples found in repository

examples/demo.rs (line 54)

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 set_sensitivity_by_builtin_data( self, ) -> Result<DynpickSensorBuilder<Ready>, Error>

Set the Sensitivity of the connected sensor, reading its sensitivity from it.
Some sensors may not support this functionality (Err(_) will be returned under this situation).

Examples

See the example here

Note

This method has not been tested yet because my sensor (WDF-6M200-3) does not support this functionality.

impl DynpickSensorBuilder<Ready>

pub fn build(self) -> Result<DynpickSensor, Error>

Consuming this builder, attempts to construct a sensor instance.

Examples found in repository

examples/demo.rs (line 55)

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.");
}