cinosbasemotor.h

Go to the documentation of this file.

//******************************************************************************
//******************************************************************************
 
#ifndef INC_CINOSBASEMOTOR_H
#define INC_CINOSBASEMOTOR_H
 
//------------------------------------------------------------------------------
// defines
//------------------------------------------------------------------------------
//
#define DF_INOS_BASE_MOTOR_DBT  "INOS-BASE-MOTOR"// db table name
#define DF_INOS_BASE_MOTOR_NAME "CINOSBaseMotor" // motor name
//
#define DF_INOS_MOTOR_TRQ_LIMIT_DBT "INOS-MOTOR-TRQ-LIMIT"  // db table name
//
// --- motor states ------------------------------------------------------------
//
//
// --- motor errors ------------------------------------------------------------
//
//
// --- motor warnings ----------------------------------------------------------
//
//
// --- motor flags -------------------------------------------------------------
//                       
//
//------------------------------------------------------------------------------
// includes
//------------------------------------------------------------------------------
//
// system
#include <cinosprocessimage.h>
//
// C++
//
// project
//
//------------------------------------------------------------------------------
//--- structures ---------------------------------------------------------------
//------------------------------------------------------------------------------
//
struct SINOSBaseMotor
{
    inosName64 m_cName;
 
    inosName32 m_cType;
 
    inosName m_cUnit;
 
    inosName32 m_cTrqLimitAcc;
 
    inosName32 m_cTrqLimitDec;
 
    double m_dTurnsPerMin;
 
    double m_dIncsPerTurn;
 
    double m_dFeedPerTurn;
 
    double m_dUnitsPerInc;
 
    double m_dInertia;
 
    double m_dGearRatio;
 
    double m_dGearInp;
 
    double m_dGearOut;
 
    double m_dGearInp2;
 
    double m_dGearOut2;
 
    real64 m_dPowerPosition;
 
    uint32 m_uIncReference;
 
    uint32 m_uOptions;
 
    uint8 m_uDigits;
 
    uint8 m_uIncPosition;
 
    uint8 m_uNumber;
 
    SINOSBaseMotor();
};
 
struct SINOSMotorTrqLimitPoint
{
    inosName32 m_cName;
    uint32 m_uNumber;
    uint32 m_uDummy;
    real64 m_rRpm;
    real64 m_rN;
};
 
struct SINOSMotorTrqLimit
{
    uint32 m_uNumber;
    uint32 m_uDummy;
    real64* m_rRpm;
    real64* m_rN;
};
 
//------------------------------------------------------------------------------
// class definition
//------------------------------------------------------------------------------
//
class CINOSBaseMotor
{
    //--- user interface ---------------------------------------------------
 
    // public member functions
    public :
 
        explicit CINOSBaseMotor(SINOSBaseMotor* apDesc);
        virtual ~CINOSBaseMotor();
 
        static CINOSBaseMotor* GetMotor(const char* apAxisName, 
            const char* apMotorType);
 
        const char* GetName()
            { return m_pDesc->m_cName; };
        
        virtual uint32 GetParam(const char* apName, real64& arResult);
            //; universal get parameter with apName to arResult and return error code
        virtual uint32 SetParam(const char* apName, real64 arValue);
            //; universal set parameter with apName to arValue and return error code
                    
        virtual void GetUnitsPerInc(double& arUnits);
            //; get number of units per one inc
        virtual void SetIncsPerUnit(double& arIncs);
            //; set number of incs per unit
        virtual void GetIncsPerUnit(double& arIncs);
            //; get number of incs per unit
        virtual void SetInertia(double arInertia);
            //; set inertia
        virtual void GetInertia(double& arInertia);
            //; get inertia
        virtual void SetGearRatio(double adGearRatio);
            //; set gear ratio
        virtual void GetGearRatio(double& arGearRatio);
            //; get gear ratio
        virtual void SetFeedPerTurn(double arFeedPerTurn);
            //; set feed per turn (b)
        virtual void GetFeedPerTurn(double& arFeedPerTurn);
            //; get feed per turn (b)
        virtual void SetIncsPerTurn(double arIncsPerTurn);
            //; set incs per turn
        virtual void GetIncsPerTurn(double& arIncsPerTurn);
            //; get incs per turn
        virtual void GetTurnsPerMin(double& arTurnsPerMin);
            //; get turns per min
        virtual void GetIncPosition(uint8& auIncPosition);
            //; get position of increments (A=0, B=1)
        virtual void GetIncReference(uint32& auIncReference);
            //; get length of reference in [inc]
 
        virtual CINCOObject* GetRegister();
            //; do inco registration and return pointer to it
 
        void GetTrqLimit(SINOSMotorTrqLimit*& apLimitAcc, SINOSMotorTrqLimit*& apLimitDec)
            { apLimitAcc = m_pTrqLimitAcc; apLimitDec = m_pTrqLimitDec; }
 
    //--- internals --------------------------------------------------------
 
    // protected member functions
    protected:
        void iCalc();
        void SetupTrqLimit(const char* apName, SINOSMotorTrqLimit*& apLimit);
 
    // protected members
    protected:
 
        // pointers
        
        CINCOObject* m_pRegister;
        CINCOObject* m_pCfg;
        SINOSBaseMotor* m_pDesc;
        const char* m_pType;
 
        // parameters
 
        double m_dTurnsPerMin;
        double m_dIncsPerTurn;
        double m_dFeedPerTurn;
        double m_dUnitsPerInc;
        double m_dInertia;
        double m_dGearRatio;
 
        // factors
 
        double m_dKnf_s;
        double m_dKnf_1s;
            
        uint32 m_uCharacteristics;
 
        // torque limitation
 
        SINOSMotorTrqLimit* m_pTrqLimitAcc;
        SINOSMotorTrqLimit* m_pTrqLimitDec;
 
    // allow dynamic object handling (new/delete)
    DECLARE_DYNAMIC(CINOSBaseMotor);
};
 
//------------------------------------------------------------------------------
// class registration
//------------------------------------------------------------------------------
 
typedef CINOSBaseMotor *(*TCreateMotor)(const char* apAxisName);
 
class CINOSRegisterBaseMotor
{   
    // after this function you can register new controllers
    friend void _INI_0000_CINOSBaseMotor();
    
    //--- internals --------------------------------------------------------
 
    // private members 
private:
    // pointer to the first registered motor
    static CINOSRegisterBaseMotor* m_pFirst; 
    // pointer to the next motor
    CINOSRegisterBaseMotor* m_pNext; 
    // create funtion for the motor
    TCreateMotor m_pCreate;
    // motor type name
    const char* m_pMotorType;
        
    //--- user interface ---------------------------------------------------
 
public:
    // register a new motor type
    CINOSRegisterBaseMotor(TCreateMotor apFunction,
        const char* apMotorType);
    
    // create and return and new motor instance
    static CINOSBaseMotor* GetMotor(const char* apAxisName,
        const char* apMotorType);
};
 
//------------------------------------------------------------------------------
// end of file
//------------------------------------------------------------------------------
 
#endif  // INC_CINOSBASEMOTOR_H