SVHController.h

Go to the documentation of this file.

//
// © Copyright 2022 SCHUNK Mobile Greifsysteme GmbH, Lauffen/Neckar Germany
// © Copyright 2022 FZI Forschungszentrum Informatik, Karlsruhe, Germany
//
// This file is part of the Schunk SVH Library.
//
// The Schunk SVH Library 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 3 of the License, or (at your
// option) any later version.
//
// The Schunk SVH Library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
// Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// the Schunk SVH Library. If not, see <https://www.gnu.org/licenses/>.
//
 
 
//----------------------------------------------------------------------
//----------------------------------------------------------------------
#ifndef DRIVER_SVH_SVH_CONTROLLER_H_INCLUDED
#define DRIVER_SVH_SVH_CONTROLLER_H_INCLUDED
 
#include <schunk_svh_library/ImportExport.h>
#include <schunk_svh_library/SVHFirmwareInfo.h>
#include <schunk_svh_library/control/SVHControlCommand.h>
#include <schunk_svh_library/control/SVHControllerFeedback.h>
#include <schunk_svh_library/control/SVHControllerState.h>
#include <schunk_svh_library/control/SVHCurrentSettings.h>
#include <schunk_svh_library/control/SVHEncoderSettings.h>
#include <schunk_svh_library/control/SVHPositionSettings.h>
#include <schunk_svh_library/serial/SVHReceiveThread.h>
#include <schunk_svh_library/serial/SVHSerialInterface.h>
 
namespace driver_svh {
 
enum
{
  SVH_ALL           = -1, // this should be used with care as not all functions support it yet
  SVH_THUMB_FLEXION = 0,
  SVH_THUMB_OPPOSITION, // wrist
  SVH_INDEX_FINGER_DISTAL,
  SVH_INDEX_FINGER_PROXIMAL,
  SVH_MIDDLE_FINGER_DISTAL,
  SVH_MIDDLE_FINGER_PROXIMAL,
  SVH_RING_FINGER,
  SVH_PINKY,
  SVH_FINGER_SPREAD,
  SVH_DIMENSION // 9
} typedef SVHChannel;
 
class DRIVER_SVH_IMPORT_EXPORT SVHController
{
public:
  SVHController();
 
  ~SVHController();
 
  bool connect(const std::string& dev_name);
 
  void disconnect();
 
  void setControllerTarget(const SVHChannel& channel, const int32_t& position);
 
  void setControllerTargetAllChannels(const std::vector<int32_t>& positions);
 
 
  // Access functions
  void enableChannel(const SVHChannel& channel);
 
  void disableChannel(const SVHChannel& channel);
 
  void requestControllerState();
 
  void requestControllerFeedback(const SVHChannel& channel);
 
  void requestPositionSettings(const SVHChannel& channel);
 
  void setPositionSettings(const SVHChannel& channel, const SVHPositionSettings& position_settings);
 
  void requestCurrentSettings(const SVHChannel& channel);
 
  void setCurrentSettings(const SVHChannel& channel, const SVHCurrentSettings& current_settings);
 
  void requestEncoderValues();
 
  void setEncoderValues(const SVHEncoderSettings& encoder_settings);
 
 
  void requestFirmwareInfo();
 
  void receivedPacketCallback(const SVHSerialPacket& packet, unsigned int packet_count);
 
  bool getControllerFeedback(const SVHChannel& channel, SVHControllerFeedback& controller_feedback);
 
  bool getPositionSettings(const SVHChannel& channel, SVHPositionSettings& position_settings);
 
  bool getCurrentSettings(const SVHChannel& channel, SVHCurrentSettings& current_settings);
 
  SVHFirmwareInfo getFirmwareInfo();
 
  unsigned int getSentPackageCount();
 
  unsigned int getReceivedPackageCount();
 
  void resetPackageCounts();
 
  bool isEnabled(const SVHChannel& channel);
 
  static const char* m_channel_description[];
 
  static const float CHANNEL_EFFORT_CONSTANTS[9][2];
 
  void getControllerFeedbackAllChannels(SVHControllerFeedbackAllChannels& controller_feedback);
 
private:
  // Data Structures for holding configurations and feedback of the Controller
 
  std::vector<SVHCurrentSettings> m_current_settings;
 
  std::vector<SVHPositionSettings> m_position_settings;
 
  std::vector<SVHControllerFeedback> m_controller_feedback;
 
  SVHControllerState m_controller_state;
 
  SVHEncoderSettings m_encoder_settings;
 
  SVHFirmwareInfo m_firmware_info;
 
  // Hardware control
 
  SVHSerialInterface* m_serial_interface;
 
  uint16_t m_enable_mask;
 
  unsigned int m_received_package_count;
};
 
} // namespace driver_svh
 
#endif