kmlExt.h

Go to the documentation of this file.

/*
 *   Katana Native Interface - A C++ interface to the robot arm Katana.
 *   Copyright (C) 2005 Neuronics AG
 *   Check out the AUTHORS file for detailed contact information.
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */


/******************************************************************************************************************/
#ifndef _KMLEXT_H_
#define _KMLEXT_H_
/******************************************************************************************************************/
#include "common/dllexport.h"
#include "common/exception.h"

#include "KNI/kmlBase.h"
#include "KNI/kmlMotBase.h"

#include <vector>


/******************************************************************************************************************/


class ConfigFileOpenException : public Exception {
public:
        ConfigFileOpenException(const std::string & port) throw ():
                Exception("Cannot open configuration file '" + port + "'", -40) {}
};


namespace KNI {
    class kmlFactory; 
}

class DLLDIR CKatana {
protected:
        //-------------------------------------//
        CKatBase*       base;   

        bool _gripperIsPresent;
        int  _gripperOpenEncoders;
        int  _gripperCloseEncoders;
        int mKatanaType;
        int mKinematics;

        void setTolerance(long idx, int enc_tolerance);

public:
        //-------------------------------------//
        CKatBase* GetBase()        { return base; } 

        CKatana()  { base = new CKatBase; }
        ~CKatana() { delete base; }
        //------------------------------------------------------------------------------//
        void create(const char* configurationFile, CCplBase* protocol);
        void create(KNI::kmlFactory* infos,  CCplBase* protocol);
        
        void create(TKatGNL& gnl,               
                                TKatMOT& mot,   
                                TKatSCT& sct,   
                                TKatEFF& eff,   
                                CCplBase* protocol      
                                );
        //------------------------------------------------------------------------------//


        /* \brief calibrates the robot
         */
        void calibrate();

        void calibrate( long idx,       
                        TMotCLB clb,    
                        TMotSCP scp,    
                        TMotDYL dyl     
        );

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

        void searchMechStop(long idx,           
                            TSearchDir dir,     
                            TMotSCP    scp,     
                            TMotDYL    dyl      
        );


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

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

        //------------------------------------------------------------------------------//
        // public just for dubbuging purposes
        bool checkENLD(long idx, double degrees);

        //------------------------------------------------------------------------------//
        
        void setGripperParameters(bool isPresent, int openEncoders, int closeEncoders);
        void getGripperParameters(bool &isPresent, int &openEncoders, int &closeEncoders);
        //------------------------------------------------------------------------------//

        void enableCrashLimits();
        void disableCrashLimits();
        void unBlock();
        void flushMoveBuffers();
        void setCrashLimit(long idx, int limit);
        void setPositionCollisionLimit(long idx, int limit);
        void setSpeedCollisionLimit(long idx, int limit);
        void setForceLimit(int axis, int limit);

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

        short getNumberOfMotors() const;
        int getMotorEncoders(short number, bool refreshEncoders = true) const;

        std::vector<int>::iterator getRobotEncoders(std::vector<int>::iterator start, std::vector<int>::const_iterator end, bool refreshEncoders = true) const;

        std::vector<int> getRobotEncoders(bool refreshEncoders = true) const;

        short getMotorVelocityLimit( short number ) const;
        short getMotorAccelerationLimit( short number ) const;

        void setMotorVelocityLimit( short number, short velocity );
        void setMotorAccelerationLimit( short number, short acceleration );
        short getForce(int axis);
        int getCurrentControllerType(int axis);

        void setRobotVelocityLimit( short velocity );
        void setRobotAccelerationLimit( short acceleration );

        void moveMotorByEnc( short number, int encoders,       bool waitUntilReached = false, int waitTimeout = 0);
        void moveMotorBy   ( short number, double radianAngle, bool waitUntilReached = false, int waitTimeout = 0);
        
        void moveMotorToEnc( short number, int encoders,       bool waitUntilReached = false, int encTolerance = 100, int waitTimeout = 0);
        void moveMotorTo   ( short number, double radianAngle, bool waitUntilReached = false, int waitTimeout = 0);

        void waitForMotor( short number, int encoders, int encTolerance = 100, short mode = 0, int waitTimeout = 5000);
        void waitFor(TMotStsFlg status, int waitTimeout);
        
        void moveRobotToEnc(std::vector<int>::const_iterator start, std::vector<int>::const_iterator end, bool waitUntilReached = false, int encTolerance = 100, int waitTimeout = 0);
        void moveRobotToEnc(std::vector<int> encoders, bool waitUntilReached = false, int encTolerance = 100, int waitTimeout = 0);
        void moveRobotToEnc4D(std::vector<int> target, int velocity=180, int acceleration = 1, int encTolerance = 100);

        void openGripper (bool waitUntilReached = false, int waitTimeout = 100);
        void closeGripper(bool waitUntilReached = false, int waitTimeout = 100);

        void freezeRobot();
        void freezeMotor(short number);
        void switchRobotOn();
        void switchRobotOff();
        void switchMotorOn(short number);
        void switchMotorOff(short number);

    void startSplineMovement(bool exactflag, int moreflag = 1);

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

    void setAndStartPolyMovement(std::vector<short> polynomial, bool exactflag, int moreflag);
    
        int readDigitalIO();
};

/******************************************************************************************************************/
#endif //_KMLEXT_H_
/******************************************************************************************************************/