vpRobotFranka.h

/*
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2023 by Inria. All rights reserved.
 *
 * This software is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact Inria about acquiring a ViSP Professional
 * Edition License.
 *
 * See https://visp.inria.fr for more information.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * If you have questions regarding the use of this file, please contact
 * Inria at visp@inria.fr
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Description:
 * Interface for the Franka robot.
 */
 
#ifndef _vpRobotFranka_h_
#define _vpRobotFranka_h_
 
#include <visp3/core/vpConfig.h>
 
#if defined(VISP_HAVE_FRANKA) && defined(VISP_HAVE_THREADS)
 
#include <atomic>
#include <iostream>
#include <thread>
#include <vector>
 
#include <stdio.h>
 
#include <franka/exception.h>
#include <franka/gripper.h>
#include <franka/model.h>
#include <franka/robot.h>
 
#include <visp3/core/vpColVector.h>
#include <visp3/core/vpException.h>
#include <visp3/robot/vpRobot.h>
 
BEGIN_VISP_NAMESPACE
class VISP_EXPORT vpRobotFranka : public vpRobot
{
private:
  vpRobotFranka(const vpRobotFranka &robot);
  void getDisplacement(const vpRobot::vpControlFrameType, vpColVector &) VP_OVERRIDE { };
 
  void init();
 
  franka::Robot *m_handler;   
  franka::Gripper *m_gripper; 
  franka::Model *m_model;
  double m_positioningVelocity;
 
  // Velocity controller
  std::thread m_velControlThread;
  std::atomic_bool m_velControlThreadIsRunning;
  std::atomic_bool m_velControlThreadStopAsked;
  std::array<double, 7> m_dq_des; // Desired joint velocity
  vpColVector m_v_cart_des;       // Desired cartesian velocity either in reference, end-effector, camera, or tool frame
 
  // Force/torque controller
  std::thread m_ftControlThread;
  std::atomic_bool m_ftControlThreadIsRunning;
  std::atomic_bool m_ftControlThreadStopAsked;
  std::array<double, 7> m_tau_J_des; // Desired joint torques
  vpColVector m_ft_cart_des; // Desired cartesian force/torque either in reference, end-effector, camera, or tool frame
 
  std::array<double, 7> m_q_min;   // Joint min position
  std::array<double, 7> m_q_max;   // Joint max position
  std::array<double, 7> m_dq_max;  // Joint max velocity
  std::array<double, 7> m_ddq_max; // Joint max acceleration
 
  franka::RobotState m_robot_state; // Robot state protected by mutex
  std::mutex m_mutex;               // Mutex to protect m_robot_state
 
  vpHomogeneousMatrix m_eMc;
  std::string m_log_folder;
  std::string m_franka_address;
 
public:
  vpRobotFranka();
 
  vpRobotFranka(const std::string &franka_address,
                franka::RealtimeConfig realtime_config = franka::RealtimeConfig::kEnforce);
 
  virtual ~vpRobotFranka();
 
  void connect(const std::string &franka_address,
               franka::RealtimeConfig realtime_config = franka::RealtimeConfig::kEnforce);
 
  vpHomogeneousMatrix get_fMe(const vpColVector &q);
  vpHomogeneousMatrix get_fMc(const vpColVector &q);
  vpHomogeneousMatrix get_eMc() const;
 
  void get_eJe(vpMatrix &eJe) VP_OVERRIDE;
  void get_eJe(const vpColVector &q, vpMatrix &eJe);
  void get_fJe(vpMatrix &fJe) VP_OVERRIDE;
  void get_fJe(const vpColVector &q, vpMatrix &fJe);
 
  void getCoriolis(vpColVector &coriolis);
  void getForceTorque(const vpRobot::vpControlFrameType frame, vpColVector &force);
 
  void getGravity(vpColVector &gravity);
 
  franka::RobotState getRobotInternalState();
 
  franka::Gripper *getGripperHandler()
  {
    if (!m_gripper) {
      throw(vpException(vpException::fatalError, "Cannot get Franka gripper handler: gripper is not connected"));
    }
 
    return m_gripper;
  }
 
  franka::Robot *getHandler()
  {
    if (!m_handler) {
      throw(vpException(vpException::fatalError, "Cannot get Franka robot handler: robot is not connected"));
    }
 
    return m_handler;
  }
 
  vpColVector getJointMin() const;
  vpColVector getJointMax() const;
 
  void getMass(vpMatrix &mass);
 
  void getPosition(const vpRobot::vpControlFrameType frame, vpColVector &position) VP_OVERRIDE;
  void getPosition(const vpRobot::vpControlFrameType frame, vpPoseVector &pose);
 
  void getVelocity(const vpRobot::vpControlFrameType frame, vpColVector &d_position);
 
  int gripperClose();
  int gripperGrasp(double grasping_width, double force = 60.);
  int gripperGrasp(double grasping_width, double speed, double force);
  void gripperHoming();
  int gripperMove(double width);
  int gripperOpen();
  void gripperRelease();
 
  void move(const std::string &filename, double velocity_percentage = 10.);
 
  bool readPosFile(const std::string &filename, vpColVector &q);
  bool savePosFile(const std::string &filename, const vpColVector &q);
 
  void set_eMc(const vpHomogeneousMatrix &eMc);
  void setForceTorque(const vpRobot::vpControlFrameType frame, const vpColVector &ft, const double &filter_gain = 0.1,
                      const bool &activate_pi_controller = false);
  void setLogFolder(const std::string &folder);
  void setPosition(const vpRobot::vpControlFrameType frame, const vpColVector &position) VP_OVERRIDE;
  void setPositioningVelocity(double velocity);
 
  vpRobot::vpRobotStateType setRobotState(vpRobot::vpRobotStateType newState);
  void setVelocity(const vpRobot::vpControlFrameType frame, const vpColVector &vel) VP_OVERRIDE;
 
  void stopMotion();
};
END_VISP_NAMESPACE
#endif
#endif // #ifndef __vpRobotFranka_h_