Struct franka_interface::experiment::Experiment

pub struct Experiment<Sim: ?Sized + SimulationSetup, Real: ?Sized + RealSetup> {
    pub environment: FrankaEnvironment,
    pub sim_setup: Box<Sim>,
    pub real_setup: Box<Real>,
}

Use it to create a new experiment which can either run on the real robot or in the simulation.

Use new to create an experiment and then use new_robot to create a new robot.

Fields

environment: FrankaEnvironment

sim_setup: Box<Sim>

real_setup: Box<Real>

Implementations

impl Experiment<dyn SimulationSetup, dyn RealSetup>

pub fn new(
    mode: Mode,
    sim_setup: impl SimulationSetup + 'static,
    real_setup: impl RealSetup + 'static
) -> Experiment<dyn SimulationSetup, dyn RealSetup>

Use it to create a new experiment which can either run on the real robot or in the simulation

Arguments

• mode - specify whether to run the experiment in simulation or with a real robot
• sim_setup - something that implements SimulationSetup.
• real_setup - something that implements RealSetup.

Example

use franka_interface::experiment::{Experiment, Mode, RealSetup, SimulationSetup};
use franka_interface::types::Vector7;
use franka_interface::RobotArguments;
use std::f64::consts::PI;
use std::path::PathBuf;
struct MySimSetup {}
impl SimulationSetup for MySimSetup {
    fn set_franka_urdf_path(&self) -> PathBuf {
        "path/to/panda.urdf".into()
    }
}
struct MyRealSetup {}
impl RealSetup for MyRealSetup {}
let mut env = Experiment::new(Mode::Simulation, MySimSetup {}, MyRealSetup {});
let mut robot = env.new_robot(RobotArguments {
    hostname: "franka".to_string(),
    base_pose: None,
    initial_config: None,
});
robot.joint_motion(
    0.1,
    Vector7::from_column_slice(&[1., PI / 4., 0., -2. * PI / 4., 0., PI / 2., -PI / 4.]),
);
println!("{:?}", robot.get_state());

pub fn get_image(&mut self) -> RgbaImage

returns the current image from the robot. Make sure you implemented get_camera_image in your RealSetup and SimulationSetup.

pub fn new_robot(&mut self, config: RobotArguments) -> Robot

spawns/connects to a new robot using the RobotArguments

pub fn is_simulation(&self) -> bool

Query whether the current experiment is run in simulation

pub fn use_physics_client<F: FnMut(RefMut<'_, PhysicsClient>) -> T, T>(
    &mut self,
    client_cb: F
) -> Option<T>

allows accessing the PhysicsClient in Simulation by defining a closure that takes the PhysicsClient as input. Nothing will happen if the experiment is not run in the simulation

Return

• In the simulation it will return Some(T) where T is the return type of the client_cb
• Will return None when not executed with the simulation.