Controller.h

Go to the documentation of this file.

#pragma once
#include <gmi/iface/GmiInterface.h>
#include <misc/gen/PropertySheetDialog.h>
#include <misc/gen/TClassRegistration.h>
 
namespace sf::gmi
{
 
class _GMI_CLASS Controller
{
  public:
    struct Parameters
    {
        Parameters() = default;
 
        explicit Parameters(int mode)
          : _mode(mode)
        {}
 
        int _mode{0};
    };
 
    Controller(const Parameters&);
 
    virtual ~Controller();
 
    void destroy();
 
    bool initialize();
 
    bool uninitialize();
 
    void hookEventHandler(ControllerEvent handler);
 
    void unhookEventHandler(ControllerEvent handler);
 
    bool storeSettings(bool rd);
 
    class _GMI_CLASS Axis
    {
      public:
        EAxisLocation getLocation() const;
 
        AxisMovements getMovements() const;
 
        const char* getName() const;
 
        const char* getDescription() const;
 
        double getCurrent(EAxisValueType avt) const;
 
        bool setCurrent(EAxisValueType avt, double val);
 
        double getAccuracy() const;
 
        double getResolution() const;
 
        double getMinMax(EAxisMinMax amm) const;
 
        bool setOffset(double ofs);
 
        double setOffset() const;
 
        double getTarget(EAxisValueType avt) const;
 
        bool setTarget(EAxisValueType avt, double val);
 
        bool setPosition(double value);
 
        double normalized(double pos) const;
 
        bool setMode(EAxisMode mode);
 
        EAxisMode getMode() const;
 
        bool canModeChange(EAxisMode cur_mode, EAxisMode new_mode, bool pos_cmplt, bool vel_cmplt, bool con_cmplt);
 
        typedef TVector<Axis*> PtrVector;
 
      protected:
        Axis(Controller* mc, EAxisLocation);
 
        virtual ~Axis();
 
        AxisMovements _movements;
 
      private:
        Controller& _controller;
        EAxisLocation _location;
 
        friend Controller;
    };
 
    bool homeAxes(bool skip);
 
    bool setJoystick(EJoystickCmd jsc);
 
    EJoystickCmd getJoystick() const;
 
    EAxisLocation getJoystickAxis() const;
 
    bool setJoystickAxis(EAxisLocation axis_loc);
 
    EAxisLocation getPopAxis() const;
 
    bool setPopAxis(EAxisLocation al);
 
    bool setTriggerEnable(bool enable);
 
    bool getTriggerEnable() const;
 
    double setTriggerFreq(double freq);
 
    double getTriggerFreq() const;
 
    //
    // Movement execution related functions and properties.
    //
 
    bool setMovePos(EMovePosCmd mpc);
 
    EMovePosCmd getMovePos() const;
 
    bool setMoveVel(EMoveVelCmd mvc);
 
    EMoveVelCmd getMoveVel() const;
 
    bool setMoveCon(EMoveConCmd mcc);
 
    EMoveConCmd getMoveCon() const;
 
    Axis& getAxis(int axis_loc);
 
    const Axis& getAxis(int axis_loc) const;
 
    Axis& getPhysicalAxis(int axis_num);
 
    virtual void addPropertyPages(PropertySheetDialog* sheet);
 
    bool getCurrent(EAxisValueType avt, AxesCoord& ac) const;
 
    bool setCurrent(EAxisValueType avt, const AxesCoord& coord);
 
    bool getTarget(EAxisValueType avt, AxesCoord& coord) const;
 
    bool setTarget(EAxisValueType avt, const AxesCoord& coord);
 
    bool setTarget(const AxesCoord& pos, const AxesCoord& vel, const AxesCoord& acc, bool linear);
 
    bool setMode(EAxisMode am, const AxesCoord& ac, EAxisMode amdef = amDISABLED);
 
    bool setTriggerAxis(EAxisLocation al);
 
    EAxisLocation getTriggerAxis() const;
 
    double getTriggerDensity() const;
 
    bool setTriggerDensity(double td);
 
    bool setTriggerMode(bool intern);
 
    bool getTriggerMode() const;
 
    bool setChuckJaw(EChuckJaw cj);
 
    EChuckJaw getChuckJaw() const;
 
    bool isMovePosCompleted() const;
 
    bool isMoveVelCompleted() const;
 
    bool isMoveConCompleted() const;
 
    bool isMoving() const;
 
    bool setPosition(EAxisLocation al, double value);
 
    bool setPosition(const AxesCoord& ac);
 
    AxesCoord& normalize(AxesCoord& pos) const;
 
    AxesCoord normalized(const AxesCoord& dist) const;
 
    AxisLocations getRadialUnlimited() const;
 
    virtual void openDebugger() {}
 
    // Information retrieval functions.
    enum EStatus : int
    {
      csERROR = -1,
      csUNINIT = 0,
      csINIT,
      csUNHOMED,
      csHOMING,
      csREADY,
    };
 
    inline bool isReady() const;
 
    static const char* getAxisName(int axis_loc);
 
    static const char* getAxisDescription(int axis_loc);
 
    static const char* getStatusName(EStatus status);
 
    const char* getStatusName() const;
 
    unsigned getAxisCount() const;
 
    std::string getLastErrorText() const;
 
    //
    // Parameter manipulation and retrieval functions.
    //
 
    bool getParamInfo(IdType id, ParamInfo& info) const;
 
    bool getParam(IdType id, Value& value) const;
 
    bool setParam(IdType id, const Value& value, bool skip_event);
 
    bool setGetParam(IdType id, Value& value, bool skip_event);
 
    virtual bool handleParam(IdType id, ParamInfo* info, const Value* setval, Value* getval) = 0;
 
    virtual IdType getParamId(EParam param, int axis = std::numeric_limits<int>::max()) const = 0;
 
    virtual bool enumParamIds(IdList& ids) const = 0;
 
    void setParamHook(NotifyProc proc, void* data);
 
    void setResultHook(NotifyProc proc, void* data);
 
    virtual IdType getResultId(EResult result, int axis = std::numeric_limits<int>::max()) const = 0;
 
    virtual bool enumResultIds(IdList& ids) const = 0;
 
    bool getResultInfo(IdType id, ResultInfo& info) const;
 
    virtual bool handleResult(IdType id, ResultInfo* info, BufferInfo* buf_info) = 0;
 
    bool getResultBuffer(IdType id, BufferInfo& buf_info);
 
    bool getAccuracy(AxesCoord& accuracy) const;
 
    bool getResolution(AxesCoord& resolution) const;
 
    bool getMinMax(EAxisMinMax amm, AxesCoord& coord) const;
 
    bool setOffset(const AxesCoord& coord);
 
    bool getOffset(AxesCoord& coord) const;
 
    std::string getProfilePath() const;
 
  protected:
    virtual bool doInitialize(bool) = 0;
 
    virtual bool doSetPosition(EAxisLocation al, double);
 
    virtual bool doHomeAxes(bool skip);
 
    void setLastErrorText(const char* text);
 
    void setStatus(EStatus status);
 
    EStatus getStatus() const;
 
    void callParamHook(IdType id);
 
    void callResultHook(IdType id);
 
    void sendPopEvent();
 
  private:
    void sendEvent(EControllerEvent ce);
 
    bool setParam(EParam param, int axis, const Value& value, bool skip_event);
 
    bool getParam(EParam param, int axis, Value& value) const;
 
    void attach(Axis* axis);
 
    Axis* getAxisPtr(int axis_loc);
 
    bool _flagDestroying;
    Axis::PtrVector _axes;
    Axis* _axesMap[alLastEntry];
    Axis _nullAxis;
    std::string _lastErrorText;
    EStatus _status;
    NotifyProc _paramNotifyProc;
    NotifyProc _resultNotifyProc;
    void* _paramNotifyData;
    void* _resultNotifyData;
    bool _noEventGeneration;
    typedef TVector<ControllerEvent> EventList;
    EventList _motionEventList;
 
    friend Axis;
 
    // Declarations of static functions and data members to be able to create registered RSA implementations.
    SF_DECL_IFACE(Controller, Controller::Parameters, Interface)
};
 
inline bool Controller::isReady() const
{
  return _status == csREADY;
}
 
inline bool Controller::getResultInfo(IdType id, ResultInfo& info) const
{
  return const_cast<Controller*>(this)->handleResult(id, &info, nullptr);
}
 
inline bool Controller::getResultBuffer(IdType id, BufferInfo& buf_info)
{
  return handleResult(id, nullptr, &buf_info);
}
 
inline bool Controller::getParamInfo(IdType id, ParamInfo& info) const
{
  return const_cast<Controller*>(this)->handleParam(id, &info, NULL, NULL);
}
 
inline bool Controller::getParam(IdType id, Value& value) const
{
  return const_cast<Controller*>(this)->handleParam(id, NULL, NULL, &value);
}
 
inline void Controller::sendPopEvent()
{
  sendEvent(cePOPEVENT);
}
 
inline void Controller::setParamHook(NotifyProc proc, void* data)
{
  _paramNotifyProc = proc;
  _paramNotifyData = data;
}
 
inline void Controller::setResultHook(NotifyProc proc, void* data)
{
  _resultNotifyProc = proc;
  _resultNotifyData = data;
}
 
inline bool Controller::isMovePosCompleted() const
{
  return getMovePos() == mpcCOMPLETE;
}
 
inline bool Controller::isMoveVelCompleted() const
{
  return getMoveVel() == mvcCOMPLETE;
}
 
inline bool Controller::isMoveConCompleted() const
{
  return getMoveCon() == mccCOMPLETE;
}
 
inline unsigned Controller::getAxisCount() const
{
  return _axes.count();
}
 
inline Controller::Axis* Controller::getAxisPtr(int axis_loc)
{
  return &getAxis(axis_loc);
}
 
inline Controller::EStatus Controller::getStatus() const
{
  return _status;
}
 
inline std::string Controller::getLastErrorText() const
{
  return _lastErrorText;
}
 
inline void Controller::setLastErrorText(const char* text)
{
  _lastErrorText = text;
}
 
inline const char* Controller::getStatusName() const
{
  return getStatusName(_status);
}
 
inline AxesCoord Controller::normalized(const AxesCoord& dist) const
{
  AxesCoord ac(dist);
  return normalize(ac);
}
 
inline EAxisLocation Controller::Axis::getLocation() const
{
  return _location;
}
 
inline AxisMovements Controller::Axis::getMovements() const
{
  return _movements;
}
 
}// namespace sf::gmi