Struct InstrumentHandle

pub struct InstrumentHandle<Ctx: UsbContext> {
    pub instrument: Instrument<Ctx>,
    pub usbtmc_capabilities: USBTMCCapabilities,
    pub usb488_capabilities: Option<USB488Capabilities>,
    pub scpi_id: Option<String>,
    /* private fields */
}

Fields

instrument: Instrument<Ctx>

usbtmc_capabilities: USBTMCCapabilities

usb488_capabilities: Option<USB488Capabilities>

scpi_id: Option<String>

Implementations

impl<Ctx: UsbContext> InstrumentHandle<Ctx>

pub fn get_max_transfer_size(&self) -> u32

pub fn set_max_transfer_size(&mut self, max_transfer_size: u32)

Examples found in repository

examples/u2000a.rs (line 40)

fn main() -> Result<(), Box<dyn Error>> {
  let context = rusb::Context::new()?;
  let instruments = list_instruments(context)?;

  if instruments.len() == 0 {
    println!("no instruments found");
    return Ok(());
  }

  let mut power_sensor = None;

  for mut instrument in instruments {
    println!("Found instrument: {}", instrument.read_resource_string()?);

    let handle = instrument.open()?;
    if let Some(id) = &handle.scpi_id {
      if id.starts_with("Keysight Technologies,U2000A") {
        println!("Found power sensor: {}", id);
        power_sensor = Some(handle);
        break;
      } else {
        println!("This is not the instrument I'm looking for: {}", id);
      }
    } else {
      println!("Sensor does not seem to support SCPI");
    }
  }

  if let Some(mut handle) = power_sensor {
    handle.set_max_transfer_size(1024);
    handle.set_term_char(Some(b'\n'))?;

    handle.write(&format!("SENS1:FREQ {}\n", FREQ_HZ as u64))?;
    loop {
      let power_str = handle.ask("FETCH1?")?;
      let power = power_str.trim().parse::<f64>()?;
      println!("{:2.3} dBm", power);
    }
  } else {
    println!("Sorry, didn't find a U2000A sensor");
    Ok(())
  }
}

pub fn get_term_char(&self) -> Option<u8>

pub fn set_term_char(&mut self, term_char: Option<u8>) -> TMCResult<()>

Examples found in repository

examples/u2000a.rs (line 41)

fn main() -> Result<(), Box<dyn Error>> {
  let context = rusb::Context::new()?;
  let instruments = list_instruments(context)?;

  if instruments.len() == 0 {
    println!("no instruments found");
    return Ok(());
  }

  let mut power_sensor = None;

  for mut instrument in instruments {
    println!("Found instrument: {}", instrument.read_resource_string()?);

    let handle = instrument.open()?;
    if let Some(id) = &handle.scpi_id {
      if id.starts_with("Keysight Technologies,U2000A") {
        println!("Found power sensor: {}", id);
        power_sensor = Some(handle);
        break;
      } else {
        println!("This is not the instrument I'm looking for: {}", id);
      }
    } else {
      println!("Sensor does not seem to support SCPI");
    }
  }

  if let Some(mut handle) = power_sensor {
    handle.set_max_transfer_size(1024);
    handle.set_term_char(Some(b'\n'))?;

    handle.write(&format!("SENS1:FREQ {}\n", FREQ_HZ as u64))?;
    loop {
      let power_str = handle.ask("FETCH1?")?;
      let power = power_str.trim().parse::<f64>()?;
      println!("{:2.3} dBm", power);
    }
  } else {
    println!("Sorry, didn't find a U2000A sensor");
    Ok(())
  }
}

pub fn get_timeout(&self) -> Duration

pub fn set_timeout(&mut self, timeout: Duration)

pub fn clear(&mut self) -> TMCResult<()>

pub fn pulse(&self) -> TMCResult<()>

Examples found in repository

examples/list_instruments.rs (line 22)

fn main() -> Result<(), Box<dyn Error>> {
  let context = rusb::Context::new()?;

  let timer = Instant::now();
  let instruments = list_instruments(context)?;

  if instruments.len() == 0 {
    println!("no instruments found");
  } else {
    for mut instrument in instruments {
      println!("Found instrument: {}", instrument.read_resource_string()?);

      let handle = instrument.open()?;
      println!("    USBTMC: {:?}", handle.usbtmc_capabilities);
      println!("    USB488: {:?}", handle.usb488_capabilities);
      println!("    SCPI ID: {:?}", handle.scpi_id);
      println!("    PULSE result: {:?}", handle.pulse());
    }
  }

  println!("Time elapsed: {:?}", timer.elapsed());
  Ok(())
}

pub fn write_raw(&mut self, data: &[u8]) -> TMCResult<()>

Write a command message to the instrument

pub fn read_raw(&mut self, transfer_size: Option<u32>) -> TMCResult<Vec<u8>>

Read response data from the instrument

pub fn read(&mut self, transfer_size: Option<u32>) -> TMCResult<String>

Read UTF-8 response data from the instrument

pub fn write(&mut self, message: &str) -> TMCResult<()>

Write a UTF-8 command message to the instrument

Examples found in repository

examples/u2000a.rs (line 43)

fn main() -> Result<(), Box<dyn Error>> {
  let context = rusb::Context::new()?;
  let instruments = list_instruments(context)?;

  if instruments.len() == 0 {
    println!("no instruments found");
    return Ok(());
  }

  let mut power_sensor = None;

  for mut instrument in instruments {
    println!("Found instrument: {}", instrument.read_resource_string()?);

    let handle = instrument.open()?;
    if let Some(id) = &handle.scpi_id {
      if id.starts_with("Keysight Technologies,U2000A") {
        println!("Found power sensor: {}", id);
        power_sensor = Some(handle);
        break;
      } else {
        println!("This is not the instrument I'm looking for: {}", id);
      }
    } else {
      println!("Sensor does not seem to support SCPI");
    }
  }

  if let Some(mut handle) = power_sensor {
    handle.set_max_transfer_size(1024);
    handle.set_term_char(Some(b'\n'))?;

    handle.write(&format!("SENS1:FREQ {}\n", FREQ_HZ as u64))?;
    loop {
      let power_str = handle.ask("FETCH1?")?;
      let power = power_str.trim().parse::<f64>()?;
      println!("{:2.3} dBm", power);
    }
  } else {
    println!("Sorry, didn't find a U2000A sensor");
    Ok(())
  }
}

pub fn ask(&mut self, data: &str) -> TMCResult<String>

Write a UTF-8 command message to the instrument and read a UTF-8 response

Examples found in repository

examples/u2000a.rs (line 45)

fn main() -> Result<(), Box<dyn Error>> {
  let context = rusb::Context::new()?;
  let instruments = list_instruments(context)?;

  if instruments.len() == 0 {
    println!("no instruments found");
    return Ok(());
  }

  let mut power_sensor = None;

  for mut instrument in instruments {
    println!("Found instrument: {}", instrument.read_resource_string()?);

    let handle = instrument.open()?;
    if let Some(id) = &handle.scpi_id {
      if id.starts_with("Keysight Technologies,U2000A") {
        println!("Found power sensor: {}", id);
        power_sensor = Some(handle);
        break;
      } else {
        println!("This is not the instrument I'm looking for: {}", id);
      }
    } else {
      println!("Sensor does not seem to support SCPI");
    }
  }

  if let Some(mut handle) = power_sensor {
    handle.set_max_transfer_size(1024);
    handle.set_term_char(Some(b'\n'))?;

    handle.write(&format!("SENS1:FREQ {}\n", FREQ_HZ as u64))?;
    loop {
      let power_str = handle.ask("FETCH1?")?;
      let power = power_str.trim().parse::<f64>()?;
      println!("{:2.3} dBm", power);
    }
  } else {
    println!("Sorry, didn't find a U2000A sensor");
    Ok(())
  }
}

pub fn ask_raw(&mut self, data: &[u8]) -> TMCResult<Vec<u8>>

Write a command message to the instrument and read a response

Trait Implementations

impl<Ctx: UsbContext> Drop for InstrumentHandle<Ctx>

fn drop(&mut self)

Executes the destructor for this type.