asyncVelControllerBuilder.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/async/asyncVelIntegratedController.hpp"
#include "okapi/api/control/async/asyncVelPidController.hpp"
#include "okapi/api/control/async/asyncVelocityController.hpp"
#include "okapi/api/util/logging.hpp"
#include "okapi/impl/device/motor/motor.hpp"
#include "okapi/impl/device/motor/motorGroup.hpp"
#include "okapi/impl/device/rotarysensor/adiEncoder.hpp"
#include "okapi/impl/device/rotarysensor/integratedEncoder.hpp"
#include "okapi/impl/util/timeUtilFactory.hpp"
 
namespace okapi {
class AsyncVelControllerBuilder {
  public:
  explicit AsyncVelControllerBuilder(
    const std::shared_ptr<Logger> &ilogger = Logger::getDefaultLogger());
 
  AsyncVelControllerBuilder &withMotor(const Motor &imotor);
 
  AsyncVelControllerBuilder &withMotor(const MotorGroup &imotor);
 
  AsyncVelControllerBuilder &withMotor(const std::shared_ptr<AbstractMotor> &imotor);
 
  AsyncVelControllerBuilder &withSensor(const ADIEncoder &isensor);
 
  AsyncVelControllerBuilder &withSensor(const IntegratedEncoder &isensor);
 
  AsyncVelControllerBuilder &withSensor(const std::shared_ptr<RotarySensor> &isensor);
 
  AsyncVelControllerBuilder &withGains(const IterativeVelPIDController::Gains &igains);
 
  AsyncVelControllerBuilder &withVelMath(std::unique_ptr<VelMath> ivelMath);
 
  AsyncVelControllerBuilder &withDerivativeFilter(std::unique_ptr<Filter> iderivativeFilter);
 
  AsyncVelControllerBuilder &withGearset(const AbstractMotor::GearsetRatioPair &igearset);
 
  AsyncVelControllerBuilder &withMaxVelocity(double imaxVelocity);
 
  AsyncVelControllerBuilder &withTimeUtilFactory(const TimeUtilFactory &itimeUtilFactory);
 
  AsyncVelControllerBuilder &withLogger(const std::shared_ptr<Logger> &ilogger);
 
  AsyncVelControllerBuilder &parentedToCurrentTask();
 
  AsyncVelControllerBuilder &notParentedToCurrentTask();
 
  std::shared_ptr<AsyncVelocityController<double, double>> build();
 
  private:
  std::shared_ptr<Logger> logger;
 
  bool hasMotors{false}; // Used to verify motors were passed
  std::shared_ptr<AbstractMotor> motor;
 
  bool sensorsSetByUser{false}; // Used so motors don't overwrite sensors set manually
  std::shared_ptr<RotarySensor> sensor;
 
  bool hasGains{false}; // Whether gains were passed, no gains means integrated control
  IterativeVelPIDController::Gains gains;
 
  bool hasVelMath{false}; // Used to verify velMath was passed
  std::unique_ptr<VelMath> velMath;
 
  std::unique_ptr<Filter> derivativeFilter = std::make_unique<PassthroughFilter>();
 
  bool gearsetSetByUser{false}; // Used so motor's don't overwrite a gearset set manually
  AbstractMotor::GearsetRatioPair pair{AbstractMotor::gearset::invalid};
 
  bool maxVelSetByUser{false}; // Used so motors don't overwrite maxVelocity
  double maxVelocity{600};
 
  TimeUtilFactory timeUtilFactory = TimeUtilFactory();
  std::shared_ptr<Logger> controllerLogger = Logger::getDefaultLogger();
 
  bool isParentedToCurrentTask{true};
 
  std::shared_ptr<AsyncVelIntegratedController> buildAVIC();
  std::shared_ptr<AsyncVelPIDController> buildAVPC();
};
} // namespace okapi