CDxlGeneric.h

Go to the documentation of this file.

// Dynamixel control code - header file
// Copyright (c) 2008 Erik Schuitema, Eelko van Breda
// Delft University of Technology
// www.dbl.tudelft.nl

#ifndef __DXLGENERIC_H_INCLUDED__
#define __DXLGENERIC_H_INCLUDED__
#include "CDxlCom.h"
#include "CDxlConfig.h"
#include "CDxlGroup.h"
#include <threemxl/platform/io/logging/Log2.h>

#include <iostream>
#include <iomanip>

#define PACKET_RETRY_FACTOR 1

//forward declarations
class CDxlConfig;
class CDxlGroup;

typedef struct
{
  uint16_t time; 
  float pwm,     
        current, 
        voltage, 
        desired, 
        actual;  
} __attribute__((packed)) TMxlLogEntry;

inline std::ostream &operator<<(std::ostream &outs, const TMxlLogEntry &obj)
{
  outs << std::fixed
       << std::setw(8) << obj.time << " "
       << std::setw(8) << obj.pwm << " "
       << std::setw(8) << std::setprecision(3) << obj.current << " "
       << std::setw(8) << std::setprecision(3) << obj.voltage << " "
       << std::setw(8) << std::setprecision(3) << obj.desired << " "
       << std::setw(8) << std::setprecision(3) << obj.actual
       << std::resetiosflags(std::ios_base::floatfield);

  return outs;
}

typedef std::vector<TMxlLogEntry> TMxlLog;


class CDxlGeneric: public CDxlCom
{
protected:
                CDxlGroup*      mpGroup;
                int                     mID;
                int                     mRetlevel;
                CLog2           mLog;

public:
                CDxlGeneric():  mLog("CDxlGeneric")
                {
//                      mLog.setLevel(llDebug);
//                      mLog.enableConsoleOutput("false");
                        mpGroup = NULL;
                }
                virtual ~CDxlGeneric() {};


                int                     readData(BYTE startingAddress, BYTE dataLength, BYTE *data);


                int                             writeData(BYTE startingAddress, BYTE dataLength, BYTE *data, bool shouldSyncWrite=false);
                
                int                             action();
                
                int                             reset();
                

                int                             ping();


                virtual int             getID()=0;


                virtual void    setGroup(CDxlGroup* group) { mpGroup = group;}


                virtual void    setConfig(CDxlConfig* config) {};


                virtual void    setSerialPort(LxSerial* serialPort) {};


                virtual int             init(bool sendConfigToMotor=true) {mLogWarningLn("init function not implemented"); return false;};


                virtual void    setPositiveDirection(bool clockwiseIsPositive) {mLogWarningLn("setPositiveDirection function not implemented");};


                virtual void    setNullAngle(double nullAngle) {mLogWarningLn("setNullAngle function not implemented");};


                virtual int             setPos(double pos, bool shouldSyncWrite=false) {mLogWarningLn("setPos/1 function not implemented"); return false;};
                

                virtual int             setPos(double pos, double absSpeed, bool shouldSyncWrite=false) {mLogWarningLn("setPos/2 function not implemented"); return false;};
                

                virtual int             setPos(double pos, double absSpeed, double acceleration, bool shouldSyncWrite=false) {mLogWarningLn("setPos/3 function not implemented"); return false;};
                

                virtual int             setLinearPos(double pos, bool shouldSyncWrite=false) {mLogWarningLn("setPosLinear/1 function not implemented"); return false;};
                

                virtual int             setLinearPos(double pos, double absSpeed, bool shouldSyncWrite=false) {mLogWarningLn("setPosLinear/2 function not implemented"); return false;};
                

                virtual int             setLinearPos(double pos, double absSpeed, double acceleration, bool shouldSyncWrite=false) {mLogWarningLn("setPosLinear/3 function not implemented"); return false;};
                

                virtual int             setSpeed(double speed, bool shouldSyncWrite=false) {mLogWarningLn("setSpeed function not implemented"); return false;};


                virtual int             setLinearSpeed(double speed, bool shouldSyncWrite=false) {mLogWarningLn("setLinearSpeed function not implemented"); return false;};


                virtual int             setAcceleration(double acceleration, bool shouldSyncWrite=false) {mLogWarningLn("setAcceleration function not implemented"); return false;};


                virtual int             setLinearAcceleration(double acceleration, bool shouldSyncWrite=false) {mLogWarningLn("setLinearAcceleration function not implemented"); return false;};


                virtual int             setTorque(double torque, bool shouldSyncWrite=false)  {mLogWarningLn("setTorque function not implemented"); return false;};


                virtual int             setCurrent(double current, bool shouldSyncWrite=false)  {mLogWarningLn("setCurrent function not implemented"); return false;};


                virtual int             setPWM(double pwm, bool shouldSyncWrite=false)  {mLogWarningLn("setPWM function not implemented"); return false;};


                virtual int     setPosSpeedTorquePPosDPos(double pos, double speed, double torque, int pPos, int dPos, bool shouldSyncWrite=false) {mLogWarningLn("setPosSpeedTorquePPosDPos function not implemented"); return false;};


                virtual int             setPIDCurrent(double p, double d, double i, double i_limit, bool shouldSyncWrite=false)  {mLogWarningLn("setPIDCurrent function not implemented"); return false;};


                virtual int             getPIDCurrent(double &p, double &d, double &i, double &i_limit)  {mLogWarningLn("getPIDCurrent function not implemented"); return false;};


                virtual int             setPIDPosition(double p, double d, double i, double i_limit, bool shouldSyncWrite=false)  {mLogWarningLn("setPIDPosition function not implemented"); return false;};


                virtual int             getPIDPosition(double &p, double &d, double &i, double &i_limit)  {mLogWarningLn("getPIDPosition function not implemented"); return false;};


                virtual int             setPIDSpeed(double p, double d, double i, double i_limit, bool shouldSyncWrite=false)  {mLogWarningLn("setPIDSpeed function not implemented"); return false;};


                virtual int             getPIDSpeed(double &p, double &d, double &i, double &i_limit)  {mLogWarningLn("getPIDSpeed function not implemented"); return false;};


                virtual int             setPIDTorque(double p, double d, double i, double i_limit, bool shouldSyncWrite=false)  {mLogWarningLn("setPIDSpeed function not implemented"); return false;};


                virtual int             getPIDTorque(double &p, double &d, double &i, double &i_limit)  {mLogWarningLn("getPIDTorque function not implemented"); return false;};


                virtual int             setPIDEnergy(double p, double d, double i, double i_limit, bool shouldSyncWrite=false)  {mLogWarningLn("setPIDEnergy function not implemented"); return false;};


                virtual int             getPIDEnergy(double &p, double &d, double &i, double &i_limit)  {mLogWarningLn("getPIDEnergy function not implemented"); return false;};


                virtual int             setRetlevel(const int returnlevel) {mLogWarningLn("setRetlevel function not implemented"); return false;};


                virtual int             setBaudRateIndex(const BYTE baudRateIndex) {mLogWarningLn("setBaudRateIndex function not implemented"); return false;};


                virtual int             setBaudRate(const int baudRate) {mLogWarningLn("setBaudRate function not implemented"); return false;};


                virtual int             setReturnDelayTime(const int microsecondsReturnDelay) {mLogWarningLn("setReturnDelayTime function not implemented"); return false;};


                virtual int             setInitialTorqueLimit(double absMaxTorque) {mLogWarningLn("setInitialTorqueLimit function not implemented"); return false;};


                virtual int             setTorqueLimit(double absMaxTorque) {mLogWarningLn("setTorqueLimit function not implemented"); return false;};


                virtual int             setAngleLimits(double lowerLimit, double upperLimit) {mLogWarningLn("setAngleLimits function not implemented"); return false;};


                virtual int             setVoltageLimits(double minVoltage, double maxVoltage) {mLogWarningLn("setVoltageLimits function not implemented"); return false;};


                virtual int             setTemperatureLimit(const int maxTemp) {mLogWarningLn("setTemperatureLimit function not implemented"); return false;};


                virtual int             setAngleLowerLimit(double limit) {mLogWarningLn("setAngleLowerLimit function not implemented"); return false;};                                         // In [rad].


                virtual int             setAngleUpperLimit(double limit){mLogWarningLn("setAngleUpperLimit function not implemented"); return false;};                                          // In [rad].


                virtual int             setCompliance(BYTE complianceMargin, BYTE complianceSlope){mLogWarningLn("setCompliance function not implemented"); return false;};


                virtual int             setPunch(WORD punch){mLogWarningLn("setPunch function not implemented"); return false;};


                virtual int             setAlarmLEDMask(const BYTE mask){mLogWarningLn("setAlarmLEDMask function not implemented"); return false;};


                virtual int             setOperatingMode(const BYTE mode){mLogWarningLn("setOperatingMode function not implemented"); return false;};


                virtual int             setAlarmShutdownMask(const BYTE mask){mLogWarningLn("setAlarmShutdownMask function not implemented"); return false;};


                virtual int             changeID(const int newID){mLogWarningLn("changeID function not implemented"); return false;};


                virtual int             enableLED(int state){mLogWarningLn("enableLED function not implemented"); return false;};


                virtual int             enableTorque(int state){mLogWarningLn("enableTorque function not implemented"); return false;};


                virtual int             setEndlessTurnMode(bool enabled, bool shouldSyncWrite=false){mLogWarningLn("setEndlessTurnMode function not implemented"); return false;};


                virtual int             setEndlessTurnTorque(double torqueRatio, bool shouldSyncWrite=false){mLogWarningLn("setEndlessTurnTorque function not implemented"); return false;};


                virtual int             set3MxlMode(BYTE mxlMode, bool shouldSyncWrite = false){mLogWarningLn("set3MxlMode function not implemented"); return false;};


                virtual int             setPositiveDirectionMotor(bool clockwiseIsPositive){mLogWarningLn("setPositiveDirectionMotor function not implemented"); return false;};


                virtual int             setPositiveDirectionJoint(bool clockwiseIsPositive){mLogWarningLn("setPositiveDirectionJoint function not implemented"); return false;};


                virtual int             setMotorOffset(double offset){mLogWarningLn("setMotorOffset function not implemented"); return false;};


                virtual int             setJointOffset(double offset){mLogWarningLn("setJointOffset function not implemented"); return false;};


                virtual int             setEncoderCountMotor(WORD encodercount){mLogWarningLn("setEncoderCountMotor function not implemented"); return false;};


                virtual int             setEncoderCountJoint(WORD encodercount){mLogWarningLn("setEncoderCountJoint function not implemented"); return false;};


                virtual int             setMotorConstant(WORD motorconstant){mLogWarningLn("setMotorConstant function not implemented"); return false;};
                

                virtual int             setMaxPeakMotorCurrent(double current){mLogWarningLn("setMaxMotorPeakCurrent function not implemented"); return false;};
                

                virtual int             setMaxContinuousMotorCurrent(double current){mLogWarningLn("setMaxMotorContinuousCurrent function not implemented"); return false;};
                

                virtual int             setMotorWindingTimeConstant(double time){mLogWarningLn("setMotorWindingTimeConstant function not implemented"); return false;};
                

                virtual int             setEncoderIndexLevelMotor(BYTE level){mLogWarningLn("setEncoderIndexLevelMotor function not implemented"); return false;};
                

                virtual int             setWheelDiameter(double diameter){mLogWarningLn("setWheelDiameter function not implemented"); return false; };


                virtual int             setGearboxRatioMotor(float gearboxratiomotor){mLogWarningLn("setGearboxRatioMotor function not implemented"); return false;};


                virtual int             setGearboxRatioJoint(float gearboxratiojoint){mLogWarningLn("setGearboxRatioJoint function not implemented"); return false;};


                virtual int             setWatchdogMode(BYTE watchdogmode){mLogWarningLn("setWatchdogMode function not implemented"); return false;};


                virtual int             setWatchdogTime(BYTE watchdogtime){mLogWarningLn("setWatchdogTime function not implemented"); return false;};


                virtual int             setWatchdogMultiplier(BYTE watchdogmultiplier){mLogWarningLn("setWatchdogMultiplier function not implemented"); return false;};


                virtual int             setMaxUninitializedMotorCurrent(WORD maxcurrent){mLogWarningLn("setMaxUninitializedMotorCurrent function not implemented"); return false;};


                virtual int             setMaxMotorCurrent(WORD maxcurrent){mLogWarningLn("setMaxMotorCurrent function not implemented"); return false;};


                virtual int             setZeroLengthSpring(double parameterInRad){mLogWarningLn("setZeroLengthSpring function not implemented"); return false;};


                virtual int             setSpringStiffness(double stiffness){mLogWarningLn("setSpringStiffness function not implemented"); return false;};
                

                virtual int             setReferenceEnergy(double energy){mLogWarningLn("setReferenceEnergy function not implemented"); return false;};
                

                virtual int             setSineFrequency(double frequency, bool shouldSyncWrite=false)  {mLogWarningLn("setSineFrequency function not implemented"); return false;};
                

                virtual int             setSineAmplitude(double amplitude, bool shouldSyncWrite=false)  {mLogWarningLn("setSineAmplitude function not implemented"); return false;};
                

                virtual int             setSinePhase(double phase, bool shouldSyncWrite=false)  {mLogWarningLn("setSinePhase function not implemented"); return false;};
                

                virtual int             setLogInterval(BYTE interval){mLogWarningLn("startLog function not implemented"); return false; };


                virtual int             setSyncReadIndex(BYTE index){mLogWarningLn("setSyncReadIndex function not implemented"); return false; };


                virtual int             getPos(){mLogWarningLn("getPos function not implemented"); return false;};


                virtual int             getLinearPos(){mLogWarningLn("getLinearPos function not implemented"); return false;};


                virtual int             getPosAndSpeed(){mLogWarningLn("getPosAndSpeed function not implemented"); return false;};


                virtual int             getTemp(){mLogWarningLn("getTemp function not implemented"); return false;};


                virtual int             getState(){mLogWarningLn("getState function not implemented"); return false;};


                virtual int             getAngleLimits(){mLogWarningLn("getAngleLimits function not implemented"); return false;};


                virtual int             getVoltage(){mLogWarningLn("getVoltage function not implemented"); return false;};


                virtual int             getBusVoltage(){mLogWarningLn("getBusVoltage function not implemented"); return false;};


                virtual int             getSensorVoltages(){mLogWarningLn("getSensorsVoltages function not implemented"); return false; };


                virtual int             getCurrent(){mLogWarningLn("getCurrent function not implemented"); return false;};


                virtual int             getTorque(){mLogWarningLn("getTorque function not implemented"); return false;};


                virtual int             getTorquePosSpeed(){mLogWarningLn("getTorquePosSpeed function not implemented"); return false;};
                

                virtual int             getAcceleration(){mLogWarningLn("getAcceleration function not implemented"); return false;};
                

                virtual int             getLinearAcceleration(){mLogWarningLn("getLinearAcceleration function not implemented"); return false;};
                
                virtual int             getStatus(){mLogWarningLn("getStatus function not implemented"); return false;};
                

                virtual int             getLog(){mLogWarningLn("getLog function not implemented"); return false;};

                virtual int             get3MxlMode(){mLogWarningLn("get3MxlMode function not implemented"); return false;};
                

                virtual double  presentPos()=0;


                virtual double  presentLinearPos()=0;


                virtual double  presentSpeed()=0;


                virtual double  presentAcceleration()=0;
                

                virtual double  presentLinearAcceleration()=0;
                

                virtual double  presentLoad()=0;


                virtual double  presentVoltage()=0;


                virtual double  presentBusVoltage()=0;


                virtual double  presentCurrentADCVoltage()=0;


                virtual double  presentAnalog1Voltage()=0;


                virtual double  presentAnalog2Voltage()=0;


                virtual double  presentAnalog3Voltage()=0;


                virtual double  presentAnalog4Voltage()=0;


                virtual double  presentTemp()=0;


                virtual double  presentCurrent()=0;


                virtual double  presentTorque()=0;


                virtual int     presentStatus(){mLogWarningLn("presentStatus function not implemented"); return 0;};


                virtual bool    presentMotorInitState() {mLogWarningLn("presentMotorInitState function not implemented"); return 0;};


                virtual WORD    presentCWAngleLimit()=0;


                virtual WORD    presentCCWAngleLimit()=0;


                virtual double  presentAngleLowerLimit()=0;


                virtual double  presentAngleUpperLimit()=0;


                virtual TMxlLog presentLog(){mLogWarningLn("presentLog function not implemented"); return TMxlLog();};


                virtual BYTE    present3MxlMode(){mLogWarningLn("present3MxlMode function not implemented"); return 0;};


                virtual int     printReport(FILE* fOut){mLogWarningLn("printReport function not implemented"); return false;};


                virtual int     interpretControlData(BYTE address, BYTE length, BYTE *data){mLogWarningLn("interpretControlData function not implemented"); return false;};
};


#endif //__DXLGENERIC_H_INCLUDED__