vpRobotFranka.h

/****************************************************************************
 *
 * ViSP, open source Visual Servoing Platform software.
 * Copyright (C) 2005 - 2019 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 http://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.
 *
 * Authors:
 * Fabien Spindler
 *
 *****************************************************************************/

#ifndef _vpRobotFranka_h_
#define _vpRobotFranka_h_

#include <visp3/core/vpConfig.h>

#ifdef VISP_HAVE_FRANKA

#include <iostream>
#include <thread>
#include <atomic>
#include <vector>

#include <stdio.h>

#include <franka/exception.h>
#include <franka/robot.h>
#include <franka/model.h>
#include <franka/gripper.h>

#include <visp3/core/vpColVector.h>
#include <visp3/robot/vpRobot.h>
#include <visp3/core/vpException.h>

class VISP_EXPORT vpRobotFranka : public vpRobot
{
private:
  vpRobotFranka(const vpRobotFranka &robot);
  void getDisplacement(const vpRobot::vpControlFrameType, vpColVector &) {};

  void init();

  franka::Robot *m_handler; 
  franka::Gripper *m_gripper; 
  franka::Model *m_model;
  double m_positionningVelocity;

  // 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);
  void get_eJe(const vpColVector &q, vpMatrix &eJe);
  void get_fJe(vpMatrix &fJe);
  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);
  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.);
  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);
  void setPositioningVelocity(double velocity);

  vpRobot::vpRobotStateType setRobotState(vpRobot::vpRobotStateType newState);
  void setVelocity(const vpRobot::vpControlFrameType frame, const vpColVector &vel);

  void stopMotion();
};

#endif
#endif // #ifndef __vpRobotFranka_h_