Epos2.h

Go to the documentation of this file.

// Copyright (C) 2009-2010 Institut de Robòtica i Informàtica Industrial, CSIC-UPC.
// Author Martí Morta Garriga  (mmorta@iri.upc.edu)
// All rights reserved.
//
// Copyright (C) 2013 Jochen Sprickerhof <jochen@sprickerhof.de>
//
// This file is part of IRI EPOS2 Driver
// IRI EPOS2 Driver is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef Epos2_H
#define Epos2_H

#include <string>
#include <stdexcept>
#include <ftdi.hpp>

class CEpos2 {


        private:

    int8_t  node_id;

    static Ftdi::Context ftdi;
    static bool ftdi_initialized;




    void openDevice();

    int32_t readObject(int16_t index, int8_t subindex);

    int writeObject(int16_t index, int8_t subindex, int32_t data);

    void sendFrame(int16_t *frame);

    void receiveFrame(uint16_t* ans_frame);

    int16_t computeChecksum(int16_t *pDataArray, int16_t numberOfWords);



    long getNegativeLong  (long number);

    bool verbose;

    void p(const char *text);


    void p(const std::stringstream& text);


        public:

                CEpos2(int8_t nodeId = 0x00);

                ~CEpos2();

    void init();

    void close();


                long getState                   ();

                void shutdown                   ();

                void switchOn                   ();

                void quickStop                  ();

                void enableOperation            ();

                void disableOperation           ();

                void disableVoltage             ();

                void faultReset                 ();


                long getOperationMode           ();

    std::string getOpModeDescription    (long opmode);

                void setOperationMode           (long opmode);

                void enableController           ();

                void enableMotor                (long opmode);

                bool isTargetReached    ();




    enum epos_states{
      FAULT, START, NOT_READY_TO_SWITCH_ON, SWITCH_ON_DISABLED,
      READY_TO_SWITCH_ON, SWITCH_ON, REFRESH, MEASURE_INIT, OPERATION_ENABLE,
      QUICK_STOP, QUICK_STOP_ACTIVE_DISABLE, QUICK_STOP_ACTIVE_ENABLE };

    enum epos_opmodes{
      NO_OPERATION = 99, VELOCITY = -2, POSITION = -1, PROFILE_VELOCITY = 3,
      PROFILE_POSITION = 1, INTERPOLATED_PROFILE_POSITION = 7, HOMING = 6 };

    enum epos_posmodes{
      HALT, ABSOLUTE, RELATIVE };



                long getTargetVelocity          ();

                void setTargetVelocity          (long velocity);

                void startVelocity              ();

                void stopVelocity               ();



                long getTargetProfilePosition   ();

                void setTargetProfilePosition           (long position);

    void startProfilePosition (epos_posmodes mode, bool blocking=true, bool wait=true, bool new_point=true);



                long getTargetProfileVelocity   ();

                void setTargetProfileVelocity   (long velocity);

                void startProfileVelocity       ();

                void stopProfileVelocity                ();



                long getTargetCurrent           ();

                void setTargetCurrent           (long current);

                void startCurrent               ();

                void stopCurrent                ();


                void setHome                    ();

                void setHomePosition            (long home_position_qc);

                long getHomePosition            ();



                long getCurrentPGain            ();

                void setCurrentPGain            (long gain);

                long getCurrentIGain            ();

                void setCurrentIGain            (long gain);

        // Velocity

                long getVelocityPGain           ();

                void setVelocityPGain           (long gain);

                long getVelocityIGain           ();

                void setVelocityIGain           (long gain);

                long getVelocitySetPointFactorPGain     ();

                void setVelocitySetPointFactorPGain     (long gain);

        // Position

                long getPositionPGain           ();

                void setPositionPGain           (long gain);

                long getPositionIGain           ();

                void setPositionIGain           (long gain);

                long getPositionDGain           ();

                void setPositionDGain           (long gain);

                long getPositionVFFGain         ();

                void setPositionVFFGain         (long gain);

                long getPositionAFFGain         ();

                void setPositionAFFGain         (long gain);

        // General

                void getControlParameters(long &cp,long &ci,long &vp,long &vi,long &vspf, long &pp,long &pi,long &pd,long &pv,long &pa);

                void setControlParameters(long cp,long ci,long vp,long vi,long vspf,long pp,long pi,long pd,long pv,long pa);

                void printControlParameters(long cp,long ci,long vp,long vi,long vspf,long pp,long pi,long pd,long pv,long pa);




                long getProfileVelocity (void);


                void setProfileVelocity         (long velocity);

                long getProfileMaxVelocity      (void);

                void setProfileMaxVelocity      (long velocity);

                long getProfileAcceleration     (void);

                void setProfileAcceleration     (long acceleration);

                long getProfileDeceleration     (void);

                void setProfileDeceleration     (long deceleration);

                long getProfileQuickStopDecel(void);

                void setProfileQuickStopDecel   (long deceleration);

                long getProfileType             (void);

                void setProfileType             (long type);

                long getMaxAcceleration (void);

                void setMaxAcceleration (long max_acceleration);

        // General

                void getProfileData             (long &vel,long &maxvel,long &acc,long &dec,long &qsdec, long &maxacc, long &type);

                void setProfileData             (long vel,long maxvel,long acc,long dec,long qsdec,long maxacc,long type);




                long readVelocity               ();

                long readVelocitySensorActual   ();

                long readVelocityDemand ();

                long readVelocityActual ();

                long readCurrent                        ();

                long readCurrentAveraged                ();

                long readCurrentDemanded                ();

                int32_t readPosition            ();

                long readStatusWord             ();

                long readEncoderCounter ();

                long readEncoderCounterAtIndexPulse ();

                long readHallsensorPattern      ();

                long readFollowingError         ();

                void getMovementInfo            ();

        // Errors

                char readError                  ();

                void readErrorHistory           (long *error[5]);

                std::string searchErrorDescription      (long error_code);

    static const std::string error_names[];

    static const int error_codes[];

    static const std::string error_descriptions[];

        // Versions

                long readVersionSoftware                ();

                long readVersionHardware                ();






                long getEncoderPulseNumber      ();

                void setEncoderPulseNumber      (long pulses);

                long getEncoderType             ();

                void setEncoderType             (long type);

                long getEncoderPolarity         ();

                void setEncoderPolarity         (long polarity);

        // General

                void getEncoderParameters(long &pulses, long &type, long &polarity);

                void setEncoderParameters(long pulses, long type, long polarity);





                long getMotorType               ();

                void setMotorType       (long type);

                long getMotorContinuousCurrentLimit     ();

                void setMotorContinuousCurrentLimit     (long current_mA);

                long getMotorOutputCurrentLimit ();

                void setMotorOutputCurrentLimit (long current_mA);

                long getMotorPolePairNumber     ();

                void setMotorPolePairNumber     (char pole_pairs);

                long getThermalTimeCtWinding    ();

                void setThermalTimeCtWinding    (long time_ds);

        // General

                void getMotorParameters(long &type, long &current_c_mA, long &current_out_mA, char &pole_pairs, long &time_ds);

                void setMotorParameters(long type, long current_c_mA, long current_out_mA, char pole_pairs, long time_ds);


                // CONFIGURATION



                long getRS232Baudrate           ();

                void setRS232Baudrate           (long baudrate);

                long getRS232FrameTimeout       ();

                void setRS232FrameTimeout       (long timeout);

                long getUSBFrameTimeout         ();

                void setUSBFrameTimeout         (long timeout);


                long getMaxFollowingError       ();


                void setMaxFollowingError       (long follerror);

                long getMinPositionLimit                ();

                void setMinPositionLimit        (long limit);

                long getMaxPositionLimit                ();

                void setMaxPositionLimit        (long limit);

                void disablePositionLimits      (void);

                long getPositionWindow          ();

                void setPositionWindow          (long window_qc);

                long getPositionWindowTime              ();

                void setPositionWindowTime              (long time_ms);

                long getVelocityWindow          ();

                void setVelocityWindow          (long window_rm);

                long getVelocityWindowTime              ();

                void setVelocityWindowTime              (long time_ms);



                long getPositionNotationIndex           ();

                void setPositionNotationIndex           (long notation);

                long getVelocityNotationIndex           ();

                void setVelocityNotationIndex           (long notation);

                long getAccelerationNotationIndex               ();

                void setAccelerationNotationIndex               (long notation);


                long getPositionDimensionIndex          ();

                void setPositionDimensionIndex          (long Dimension);

                long getVelocityDimensionIndex          ();

                void setVelocityDimensionIndex          (long Dimension);

                long getAccelerationDimensionIndex              ();

                void setAccelerationDimensionIndex              (long Dimension);



                long getAnalogOutput1           ();

                void setAnalogOutput1           (long voltage_mV);

                void saveParameters             ();

                void restoreDefaultParameters   ();

    bool getVerbose();

    void setVerbose(bool verbose);

    long getPositionMarker(int buffer = 0);

    void setPositionMarker(char polarity = 0, char edge_type = 0,
                           char mode = 0, char digitalIN = 2);

    void waitPositionMarker();

    void setHoming(int home_method = 11, int speed_pos = 100,
                   int speed_zero = 100, int acc = 1000, int digitalIN = 2);

    void doHoming(bool blocking=false);

    static void *threadTargetReached(void *param);

    void stopHoming();

    int getDigInState(int digitalIN = 2);

    int getDigInStateMask();

    int getDigInFuncMask();

    int getDigInPolarity();

    int getDigInExecutionMask();

};

class EPOS2OpenException : public std::runtime_error
{
  public:
    EPOS2OpenException(const std::string& error_description)
      : std::runtime_error (error_description) {}
};

class EPOS2IOException : public std::runtime_error
{
  public:
    EPOS2IOException(const std::string& error_description)
      : std::runtime_error (error_description) {}
};

class EPOS2UnknownStateException : public std::runtime_error
{
  public:
    EPOS2UnknownStateException(const std::string& error_description)
      : std::runtime_error (error_description) {}
};

#endif