abstractMotor.hpp

Go to the documentation of this file.

/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
#pragma once
 
#include "okapi/api/control/controllerOutput.hpp"
#include "okapi/api/device/rotarysensor/continuousRotarySensor.hpp"
#include <memory>
 
namespace okapi {
class AbstractMotor : public ControllerOutput<double> {
  public:
  enum class brakeMode {
    coast = 0, 
    brake = 1, 
    hold = 2,  
    invalid = INT32_MAX
  };
 
  enum class encoderUnits {
    degrees = 0,        
    rotations = 1,      
    counts = 2,         
    invalid = INT32_MAX 
  };
 
  enum class gearset {
    red = 100,   
    green = 200, 
    blue = 600,  
    invalid = INT32_MAX
  };
 
  struct GearsetRatioPair {
    GearsetRatioPair(const gearset igearset, const double iratio = 1)
      : internalGearset(igearset), ratio(iratio) {
    }
 
    ~GearsetRatioPair() = default;
 
    gearset internalGearset;
    double ratio = 1;
  };
 
  virtual ~AbstractMotor();
 
  /******************************************************************************/
  /******************************************************************************/
 
  virtual std::int32_t moveAbsolute(double iposition, std::int32_t ivelocity) = 0;
 
  virtual std::int32_t moveRelative(double iposition, std::int32_t ivelocity) = 0;
 
  virtual std::int32_t moveVelocity(std::int16_t ivelocity) = 0;
 
  virtual std::int32_t moveVoltage(std::int16_t ivoltage) = 0;
 
  virtual std::int32_t modifyProfiledVelocity(std::int32_t ivelocity) = 0;
 
  /******************************************************************************/
  /******************************************************************************/
 
  virtual double getTargetPosition() = 0;
 
  virtual double getPosition() = 0;
 
  double getPositionError();
 
  virtual std::int32_t tarePosition() = 0;
 
  virtual std::int32_t getTargetVelocity() = 0;
 
  virtual double getActualVelocity() = 0;
 
  double getVelocityError();
 
  virtual std::int32_t getCurrentDraw() = 0;
 
  virtual std::int32_t getDirection() = 0;
 
  virtual double getEfficiency() = 0;
 
  virtual std::int32_t isOverCurrent() = 0;
 
  virtual std::int32_t isOverTemp() = 0;
 
  virtual std::int32_t isStopped() = 0;
 
  virtual std::int32_t getZeroPositionFlag() = 0;
 
  virtual uint32_t getFaults() = 0;
 
  virtual uint32_t getFlags() = 0;
 
  virtual std::int32_t getRawPosition(std::uint32_t *timestamp) = 0;
 
  virtual double getPower() = 0;
 
  virtual double getTemperature() = 0;
 
  virtual double getTorque() = 0;
 
  virtual std::int32_t getVoltage() = 0;
 
  /******************************************************************************/
  /******************************************************************************/
 
  virtual std::int32_t setBrakeMode(brakeMode imode) = 0;
 
  virtual brakeMode getBrakeMode() = 0;
 
  virtual std::int32_t setCurrentLimit(std::int32_t ilimit) = 0;
 
  virtual std::int32_t getCurrentLimit() = 0;
 
  virtual std::int32_t setEncoderUnits(encoderUnits iunits) = 0;
 
  virtual encoderUnits getEncoderUnits() = 0;
 
  virtual std::int32_t setGearing(gearset igearset) = 0;
 
  virtual gearset getGearing() = 0;
 
  virtual std::int32_t setReversed(bool ireverse) = 0;
 
  virtual std::int32_t setVoltageLimit(std::int32_t ilimit) = 0;
 
  virtual std::shared_ptr<ContinuousRotarySensor> getEncoder() = 0;
};
 
AbstractMotor::GearsetRatioPair operator*(AbstractMotor::gearset gearset, double ratio);
 
} // namespace okapi