robot.h

Go to the documentation of this file.

// Copyright (c) 2017 Franka Emika GmbH
// Use of this source code is governed by the Apache-2.0 license, see LICENSE
#pragma once

#include <functional>
#include <memory>
#include <mutex>
#include <string>

#include <franka/command_types.h>
#include <franka/control_types.h>
#include <franka/duration.h>
#include <franka/lowpass_filter.h>
#include <franka/robot_state.h>

namespace franka {

class Model;

class Robot {
 public:
  using ServerVersion = uint16_t;

  explicit Robot(const std::string& franka_address,
                 RealtimeConfig realtime_config = RealtimeConfig::kEnforce,
                 size_t log_size = 50);

  Robot(Robot&& other) noexcept;

  Robot& operator=(Robot&& other) noexcept;

  ~Robot() noexcept;

  void control(std::function<Torques(const RobotState&, franka::Duration)> control_callback,
               bool limit_rate = true,
               double cutoff_frequency = kDefaultCutoffFrequency);

  void control(
      std::function<Torques(const RobotState&, franka::Duration)> control_callback,
      std::function<JointPositions(const RobotState&, franka::Duration)> motion_generator_callback,
      bool limit_rate = true,
      double cutoff_frequency = kDefaultCutoffFrequency);

  void control(
      std::function<Torques(const RobotState&, franka::Duration)> control_callback,
      std::function<JointVelocities(const RobotState&, franka::Duration)> motion_generator_callback,
      bool limit_rate = true,
      double cutoff_frequency = kDefaultCutoffFrequency);

  void control(
      std::function<Torques(const RobotState&, franka::Duration)> control_callback,
      std::function<CartesianPose(const RobotState&, franka::Duration)> motion_generator_callback,
      bool limit_rate = true,
      double cutoff_frequency = kDefaultCutoffFrequency);

  void control(std::function<Torques(const RobotState&, franka::Duration)> control_callback,
               std::function<CartesianVelocities(const RobotState&, franka::Duration)>
                   motion_generator_callback,
               bool limit_rate = true,
               double cutoff_frequency = kDefaultCutoffFrequency);

  void control(
      std::function<JointPositions(const RobotState&, franka::Duration)> motion_generator_callback,
      ControllerMode controller_mode = ControllerMode::kJointImpedance,
      bool limit_rate = true,
      double cutoff_frequency = kDefaultCutoffFrequency);

  void control(
      std::function<JointVelocities(const RobotState&, franka::Duration)> motion_generator_callback,
      ControllerMode controller_mode = ControllerMode::kJointImpedance,
      bool limit_rate = true,
      double cutoff_frequency = kDefaultCutoffFrequency);

  void control(
      std::function<CartesianPose(const RobotState&, franka::Duration)> motion_generator_callback,
      ControllerMode controller_mode = ControllerMode::kJointImpedance,
      bool limit_rate = true,
      double cutoff_frequency = kDefaultCutoffFrequency);

  void control(std::function<CartesianVelocities(const RobotState&, franka::Duration)>
                   motion_generator_callback,
               ControllerMode controller_mode = ControllerMode::kJointImpedance,
               bool limit_rate = true,
               double cutoff_frequency = kDefaultCutoffFrequency);

  void read(std::function<bool(const RobotState&)> read_callback);

  RobotState readOnce();

  VirtualWallCuboid getVirtualWall(int32_t id);

  void setCollisionBehavior(const std::array<double, 7>& lower_torque_thresholds_acceleration,
                            const std::array<double, 7>& upper_torque_thresholds_acceleration,
                            const std::array<double, 7>& lower_torque_thresholds_nominal,
                            const std::array<double, 7>& upper_torque_thresholds_nominal,
                            const std::array<double, 6>& lower_force_thresholds_acceleration,
                            const std::array<double, 6>& upper_force_thresholds_acceleration,
                            const std::array<double, 6>& lower_force_thresholds_nominal,
                            const std::array<double, 6>& upper_force_thresholds_nominal);

  void setCollisionBehavior(const std::array<double, 7>& lower_torque_thresholds,
                            const std::array<double, 7>& upper_torque_thresholds,
                            const std::array<double, 6>& lower_force_thresholds,
                            const std::array<double, 6>& upper_force_thresholds);

  void setJointImpedance(
      const std::array<double, 7>& K_theta);  // NOLINT(readability-identifier-naming)

  void setCartesianImpedance(
      const std::array<double, 6>& K_x);  // NOLINT(readability-identifier-naming)

  void setGuidingMode(const std::array<bool, 6>& guiding_mode, bool elbow);

  void setK(const std::array<double, 16>& EE_T_K);  // NOLINT(readability-identifier-naming)

  void setEE(const std::array<double, 16>& NE_T_EE);  // NOLINT(readability-identifier-naming)

  void setLoad(double load_mass,
               const std::array<double, 3>& F_x_Cload,  // NOLINT(readability-identifier-naming)
               const std::array<double, 9>& load_inertia);

  [[deprecated("Use franka::lowpassFilter instead")]] void setFilters(
      double joint_position_filter_frequency,
      double joint_velocity_filter_frequency,
      double cartesian_position_filter_frequency,
      double cartesian_velocity_filter_frequency,
      double controller_filter_frequency);
  void automaticErrorRecovery();

  void stop();

  Model loadModel();

  ServerVersion serverVersion() const noexcept;

  Robot(const Robot&) = delete;
  Robot& operator=(const Robot&) = delete;

  class Impl;

 private:
  std::unique_ptr<Impl> impl_;
  std::mutex control_mutex_;
};

}  // namespace franka