/home/benoit/sketchbook/libraries/HerkuleXLib/HkxSetup.h

Go to the documentation of this file.

#ifndef _HKXSETUP_H
#define _HKXSETUP_H

#include "Arduino.h"
#include "HkxCommunication.h"

class HkxSetup{
private:
  HkxCommunication& _herkXCom;
  HkxPrint& _print;
  const String _className;

  void errorPrint(const String& message){if(_print._errorMessages){_print.errorPrint(_className + message);}};

  void warningPrint(const String& message){if(_print._errorMessages){_print.warningPrint(_className + message);}};

  void infoPrint(const String& message){if(_print._errorMessages){_print.infoPrint(_className + message);}};

  uint8_t setPolicies(uint8_t ID, uint8_t newAlarmLEDPolicy, uint8_t newTorquePolicy);

  uint8_t setTemperatureVoltage(uint8_t ID, int16_t newMaxTemp, uint16_t newMinVoltage, uint16_t newMaxVoltage);

  uint8_t setAcceleration(uint8_t ID, uint8_t newAccelerationRatio, uint16_t newMaxAccelerationTime);
  
  uint8_t setLoadControl(uint8_t ID, uint16_t newDeadZone, uint8_t newSaturatorOffset, const uint32_t& newSaturatorSlope, int8_t newPWMOffset, uint8_t newMinPWM, uint16_t newMaxPWM);

  uint8_t setPWMPositionLimits(uint8_t ID, uint16_t newOverlaodPWMThreshold, int16_t newMinPosition, int16_t newMaxPosition);

  uint8_t setControlSystem(uint8_t ID, uint16_t kProportionnal, uint16_t kDerivative, uint16_t kInteger, uint16_t feedforwardGain1, uint16_t feedforwardGain2);

  uint8_t setErrorsCheckPeriod(uint8_t ID, uint16_t LEDBlink, uint16_t ADCFault, uint16_t packetGarbage, uint16_t stopDetection, uint16_t overloadDetection);

  uint8_t setInPositionCriteria(uint8_t ID, uint16_t stopThreshold, uint16_t inPositionMargin);

  uint8_t setTorqueLEDControl(uint8_t ID, hkxTorqueControl newTorqueControl,hkxLEDControl newLEDControl);

  uint8_t clearStatus(uint8_t ID);

  uint8_t factoryReset(uint8_t ID, boolean IDskip, boolean baudrateSkip);

  uint8_t reboot(uint8_t ID){
    if(ID > HKX_ID_ALL){
      errorPrint(F("reboot > Input not correct"));
    return 1;
    }
    return _herkXCom.rebootRequest(ID);
  };
public:  
  HkxSetup(HkxCommunication& herkXCom, HkxPrint& print) : _herkXCom(herkXCom), _print(print), _className(F("HkxSetup::")){};
  
  uint8_t getServoInfo(uint8_t ID, HkxMaybe<uint16_t> model, HkxMaybe<uint16_t> version);

  uint8_t getBaudRate(uint8_t ID, hkxBaudrate* baudRate); 

  uint8_t setAllBaudRate(const hkxBaudrate& baudrate); 

  uint8_t setID(uint8_t ID, uint8_t newID); 

  uint8_t getPolicies(uint8_t ID, HkxMaybe<uint8_t> newAlarmLEDPolicy, HkxMaybe<uint8_t> newTorquePolicy);

  uint8_t setOnePolicies(uint8_t ID, uint8_t newAlarmLEDPolicy, uint8_t newTorquePolicy){
    if(ID > HKX_MAX_ID){
      errorPrint(F("setOnePolicies > Input not correct"));
      return 1;
    }
    return setPolicies(ID, newAlarmLEDPolicy, newTorquePolicy);
  };

  uint8_t setAllPolicies(uint8_t newAlarmLEDPolicy, uint8_t newTorquePolicy){return setPolicies(HKX_ID_ALL, newAlarmLEDPolicy, newTorquePolicy);};

  uint8_t getTemperatureVoltage(uint8_t ID, HkxMaybe<int16_t> maxTemp, HkxMaybe<uint16_t> minVoltage, HkxMaybe<uint16_t> maxVoltage);

  uint8_t setOneTemperatureVoltage(uint8_t ID, int16_t newMaxTemp, uint16_t newMinVoltage, uint16_t newMaxVoltage){
    if(ID > HKX_MAX_ID){
      errorPrint(F("setOneMaxTemperature > Input value not correct"));
      return 1;
    }
    return setTemperatureVoltage(ID, newMaxTemp, newMinVoltage, newMaxVoltage);
  };

  uint8_t setAllTemperatureVoltage(int16_t newMaxTemp, int16_t newMinVoltage, int16_t newMaxVoltage){return setTemperatureVoltage(HKX_ID_ALL, newMaxTemp, newMinVoltage, newMaxVoltage);};

  uint8_t getAcceleration(uint8_t ID, HkxMaybe<uint8_t> accelerationRatio, HkxMaybe<uint16_t> maxAccelerationTime);
 
  uint8_t setOneAcceleration(uint8_t ID, uint8_t newAccelerationRatio, uint16_t newMaxAccelerationTime){
    if(ID > HKX_MAX_ID){
      errorPrint(F("setOneAcceleration > acceleration ratio value or max acceleration time not correct"));
      return 1;
    }
    return setAcceleration(ID, newAccelerationRatio, newMaxAccelerationTime);
  };

  uint8_t setAllAcceleration(uint8_t newAccelerationRatio, uint16_t newMaxAccelerationTime){return setAcceleration(HKX_ID_ALL, newAccelerationRatio, newMaxAccelerationTime);};
  
  uint8_t getLoadControl(uint8_t ID, HkxMaybe<uint16_t> deadZone, HkxMaybe<uint8_t> saturatorOffSet, HkxMaybe<uint32_t> saturatorSlope, HkxMaybe<int8_t> PWMoffset, HkxMaybe<uint8_t> minPWM, HkxMaybe<uint16_t> maxPWM);

  uint8_t setOneLoadControl(uint8_t ID, uint16_t newDeadZone, uint8_t newSaturatorOffset, const uint32_t& newSaturatorSlope, int8_t newPWMOffset, uint8_t newMinPWM, uint16_t newMaxPWM){
    if(ID > HKX_MAX_ID){
      errorPrint(F("setOneLoadControl > Input not correct"));
      return 1;
    }
    return setLoadControl(ID, newDeadZone, newSaturatorOffset, newSaturatorSlope, newPWMOffset, newMinPWM, newMaxPWM);
  };

  uint8_t setAllLoadControl(uint16_t newDeadZone, uint8_t newSaturatorOffset, const uint32_t& newSaturatorSlope, int8_t newPWMOffset, uint8_t newMinPWM, uint16_t newMaxPWM){return setLoadControl(HKX_ID_ALL, newDeadZone, newSaturatorOffset, newSaturatorSlope, newPWMOffset, newMinPWM, newMaxPWM);};

  uint8_t getPWMPositionLimits(uint8_t ID, HkxMaybe<uint16_t> overlaodPWMThreshold, HkxMaybe<int16_t> minPosition, HkxMaybe<int16_t> maxPosition);

  uint8_t setOnePWMPositionLimits(uint8_t ID, uint16_t newOverlaodPWMThreshold, int16_t newMinPosition, int16_t newMaxPosition){
    if(ID > HKX_MAX_ID){
      errorPrint(F("setOnePWMPositionLimits > Input not correct"));
      return 1;
    }
    return setPWMPositionLimits(ID, newOverlaodPWMThreshold, newMinPosition, newMaxPosition);
  }; 

  uint8_t setAllPWMPositionLimits(uint16_t newOverlaodPWMThreshold, int16_t newMinPosition, int16_t newMaxPosition){return setPWMPositionLimits(HKX_ID_ALL, newOverlaodPWMThreshold, newMinPosition, newMaxPosition);};

  uint8_t getControlSystem(uint8_t ID, HkxMaybe<uint16_t> kProportionnal, HkxMaybe<uint16_t> kDerivative, HkxMaybe<uint16_t> kInteger, HkxMaybe<uint16_t> feedforwardGain1, HkxMaybe<uint16_t> feedforwardGain2);

  uint8_t setOneControlSystem(uint8_t ID, uint16_t kProportionnal, uint16_t kDerivative, uint16_t kInteger, uint16_t feedforwardGain1, uint16_t feedforwardGain2){
    if(ID > HKX_MAX_ID){
      errorPrint(F("setOneControlSystem > Input not correct"));
      return 1;
    }
    return setControlSystem(ID, kProportionnal, kDerivative, kInteger, feedforwardGain1, feedforwardGain2);
  };

  uint8_t setAllControlSystem(uint16_t kProportionnal, uint16_t kDerivative, uint16_t kInteger, uint16_t feedforwardGain1, uint16_t feedforwardGain2){return setControlSystem(HKX_ID_ALL, kProportionnal, kDerivative, kInteger, feedforwardGain1, feedforwardGain2);};

  uint8_t getErrorsCheckPeriod(uint8_t ID, HkxMaybe<uint16_t> LEDBlink, HkxMaybe<uint16_t> ADCFault, HkxMaybe<uint16_t> packetGarbage, HkxMaybe<uint16_t> stopDetection, HkxMaybe<uint16_t> overloadDetection);

  uint8_t setOneErrorsCheckPeriod(uint8_t ID, uint16_t LEDBlink, uint16_t ADCFault, uint16_t packetGarbage, uint16_t stopDetection, uint16_t overloadDetection){
    if(ID > HKX_MAX_ID){
      errorPrint(F("setOneErrorsCheckPeriod > Input not correct"));
      return 1;
    }
    return setErrorsCheckPeriod(ID, LEDBlink, ADCFault, packetGarbage, stopDetection, overloadDetection);
  };

  uint8_t setAllErrorsCheckPeriod(uint16_t LEDBlink, uint16_t ADCFault, uint16_t packetGarbage, uint16_t stopDetection, uint16_t overloadDetection){return setErrorsCheckPeriod(HKX_ID_ALL, LEDBlink, ADCFault, packetGarbage, stopDetection, overloadDetection);};

  uint8_t getInPositionCriteria(uint8_t ID, HkxMaybe<uint16_t> stopThreshold, HkxMaybe<uint16_t> inPositionMargin);

  uint8_t setOneInPositionCriteria(uint8_t ID, uint16_t stopThreshold, uint16_t inPositionMargin){
    if(ID > HKX_MAX_ID){
      errorPrint(F("setOneInPositionCriteria > Input not correct"));
      return 1;
    }
    return setInPositionCriteria(ID, stopThreshold, inPositionMargin);
  };

  uint8_t setAllInPositionCriteria(uint16_t stopThreshold, uint16_t inPositionMargin){return setInPositionCriteria(HKX_ID_ALL, stopThreshold, inPositionMargin);};

  uint8_t getTorqueLEDControl(uint8_t ID, HkxMaybe<hkxTorqueControl> torqueControl, HkxMaybe<hkxLEDControl> LEDControl);

  uint8_t setOneTorqueLEDControl(uint8_t ID, hkxTorqueControl newTorqueControl, hkxLEDControl newLEDControl){
    if(ID > HKX_MAX_ID){
      errorPrint(F("setOneTorqueLEDControl > Input not correct"));
      return 1;
    }
    return setTorqueLEDControl(ID, newTorqueControl, newLEDControl);
  };

  uint8_t setAllTorqueLEDControl(hkxTorqueControl newTorqueControl,hkxLEDControl newLEDControl){return setTorqueLEDControl(HKX_ID_ALL, newTorqueControl, newLEDControl);};

  uint8_t getBehaviour(uint8_t ID, HkxMaybe<uint16_t> voltage, HkxMaybe<uint16_t> temperature, HkxMaybe<hkxControlMode> controlMode, HkxMaybe<uint16_t> tick, HkxMaybe<int16_t> absolutePosition, HkxMaybe<int16_t> velocity, HkxMaybe<int16_t> PWM, HkxMaybe<int16_t> absoluteGoalPosition, HkxMaybe<int16_t> absoluteDesiredTrajectoryPosition, HkxMaybe<int16_t> desiredVelocity);

  uint8_t getStatus(uint8_t ID, HkxStatus& statusED); 

  uint8_t clearOneStatus(uint8_t ID){
    if(ID > HKX_MAX_ID){
      errorPrint(F("clearOneStatus > Input not correct"));
      return 1;
    }
    return clearStatus(ID);
  };

  uint8_t clearAllStatus(){return clearStatus(HKX_ID_ALL);};

  void scanIDs(boolean IDs[]);

  uint8_t factoryResetOne(uint8_t ID, boolean IDskip, boolean baudrateSkip){
    if(ID > HKX_MAX_ID){
      errorPrint(F("factoryResetOne > Input not correct"));
      return 1;
    }
    return factoryReset(ID, IDskip, baudrateSkip);
  };

  uint8_t factoryResetAll(boolean IDskip, boolean baudrateSkip){return factoryReset(HKX_ID_ALL, IDskip, baudrateSkip);};

  uint8_t rebootOne(uint8_t ID){
    if(ID > HKX_MAX_ID){
      errorPrint(F("rebootOne > Input not correct"));
    return 1;
    }
    return reboot(ID);
  };

  void rebootAll(){reboot(HKX_ID_ALL);};
  
};

#endif    // _HKXSETUP_H