phidget_ik.h

Go to the documentation of this file.

#include <phidgetspp.hh>


class PhidgetIK : public Phidget
{
  public:

        PhidgetIK() :
          Phidget((CPhidgetHandle*)&ik_handle_),
          ik_handle_(0)
        {
      last_error_ = CPhidgetInterfaceKit_create(&ik_handle_);
      
      if (!last_error_)
      {
        CPhidget_set_OnAttach_Handler((CPhidgetHandle)ik_handle_, PhidgetIK::attachDelegate, this);
        CPhidgetInterfaceKit_set_OnInputChange_Handler(ik_handle_, PhidgetIK::inputChangeDelegate, this);
        CPhidgetInterfaceKit_set_OnOutputChange_Handler(ik_handle_, PhidgetIK::outputChangeDelegate, this);
        last_error_ = CPhidgetInterfaceKit_set_OnSensorChange_Handler(ik_handle_, PhidgetIK::sensorChangeDelegate, this);
      }
        }
        

    int init(int serial_number)
    {
      return (last_error_ = open(serial_number));
    }
    
    int getInputCount()
    {
      int count=-1;
      
      last_error_ = CPhidgetInterfaceKit_getInputCount(ik_handle_, &count);
      
      return count;
    }
    
    int getInputState(int index)
    {
      int state=-1;
      
      last_error_ = CPhidgetInterfaceKit_getInputState(ik_handle_, index, &state);
      
      return state;
    }
    
    int getOutputCount()
    {
      int count=-1;
      
      last_error_ = CPhidgetInterfaceKit_getOutputCount(ik_handle_, &count);
      
      return count;
    }
    
    int getOutputState(int index)
    {
      int state=-1;
      
      last_error_ = CPhidgetInterfaceKit_getOutputState(ik_handle_, index, &state);
      
      return state;
    }
    
    int setOutputState(int index, int state)
    {
      return (last_error_ = CPhidgetInterfaceKit_setOutputState(ik_handle_, index, state));
    }

    int getSensorCount()
    {
      int count=-1;
      
      last_error_ = CPhidgetInterfaceKit_getSensorCount(ik_handle_, &count);
      
      return count;
    }
    
    int getSensorValue(int index)
    {
      int value=-1;
      
      last_error_ = CPhidgetInterfaceKit_getSensorValue(ik_handle_, index, &value);
      
      return value;
    }
    
    int getSensorRawValue(int index)
    {
      int value=-1;
      
      last_error_ = CPhidgetInterfaceKit_getSensorRawValue(ik_handle_, index, &value);
      
      return value;
    }

    int getSensorChangeTrigger(int index)
    {
      int trigger=-1;
      
      last_error_ = CPhidgetInterfaceKit_getSensorChangeTrigger(ik_handle_, index, &trigger);
      
      return trigger;
    }
    
    int setSensorChangeTrigger(int index, int trigger)
    {
      return (last_error_ = CPhidgetInterfaceKit_setSensorChangeTrigger(ik_handle_, index, trigger));
    }
    
    int getRatiometric()
    {
      int ratiometric=-1;
      
      last_error_ = CPhidgetInterfaceKit_getRatiometric(ik_handle_, &ratiometric);
      
      return ratiometric;
    }
    
    int setRatiometric(int ratiometric)
    {
      return (last_error_ = CPhidgetInterfaceKit_setRatiometric(ik_handle_, ratiometric));
    }
    
    int getDataRate(int index)
    {
      int datarate=-1;
      
      last_error_ = CPhidgetInterfaceKit_getDataRate(ik_handle_, index, &datarate);
      
      return datarate;
    }
    
    int setDataRate(int index, int datarate)
    {
      return (last_error_ = CPhidgetInterfaceKit_setDataRate(ik_handle_, index, datarate));
    }
    
    int getDataRateMax(int index)
    {
      int max=-1;
      
      last_error_ = CPhidgetInterfaceKit_getDataRateMax(ik_handle_, index, &max);
      
      return max;
    }
    
    int getDataRateMin(int index)
    {
      int min=-1;
      
      last_error_ = CPhidgetInterfaceKit_getDataRateMin(ik_handle_, index, &min);
      
      return min;
    }
    
    int getLastError()
    {
      return last_error_;
    }

  protected:
    CPhidgetInterfaceKitHandle ik_handle_;
    
    int last_error_;
   

    virtual int attachHandler()
    {
      return 0;
    };


    virtual int inputChangeHandler(int index, int inputState)
    {
      return 0;
    }
    

    virtual int outputChangeHandler(int index, int outputState)
    {
      return 0;
    }
    

    virtual int sensorChangeHandler(int index, int sensorValue)
    {
      return 0;
    }
    
  private:
    static int attachDelegate(CPhidgetHandle phid, void *userptr)
    {
      return ((PhidgetIK*)userptr)->attachHandler();
    };

    static int inputChangeDelegate(CPhidgetInterfaceKitHandle phid, void *userPtr, int index, int inputState)
    {
      return ((PhidgetIK*)userPtr)->inputChangeHandler(index, inputState);
    }
    
    static int outputChangeDelegate(CPhidgetInterfaceKitHandle phid, void *userPtr, int index, int outputState)
    {
      return ((PhidgetIK*)userPtr)->outputChangeHandler(index, outputState);
    }
    
    static int sensorChangeDelegate(CPhidgetInterfaceKitHandle phid, void *userPtr, int index, int sensorValue)
    {
      return ((PhidgetIK*)userPtr)->sensorChangeHandler(index, sensorValue);
    }
};