riq_hand_state.h

Go to the documentation of this file.

/*********************************************************************
 * Software License Agreement (BSD License)
 *
 *  Copyright (c) 2008, Willow Garage, Inc.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.
 *   * Neither the name of the Willow Garage nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *********************************************************************/

#ifndef RIQ_HAND_ETHERCAT_HARDWARE__RIQ_HAND_STATE_H
#define RIQ_HAND_ETHERCAT_HARDWARE__RIQ_HAND_STATE_H

#include <stdint.h>

namespace riq_hand_ethercat_hardware
{


struct RIQGripperStatus
{
  union {
    uint8_t raw_;
    struct {
      uint8_t initialization_ : 1;  // When set to 0 will reset gripper, setting to 1 will initialize gripper
      uint8_t mode_           : 2;  // Gripper grasp mode (Cylindrical, Pinch, Spheriod, Scissors)
      uint8_t grip_           : 2;  // Current mode for gripper, Open,Close,Stop,Changing
      uint8_t status_         : 2;  // Action status (Faulted, In progress, illegal/undefined, successfull)
      uint8_t reserved_       : 1;
      } __attribute__ ((__packed__));
    } __attribute__ ((__packed__));

  enum {RESETTED=0, INITALIAZATION_COMPLETE=1};
  enum {CYLINDRICAL_MODE=0, PINCH_MODE=1, SPHERIOD_MODE=2, SCISSORS_MODE=3};
  enum {GRIP_STOPPED=0, GRIP_OPENED=1, GRIP_CLOSED=2, GRIP_INITIALIZING_OR_CHANGING=3};
  enum {ACTION_FAULTED=0, ACTION_IN_PROGRESS=1, ACTION_ILLEGAL_UNDEFINED=2, ACTION_SUCCESSFUL=3};
  
  bool inScissorsMode() const {return (mode_ == SCISSORS_MODE);}

  static const char* modeString(unsigned mode);
  static const char* gripString(unsigned grip);
  static const char* statusString(unsigned status);
  
  const char* modeString()   const {return modeString(mode_);}
  const char* gripString()   const {return gripString(grip_);}
  const char* statusString() const {return statusString(status_);}

} __attribute__ ((__packed__));



struct RIQObjectStatus
{
  union {
    uint8_t raw_;
    struct {
      uint8_t detected_          : 2;  
      uint8_t thumb_detected_    : 1;  // Set to 1 when thumb detected object
      uint8_t right_finger_detected_    : 1; 
      uint8_t left_finger_detected_     : 1;
      uint8_t scissors_detected_ : 1;
      uint8_t reserved_          : 2;
    } __attribute__ ((__packed__));
  } __attribute__ ((__packed__));

  enum {OBJECT_NOT_DETECTED=0, 
        OBJECT_DETECTED_1_FINGER=1,
        OBJECT_DETECTED_2_FINGERS=2,
        OBJECT_DETECTED_ALL_FINGERS=3};

  static const char* detectedString(unsigned detected, bool in_scissors_mode=false);
  static const char* wasDetectedString(bool was_detected);

  const char* detectedString(bool in_scissors_mode=false) const {return detectedString(detected_, in_scissors_mode);}

}  __attribute__ ((__packed__));



struct RIQHandStateEcat
{ 
  RIQGripperStatus gripper_status_;
  RIQObjectStatus  object_status_; 
  uint8_t reserved_;
  uint8_t fault_status_;
  uint8_t thumb_position_;
  uint8_t right_finger_position_;
  uint8_t left_finger_position_;
  uint8_t scissors_position_;
  uint8_t thumb_current_;
  uint8_t right_finger_current_;
  uint8_t left_finger_current_;
  uint8_t scissors_current_;

  enum {NO_FAULT = 0x00,
        FAULT_NEED_INITIALIZATION_TO_COMPLETE=0x11,
        FAULT_NEED_MODE_CHANGE_TO_COMPLETE   =0x12,
        FAULT_COMMUNICATION_TIMEOUT          =0x21,
        FAULT_INSUFFICIENT_SUPPLY_VOLTAGE    =0x22,
        FAULT_CHANGING_MODE_INTERFERENCE_SCISSORS = 0x31,
        FAULT_OPENING_INTERFERENCE_FINGERS   = 0x32,
        FAULT_OPENING_INTERFERENCE_SCISSORS  = 0x33,
        FAULT_CLOSING_INTERFERENCE_FINGERS   = 0x34,
        FAULT_CLOSING_INTERFERENCE_SCISSORS  = 0x35,
        FAULT_MAJOR_SCISSORS_DISPLACEMENT    = 0x41,
        FAULT_MAJOR_FINGER_DISPLACEMENT      = 0x42};

  static const char* faultString(unsigned fault);

  const char* faultString() const {return faultString(fault_status_);}

  static double convertPosition(unsigned position);

  static double convertCurrent(unsigned current);

} __attribute__ ((__packed__));

}; //namespace riq_hand_ethercat_hardware


#endif /* RIQ_HAND_ETHERCAT_HARDWARE__RIQ_HAND_STATE_H */