$search

kmlMotBase.h

Go to the documentation of this file.

//
// C++ Interface: MotBase
//
// Description: 
//
//
// Author: Tiziano Müller <tiziano.mueller@neuronics.ch>, (C) 2006
//
// Copyright: See COPYING file that comes with this distribution
//
//

#ifndef KMLMOTBASE_H
#define KMLMOTBASE_H

#include "common/exception.h"
#include "common/dllexport.h"

#include "KNI/kmlCommon.h"
#include "KNI/cplBase.h"

#include <vector>

class CKatBase; // forward declaration
class CMotBase; // forward declaration


/****************************************************************************/
// CMotBase ----------------------------------------------------------------//
/****************************************************************************/

struct  TMotDesc {
        byte            slvID;          
};

struct  TKatMOT {
        short           cnt;            
        CMotBase*       arr;            
        TMotDesc*       desc;           
};

typedef enum TMotCmdFlg {
        MCF_OFF                 = 0,            
        MCF_CALIB               = 4,            
        MCF_FREEZE              = 8,            
        MCF_ON                  = 24,           
        MCF_CLEAR_MOVEBUFFER    = 32            
};

typedef enum TMotStsFlg {
        MSF_MECHSTOP    = 1,            
        MSF_MAXPOS      = 2,            
        MSF_MINPOS      = 4,            
        MSF_DESPOS      = 8,            
        MSF_NORMOPSTAT  = 16,           
        MSF_MOTCRASHED  = 40,           
        MSF_NLINMOV     = 88,           
        MSF_LINMOV      = 152,          
        MSF_NOTVALID    = 128           
};
enum TSearchDir {                       
        DIR_POSITIVE,
        DIR_NEGATIVE
};


//--------------------------------------------------------------------------//

struct TMotGNL {
        CKatBase*       own;            
        byte            SID;            
};

struct TMotSFW {
        byte            version;        
        byte            subversion;     
        byte            revision;       
        byte            type;           
        byte            subtype;        
};

struct TMotAPS {
        TMotCmdFlg      mcfAPS;         
        short           actpos;         
};

struct TMotTPS {
        TMotCmdFlg      mcfTPS;         
        short           tarpos;         
};

struct TMotSCP {

        //--------------- Motor old parameters -------------------------------//
        //
        byte            maxppwm;        
        byte            maxnpwm;        
        byte            kP;             
        byte            kI;             
        byte            kD;             
        byte            kARW;           
        //byte          kSpeed;         //!< prop. factor of speed limit comp
        byte            kP_speed;       
        byte            kI_speed;       
        byte            kD_speed;       

        //--------------- Motor new parameters -------------------------------//
        //
        byte            maxppwm_nmp;    
        byte            maxnpwm_nmp;    
        byte            kspeed_nmp;     
        byte            kpos_nmp;       
        byte            kI_nmp;         
        int             crash_limit_nmp;        
        int             crash_limit_lin_nmp;    
};

struct TMotDYL {

        //--------------- Motor old parameters -------------------------------//
        //
        byte            maxaccel;       
        byte            maxdecel;       
        short           minpos;         
        short           maxpspeed;      
        short           maxnspeed;      
        //byte          maxpcurr;       // no more active
        //byte          maxncurr;       // no more active
        byte            maxcurr;        
        byte            actcurr;        

        //--------------- Motor new parameters -------------------------------//
        //
        byte            maxaccel_nmp;   
        short           maxpspeed_nmp;  
        short           maxnspeed_nmp;  
        byte            maxcurr_nmp;    
};

struct TMotPVP {
        TMotStsFlg      msf;            
        short           pos;            
        short           vel;            
        byte            pwm;            
};

struct TMotENL {
        int     enc_range;              
        int     enc_minpos;             
        int     enc_maxpos;             
        int     enc_per_cycle;          
        int     enc_tolerance;          
};


struct TMotCLB {
  bool          enable;                 
  short       order;                    
  
  TSearchDir    dir;                    
  TMotCmdFlg    mcf;                    
  
  int                 encoderPositionAfter;
  bool          isCalibrated;
  
  TMotDYL dyl;
  TMotSCP scp;
};


struct TMotInit {
        int             encoderOffset;
        int             encodersPerCycle;
        double          angleOffset;
        double          angleRange;
        int             rotationDirection;

        // calculated ones:
        double                  angleStop;
};

//--------------------------------------------------------------------------//

class DLLDIR CMotBase {

        friend class CKatBase;


protected:
        TMotGNL gnl;                    
        TMotAPS aps;                    
        TMotTPS tps;                    
        TMotSCP scp;                    
        TMotDYL dyl;                    
        TMotPVP pvp;                    
        TMotSFW sfw;                    
        TMotCLB  _calibrationParameters;
        TMotENL  _encoderLimits;        
        TMotInit _initialParameters;
        bool    freedom;                
        bool    blocked;                


public:
        const TMotGNL* GetGNL() { return &gnl; }
        const TMotAPS* GetAPS() { return &aps; }
        const TMotTPS* GetTPS() { return &tps; }
        const TMotSCP* GetSCP() { return &scp; }
        const TMotDYL* GetDYL() { return &dyl; }
        const TMotPVP* GetPVP() { return &pvp; }
        const TMotSFW* GetSFW() { return &sfw; }
        const TMotCLB* GetCLB() { return &_calibrationParameters; }

        const TMotInit* GetInitialParameters() { return &_initialParameters; }
        const int GetEncoderTolerance() { return _encoderLimits.enc_tolerance; }
        const int GetEncoderMinPos() { return _encoderLimits.enc_minpos; }      
        const int GetEncoderMaxPos() { return _encoderLimits.enc_maxpos; }      
        const int GetEncoderRange() { return _encoderLimits.enc_range; }        
const bool GetFreedom() { return freedom; }const bool GetBlocked() { return blocked; }

protected:
        CCplBase* protocol;     

public:
        virtual ~CMotBase() {}  //destructor

        bool init(CKatBase* _own, const TMotDesc _motDesc, CCplBase* protocol);
        void sendAPS(const TMotAPS* _aps);      void sendTPS(const TMotTPS* _tps);
        void recvPVP(); void recvSFW();

        void setSCP(TMotSCP _scp) { scp = _scp; }
        void setDYL(TMotDYL _dyl) { dyl = _dyl; }

        
        void setInitialParameters(double angleOffset, double angleRange, int encodersPerCycle, int encoderOffset, int rotationDirection);
        void setCalibrationParameters(bool doCalibration, short order, TSearchDir direction, TMotCmdFlg motorFlagAfter, int encoderPositionAfter);
        void setCalibrated(bool calibrated);
                                      
        void setTolerance(int tolerance);

        bool checkAngleInRange(double angle);   
        bool checkEncoderInRange(int encoder);

        void inc(int dif, bool wait = false, int tolerance = 100, long timeout = TM_ENDLESS);
        void dec(int dif, bool wait = false, int tolerance = 100, long timeout = TM_ENDLESS);
        void mov(int tar, bool wait = false, int tolerance = 100, long timeout = TM_ENDLESS);

        void waitForMotor(int tar, int encTolerance = 100, short mode = 0, int waitTimeout = TM_ENDLESS);

        void incDegrees(double dif, bool wait = false, int tolerance = 100, long timeout = TM_ENDLESS);
        void decDegrees(double dif, bool wait = false, int tolerance = 100, long timeout = TM_ENDLESS);
        void movDegrees(double tar, bool wait = false, int tolerance = 100, long timeout = TM_ENDLESS);

        void resetBlocked();


    void sendSpline(short targetPosition, short duration, short p1, short p2, short p3, short p4);

        void setSpeedLimits(short positiveVelocity, short negativeVelocity);
        void setSpeedLimit(short velocity) { setSpeedLimits(velocity, velocity); }

        void setAccelerationLimit( short acceleration );
        
        void setPwmLimits(byte maxppwm, byte maxnpwm);
        
        void setControllerParameters(byte kSpeed, byte kPos, byte kI);
        
        void setCrashLimit(int limit);
        void setCrashLimitLinear(int limit_lin);
        void setSpeedCollisionLimit(int limit);
        void setPositionCollisionLimit(int limit);

        void getParameterOrLimit(int subcommand, byte* R1, byte* R2, byte* R3);
};


#endif

---

kni
Author(s): Neuronics AG (see AUTHORS.txt); ROS wrapper by Martin Günther
autogenerated on Tue Mar 5 12:32:59 2013