Third robot commit.
All tests pass!
Change-Id: I086248537f075fd06afdfb3e94670eb7646aaf6c
diff --git a/y2016_bot3/control_loops/intake/BUILD b/y2016_bot3/control_loops/intake/BUILD
new file mode 100644
index 0000000..887a63c
--- /dev/null
+++ b/y2016_bot3/control_loops/intake/BUILD
@@ -0,0 +1,96 @@
+package(default_visibility = ['//visibility:public'])
+
+load('/aos/build/queues', 'queue_library')
+
+queue_library(
+ name = 'intake_queue',
+ srcs = [
+ 'intake.q',
+ ],
+ deps = [
+ '//aos/common/controls:control_loop_queues',
+ '//frc971/control_loops:queues',
+ ],
+)
+
+genrule(
+ name = 'genrule_intake',
+ visibility = ['//visibility:private'],
+ cmd = '$(location //y2016_bot3/control_loops/python:intake) $(OUTS)',
+ tools = [
+ '//y2016_bot3/control_loops/python:intake',
+ ],
+ outs = [
+ 'intake_plant.h',
+ 'intake_plant.cc',
+ 'integral_intake_plant.h',
+ 'integral_intake_plant.cc',
+ ],
+)
+
+cc_library(
+ name = 'intake_plants',
+ srcs = [
+ 'intake_plant.cc',
+ 'integral_intake_plant.cc',
+ ],
+ hdrs = [
+ 'intake_plant.h',
+ 'integral_intake_plant.h',
+ ],
+ deps = [
+ '//frc971/control_loops:state_feedback_loop',
+ ],
+)
+
+cc_library(
+ name = 'intake_lib',
+ srcs = [
+ 'intake.cc',
+ 'intake_controls.cc',
+ ],
+ hdrs = [
+ 'intake.h',
+ 'intake_controls.h',
+ ],
+ deps = [
+ ':intake_queue',
+ ':intake_plants',
+ '//aos/common/controls:control_loop',
+ '//aos/common/util:trapezoid_profile',
+ '//aos/common:math',
+ '//y2016_bot3/queues:ball_detector',
+ '//frc971/control_loops:state_feedback_loop',
+ '//frc971/control_loops:simple_capped_state_feedback_loop',
+ '//frc971/zeroing',
+ ],
+)
+
+cc_test(
+ name = 'intake_lib_test',
+ srcs = [
+ 'intake_lib_test.cc',
+ ],
+ deps = [
+ ':intake_queue',
+ ':intake_lib',
+ '//aos/testing:googletest',
+ '//aos/common:queues',
+ '//aos/common/controls:control_loop_test',
+ '//aos/common:math',
+ '//aos/common:time',
+ '//frc971/control_loops:position_sensor_sim',
+ ],
+)
+
+cc_binary(
+ name = 'intake',
+ srcs = [
+ 'intake_main.cc',
+ ],
+ deps = [
+ '//aos/linux_code:init',
+ ':intake_lib',
+ ':intake_queue',
+ ],
+)
diff --git a/y2016_bot3/control_loops/intake/intake.cc b/y2016_bot3/control_loops/intake/intake.cc
new file mode 100644
index 0000000..5320cd5
--- /dev/null
+++ b/y2016_bot3/control_loops/intake/intake.cc
@@ -0,0 +1,265 @@
+#include "y2016_bot3/control_loops/intake/intake.h"
+#include "y2016_bot3/control_loops/intake/intake_controls.h"
+
+#include "aos/common/commonmath.h"
+#include "aos/common/controls/control_loops.q.h"
+#include "aos/common/logging/logging.h"
+
+#include "y2016_bot3/control_loops/intake/integral_intake_plant.h"
+#include "y2016_bot3/queues/ball_detector.q.h"
+
+namespace y2016_bot3 {
+namespace control_loops {
+namespace intake {
+
+namespace {
+// The maximum voltage the intake roller will be allowed to use.
+constexpr float kMaxIntakeTopVoltage = 12.0;
+constexpr float kMaxIntakeBottomVoltage = 12.0;
+
+}
+// namespace
+
+void LimitChecker::UpdateGoal(double intake_angle_goal) {
+ intake_->set_unprofiled_goal(intake_angle_goal);
+}
+
+Intake::Intake(control_loops::IntakeQueue *intake_queue)
+ : aos::controls::ControlLoop<control_loops::IntakeQueue>(intake_queue),
+ limit_checker_(&intake_) {}
+bool Intake::IsIntakeNear(double tolerance) {
+ return ((intake_.unprofiled_goal() - intake_.X_hat())
+ .block<2, 1>(0, 0)
+ .lpNorm<Eigen::Infinity>() < tolerance);
+}
+
+double Intake::MoveButKeepAbove(double reference_angle, double current_angle,
+ double move_distance) {
+ return -MoveButKeepBelow(-reference_angle, -current_angle, -move_distance);
+}
+
+double Intake::MoveButKeepBelow(double reference_angle, double current_angle,
+ double move_distance) {
+ // There are 3 interesting places to move to.
+ const double small_negative_move = current_angle - move_distance;
+ const double small_positive_move = current_angle + move_distance;
+ // And the reference angle.
+
+ // Move the the highest one that is below reference_angle.
+ if (small_negative_move > reference_angle) {
+ return reference_angle;
+ } else if (small_positive_move > reference_angle) {
+ return small_negative_move;
+ } else {
+ return small_positive_move;
+ }
+}
+
+void Intake::RunIteration(const control_loops::IntakeQueue::Goal *unsafe_goal,
+ const control_loops::IntakeQueue::Position *position,
+ control_loops::IntakeQueue::Output *output,
+ control_loops::IntakeQueue::Status *status) {
+ const State state_before_switch = state_;
+ if (WasReset()) {
+ LOG(ERROR, "WPILib reset, restarting\n");
+ intake_.Reset();
+ state_ = UNINITIALIZED;
+ }
+
+ // Bool to track if we should turn the motors on or not.
+ bool disable = output == nullptr;
+
+ intake_.Correct(position->intake);
+
+ // There are 2 main zeroing paths, HIGH_ARM_ZERO and LOW_ARM_ZERO.
+ //
+ // HIGH_ARM_ZERO works by lifting the arm all the way up so it is clear,
+ // moving the shooter to be horizontal, moving the intake out, and then moving
+ // the arm back down.
+ //
+ // LOW_ARM_ZERO works by moving the intake out of the way, lifting the arm up,
+ // leveling the shooter, and then moving back down.
+
+ if (intake_.error()) {
+ state_ = ESTOP;
+ }
+
+ switch (state_) {
+ case UNINITIALIZED:
+ // Wait in the uninitialized state until intake is initialized.
+ LOG(DEBUG, "Uninitialized, waiting for intake\n");
+ if (intake_.initialized()) {
+ state_ = DISABLED_INITIALIZED;
+ }
+ disable = true;
+ break;
+
+ case DISABLED_INITIALIZED:
+ // Wait here until we are either fully zeroed while disabled, or we become
+ // enabled.
+ if (disable) {
+ if (intake_.zeroed()) {
+ state_ = SLOW_RUNNING;
+ }
+ } else {
+ if (intake_.angle() <= kIntakeMiddleAngle) {
+ state_ = ZERO_LIFT_INTAKE;
+ } else {
+ state_ = ZERO_LOWER_INTAKE;
+ }
+ }
+
+ // Set the goals to where we are now so when we start back up, we don't
+ // jump.
+ intake_.ForceGoal(intake_.angle());
+ // Set up the profile to be the zeroing profile.
+ intake_.AdjustProfile(0.5, 10);
+
+ // We are not ready to start doing anything yet.
+ disable = true;
+ break;
+
+ case ZERO_LOWER_INTAKE:
+ if (disable) {
+ state_ = DISABLED_INITIALIZED;
+ } else {
+ intake_.set_unprofiled_goal(kIntakeDownAngle);
+
+ if (IsIntakeNear(kLooseTolerance)) {
+ // Close enough, start the next move.
+ state_ = RUNNING;
+ }
+ }
+ break;
+
+ case ZERO_LIFT_INTAKE:
+ if (disable) {
+ state_ = DISABLED_INITIALIZED;
+ } else {
+ intake_.set_unprofiled_goal(kIntakeUpAngle);
+
+ if (IsIntakeNear(kLooseTolerance)) {
+ // Close enough, start the next move.
+ state_ = RUNNING;
+ }
+ }
+ break;
+
+ // These 4 cases are very similar.
+ case SLOW_RUNNING:
+ case RUNNING: {
+ if (disable) {
+ // If we are disabled, go to slow running if we are collided.
+ // Reset the profile to the current position so it moves well from here.
+ intake_.ForceGoal(intake_.angle());
+ }
+
+ double requested_intake = M_PI / 2.0;
+
+ if (unsafe_goal) {
+ intake_.AdjustProfile(unsafe_goal->max_angular_velocity_intake,
+ unsafe_goal->max_angular_acceleration_intake);
+
+ requested_intake = unsafe_goal->angle_intake;
+ }
+ //Push the request out to the hardware.
+ limit_checker_.UpdateGoal(requested_intake);
+
+ // ESTOP if we hit the hard limits.
+ if (intake_.CheckHardLimits() && output) {
+ state_ = ESTOP;
+ }
+ } break;
+
+ case ESTOP:
+ LOG(ERROR, "Estop\n");
+ disable = true;
+ break;
+ }
+
+ // Set the voltage limits.
+ const double max_voltage =
+ (state_ == RUNNING) ? kOperatingVoltage : kZeroingVoltage;
+
+ intake_.set_max_voltage(max_voltage);
+
+ // Calculate the loops for a cycle.
+ {
+ Eigen::Matrix<double, 3, 1> error = intake_.controller().error();
+ status->intake.position_power = intake_.controller().K(0, 0) * error(0, 0);
+ status->intake.velocity_power = intake_.controller().K(0, 1) * error(1, 0);
+ }
+
+ intake_.Update(disable);
+
+ // Write out all the voltages.
+ if (output) {
+ output->voltage_intake = intake_.intake_voltage();
+
+ output->voltage_top_rollers = 0.0;
+ output->voltage_bottom_rollers = 0.0;
+
+ if (unsafe_goal) {
+ // Ball detector lights.
+ ::y2016_bot3::sensors::ball_detector.FetchLatest();
+ bool ball_detected = false;
+ if (::y2016_bot3::sensors::ball_detector.get()) {
+ ball_detected = ::y2016_bot3::sensors::ball_detector->voltage > 2.5;
+ }
+
+ // Intake.
+ if (unsafe_goal->force_intake || !ball_detected) {
+ output->voltage_top_rollers = ::std::max(
+ -kMaxIntakeTopVoltage,
+ ::std::min(unsafe_goal->voltage_top_rollers, kMaxIntakeTopVoltage));
+ output->voltage_bottom_rollers =
+ ::std::max(-kMaxIntakeBottomVoltage,
+ ::std::min(unsafe_goal->voltage_bottom_rollers,
+ kMaxIntakeBottomVoltage));
+ } else {
+ output->voltage_top_rollers = 0.0;
+ output->voltage_bottom_rollers = 0.0;
+ }
+
+ // Traverse.
+ output->traverse_unlatched = unsafe_goal->traverse_unlatched;
+ output->traverse_down = unsafe_goal->traverse_down;
+ }
+ }
+
+ // Save debug/internal state.
+ status->zeroed = intake_.zeroed();
+
+ status->intake.angle = intake_.X_hat(0, 0);
+ status->intake.angular_velocity = intake_.X_hat(1, 0);
+ status->intake.goal_angle = intake_.goal(0, 0);
+ status->intake.goal_angular_velocity = intake_.goal(1, 0);
+ status->intake.unprofiled_goal_angle = intake_.unprofiled_goal(0, 0);
+ status->intake.unprofiled_goal_angular_velocity =
+ intake_.unprofiled_goal(1, 0);
+ status->intake.calculated_velocity =
+ (intake_.angle() - last_intake_angle_) / 0.005;
+ status->intake.voltage_error = intake_.X_hat(2, 0);
+ status->intake.estimator_state = intake_.IntakeEstimatorState();
+ status->intake.feedforwards_power = intake_.controller().ff_U(0, 0);
+
+ last_intake_angle_ = intake_.angle();
+
+ status->estopped = (state_ == ESTOP);
+
+ status->state = state_;
+
+ last_state_ = state_before_switch;
+}
+
+constexpr double Intake::kZeroingVoltage;
+constexpr double Intake::kOperatingVoltage;
+constexpr double Intake::kLooseTolerance;
+constexpr double Intake::kTightTolerance;
+constexpr double Intake::kIntakeUpAngle;
+constexpr double Intake::kIntakeMiddleAngle;
+constexpr double Intake::kIntakeDownAngle;
+
+} // namespace intake
+} // namespace control_loops
+} // namespace y2016_bot3
diff --git a/y2016_bot3/control_loops/intake/intake.h b/y2016_bot3/control_loops/intake/intake.h
new file mode 100644
index 0000000..fed17ab
--- /dev/null
+++ b/y2016_bot3/control_loops/intake/intake.h
@@ -0,0 +1,153 @@
+#ifndef Y2016_BOT3_CONTROL_LOOPS_INTAKE_INTAKE_H_
+#define Y2016_BOT3_CONTROL_LOOPS_INTAKE_INTAKE_H_
+
+#include <memory>
+
+#include "aos/common/controls/control_loop.h"
+#include "aos/common/util/trapezoid_profile.h"
+#include "frc971/control_loops/state_feedback_loop.h"
+
+#include "frc971/zeroing/zeroing.h"
+#include "y2016_bot3/control_loops/intake/intake.q.h"
+#include "y2016_bot3/control_loops/intake/intake_controls.h"
+
+namespace y2016_bot3 {
+namespace constants {
+static const int kZeroingSampleSize = 200;
+
+// Ratios for our subsystems.
+// TODO(constants): Update these.
+static constexpr double kIntakeEncoderRatio = 18.0 / 72.0 * 15.0 / 48.0;
+
+static constexpr double kIntakePotRatio = 15.0 / 48.0;
+
+// Difference in radians between index pulses.
+static constexpr double kIntakeEncoderIndexDifference =
+ 2.0 * M_PI * kIntakeEncoderRatio;
+
+// Subsystem motion ranges, in whatever units that their respective queues say
+// the use.
+// TODO(constants): Update these.
+static constexpr ::frc971::constants::Range kIntakeRange{// Lower hard stop
+ -0.5,
+ // Upper hard stop
+ 2.90,
+ // Lower soft stop
+ -0.300,
+ // Uppper soft stop
+ 2.725};
+
+struct IntakeZero {
+ double pot_offset = 0.0;
+ ::frc971::constants::ZeroingConstants zeroing{
+ kZeroingSampleSize, kIntakeEncoderIndexDifference, 0.0, 0.3};
+};
+} // namespace constants
+namespace control_loops {
+namespace intake {
+namespace testing {
+class IntakeTest_RespectsRange_Test;
+class IntakeTest_DisabledGoalTest_Test;
+class IntakeTest_IntakeZeroingErrorTest_Test;
+class IntakeTest_UpperHardstopStartup_Test;
+class IntakeTest_DisabledWhileZeroingHigh_Test;
+class IntakeTest_DisabledWhileZeroingLow_Test;
+}
+
+class LimitChecker {
+ public:
+ LimitChecker(IntakeArm *intake) : intake_(intake) {}
+ void UpdateGoal(double intake_angle_goal);
+ private:
+ IntakeArm *intake_;
+};
+
+class Intake : public ::aos::controls::ControlLoop<control_loops::IntakeQueue> {
+ public:
+ explicit Intake(
+ control_loops::IntakeQueue *my_intake = &control_loops::intake_queue);
+
+ static constexpr double kZeroingVoltage = 6.0;
+ static constexpr double kOperatingVoltage = 12.0;
+
+ // This is the large scale movement tolerance.
+ static constexpr double kLooseTolerance = 0.05;
+
+ // This is the small scale movement tolerance.
+ static constexpr double kTightTolerance = 0.03;
+
+ static constexpr double kIntakeUpAngle = M_PI / 2;
+
+ static constexpr double kIntakeDownAngle = 0.0;
+
+ static constexpr double kIntakeMiddleAngle =
+ (kIntakeUpAngle + kIntakeDownAngle) / 2;
+
+ enum State {
+ // Wait for all the filters to be ready before starting the initialization
+ // process.
+ UNINITIALIZED = 0,
+
+ // We now are ready to decide how to zero. Decide what to do once we are
+ // enabled.
+ DISABLED_INITIALIZED = 1,
+
+ ZERO_LOWER_INTAKE = 2,
+
+ ZERO_LIFT_INTAKE = 3,
+ // Run, but limit power to zeroing voltages.
+ SLOW_RUNNING = 12,
+ // Run with full power.
+ RUNNING = 13,
+ // Internal error caused the intake to abort.
+ ESTOP = 16,
+ };
+
+ bool IsRunning() const {
+ return (state_ == SLOW_RUNNING || state_ == RUNNING);
+ }
+
+ State state() const { return state_; }
+
+ // Returns the value to move the joint to such that it will stay below
+ // reference_angle starting at current_angle, but move at least move_distance
+ static double MoveButKeepBelow(double reference_angle, double current_angle,
+ double move_distance);
+ // Returns the value to move the joint to such that it will stay above
+ // reference_angle starting at current_angle, but move at least move_distance
+ static double MoveButKeepAbove(double reference_angle, double current_angle,
+ double move_distance);
+
+ protected:
+ void RunIteration(const control_loops::IntakeQueue::Goal *unsafe_goal,
+ const control_loops::IntakeQueue::Position *position,
+ control_loops::IntakeQueue::Output *output,
+ control_loops::IntakeQueue::Status *status) override;
+
+ private:
+ friend class testing::IntakeTest_DisabledGoalTest_Test;
+ friend class testing::IntakeTest_IntakeZeroingErrorTest_Test;
+ friend class testing::IntakeTest_RespectsRange_Test;
+ friend class testing::IntakeTest_UpperHardstopStartup_Test;
+ friend class testing::IntakeTest_DisabledWhileZeroingHigh_Test;
+ friend class testing::IntakeTest_DisabledWhileZeroingLow_Test;
+ IntakeArm intake_;
+
+ State state_ = UNINITIALIZED;
+ State last_state_ = UNINITIALIZED;
+
+ float last_intake_angle_ = 0.0;
+ LimitChecker limit_checker_;
+ // Returns true if the profile has finished, and the joint is within the
+ // specified tolerance.
+ bool IsIntakeNear(double tolerance);
+
+ DISALLOW_COPY_AND_ASSIGN(Intake);
+};
+
+
+} // namespace intake
+} // namespace control_loops
+} // namespace y2016_bot3
+
+#endif // Y2016_BOT3_CONTROL_LOOPS_SUPERSTRUCTURE_SUPERSTRUCTURE_H_
diff --git a/y2016_bot3/control_loops/intake/intake.q b/y2016_bot3/control_loops/intake/intake.q
new file mode 100644
index 0000000..da3edbb
--- /dev/null
+++ b/y2016_bot3/control_loops/intake/intake.q
@@ -0,0 +1,112 @@
+package y2016_bot3.control_loops;
+
+import "aos/common/controls/control_loops.q";
+import "frc971/control_loops/control_loops.q";
+
+struct JointState {
+ // Angle of the joint in radians.
+ float angle;
+ // Angular velocity of the joint in radians/second.
+ float angular_velocity;
+ // Profiled goal angle of the joint in radians.
+ float goal_angle;
+ // Profiled goal angular velocity of the joint in radians/second.
+ float goal_angular_velocity;
+ // Unprofiled goal angle of the joint in radians.
+ float unprofiled_goal_angle;
+ // Unprofiled goal angular velocity of the joint in radians/second.
+ float unprofiled_goal_angular_velocity;
+
+ // The estimated voltage error.
+ float voltage_error;
+
+ // The calculated velocity with delta x/delta t
+ float calculated_velocity;
+
+ // Components of the control loop output
+ float position_power;
+ float velocity_power;
+ float feedforwards_power;
+
+ // State of the estimator.
+ .frc971.EstimatorState estimator_state;
+};
+
+queue_group IntakeQueue {
+ implements aos.control_loops.ControlLoop;
+
+ message Goal {
+ // Zero on the intake is when the horizontal tube stock members are level
+ // with the ground. This will be essentially when we are in the intaking
+ // position. Positive is up. The angle is measured relative to the top
+ // of the robot frame.
+ // Zero on the shoulder is horizontal. Positive is up. The angle is
+ // measured relative to the top of the robot frame.
+ // Zero on the wrist is horizontal and landed in the bellypan. Positive is
+ // the same direction as the shoulder. The angle is measured relative to
+ // the top of the robot frame.
+
+ // Goal angles and angular velocities of the intake.
+ double angle_intake;
+
+ // Caps on velocity/acceleration for profiling. 0 for the default.
+ float max_angular_velocity_intake;
+
+ float max_angular_acceleration_intake;
+
+ // Voltage to send to the rollers. Positive is sucking in.
+ float voltage_top_rollers;
+ float voltage_bottom_rollers;
+
+ bool force_intake;
+
+ // If true, release the latch which holds the traverse mechanism in the
+ // middle.
+ bool traverse_unlatched;
+ // If true, fire the traverse mechanism down.
+ bool traverse_down;
+ };
+
+ message Status {
+ // Is the intake zeroed?
+ bool zeroed;
+
+ // If true, we have aborted.
+ bool estopped;
+
+ // The internal state of the state machine.
+ int32_t state;
+
+
+ // Estimated angle and angular velocitie of the intake.
+ JointState intake;
+
+ // Is the intake collided?
+ bool is_collided;
+ };
+
+ message Position {
+ // Zero for the intake potentiometer value is horizontal, and positive is
+ // up.
+ .frc971.PotAndIndexPosition intake;
+ };
+
+ message Output {
+ float voltage_intake;
+
+ float voltage_top_rollers;
+ float voltage_bottom_rollers;
+
+ // If true, release the latch to hold the traverse mechanism in the middle.
+ bool traverse_unlatched;
+ // If true, fire the traverse mechanism down.
+ bool traverse_down;
+ };
+
+ queue Goal goal;
+ queue Position position;
+ queue Output output;
+ queue Status status;
+};
+
+queue_group IntakeQueue intake_queue;
diff --git a/y2016_bot3/control_loops/intake/intake_controls.cc b/y2016_bot3/control_loops/intake/intake_controls.cc
new file mode 100644
index 0000000..f5ada8c
--- /dev/null
+++ b/y2016_bot3/control_loops/intake/intake_controls.cc
@@ -0,0 +1,168 @@
+#include "y2016_bot3/control_loops/intake/intake_controls.h"
+
+#include "aos/common/controls/control_loops.q.h"
+#include "aos/common/logging/logging.h"
+
+#include "y2016_bot3/control_loops/intake/integral_intake_plant.h"
+
+#include "y2016_bot3/control_loops/intake/intake.h"
+
+namespace y2016_bot3 {
+namespace constants {
+IntakeZero intake_zero;
+}
+namespace control_loops {
+namespace intake {
+
+using ::frc971::PotAndIndexPosition;
+using ::frc971::EstimatorState;
+
+namespace {
+double UseUnlessZero(double target_value, double default_value) {
+ if (target_value != 0.0) {
+ return target_value;
+ } else {
+ return default_value;
+ }
+}
+} // namespace
+
+// Intake
+IntakeArm::IntakeArm()
+ : loop_(new ::frc971::control_loops::SimpleCappedStateFeedbackLoop<3, 1, 1>(
+ ::y2016_bot3::control_loops::intake::MakeIntegralIntakeLoop())),
+ estimator_(y2016_bot3::constants::intake_zero.zeroing),
+ profile_(::aos::controls::kLoopFrequency) {
+ Y_.setZero();
+ unprofiled_goal_.setZero();
+ offset_.setZero();
+ AdjustProfile(0.0, 0.0);
+}
+
+void IntakeArm::UpdateIntakeOffset(double offset) {
+ const double doffset = offset - offset_(0, 0);
+ LOG(INFO, "Adjusting Intake offset from %f to %f\n", offset_(0, 0), offset);
+
+ loop_->mutable_X_hat()(0, 0) += doffset;
+ Y_(0, 0) += doffset;
+ loop_->mutable_R(0, 0) += doffset;
+
+ profile_.MoveGoal(doffset);
+ offset_(0, 0) = offset;
+
+ CapGoal("R", &loop_->mutable_R());
+}
+
+void IntakeArm::Correct(PotAndIndexPosition position) {
+ estimator_.UpdateEstimate(position);
+
+ if (estimator_.error()) {
+ LOG(ERROR, "zeroing error with intake_estimator\n");
+ return;
+ }
+
+ if (!initialized_) {
+ if (estimator_.offset_ready()) {
+ UpdateIntakeOffset(estimator_.offset());
+ initialized_ = true;
+ }
+ }
+
+ if (!zeroed_ && estimator_.zeroed()) {
+ UpdateIntakeOffset(estimator_.offset());
+ zeroed_ = true;
+ }
+
+ Y_ << position.encoder;
+ Y_ += offset_;
+ loop_->Correct(Y_);
+}
+
+void IntakeArm::CapGoal(const char *name, Eigen::Matrix<double, 3, 1> *goal) {
+ // Limit the goal to min/max allowable angles.
+ if ((*goal)(0, 0) > y2016_bot3::constants::kIntakeRange.upper) {
+ LOG(WARNING, "Intake goal %s above limit, %f > %f\n", name, (*goal)(0, 0),
+ y2016_bot3::constants::kIntakeRange.upper);
+ (*goal)(0, 0) = y2016_bot3::constants::kIntakeRange.upper;
+ }
+ if ((*goal)(0, 0) < y2016_bot3::constants::kIntakeRange.lower) {
+ LOG(WARNING, "Intake goal %s below limit, %f < %f\n", name, (*goal)(0, 0),
+ y2016_bot3::constants::kIntakeRange.lower);
+ (*goal)(0, 0) = y2016_bot3::constants::kIntakeRange.lower;
+ }
+}
+
+void IntakeArm::ForceGoal(double goal) {
+ set_unprofiled_goal(goal);
+ loop_->mutable_R() = unprofiled_goal_;
+ loop_->mutable_next_R() = loop_->R();
+
+ profile_.MoveCurrentState(loop_->R().block<2, 1>(0, 0));
+}
+
+void IntakeArm::set_unprofiled_goal(double unprofiled_goal) {
+ unprofiled_goal_(0, 0) = unprofiled_goal;
+ unprofiled_goal_(1, 0) = 0.0;
+ unprofiled_goal_(2, 0) = 0.0;
+ CapGoal("unprofiled R", &unprofiled_goal_);
+}
+
+void IntakeArm::Update(bool disable) {
+ if (!disable) {
+ ::Eigen::Matrix<double, 2, 1> goal_state =
+ profile_.Update(unprofiled_goal_(0, 0), unprofiled_goal_(1, 0));
+
+ loop_->mutable_next_R(0, 0) = goal_state(0, 0);
+ loop_->mutable_next_R(1, 0) = goal_state(1, 0);
+ loop_->mutable_next_R(2, 0) = 0.0;
+ CapGoal("next R", &loop_->mutable_next_R());
+ }
+
+ loop_->Update(disable);
+
+ if (!disable && loop_->U(0, 0) != loop_->U_uncapped(0, 0)) {
+ profile_.MoveCurrentState(loop_->R().block<2, 1>(0, 0));
+ }
+}
+
+bool IntakeArm::CheckHardLimits() {
+ // Returns whether hard limits have been exceeded.
+
+ if (angle() > y2016_bot3::constants::kIntakeRange.upper_hard ||
+ angle() < y2016_bot3::constants::kIntakeRange.lower_hard) {
+ LOG(ERROR, "Intake at %f out of bounds [%f, %f], ESTOPing\n", angle(),
+ y2016_bot3::constants::kIntakeRange.lower_hard,
+ y2016_bot3::constants::kIntakeRange.upper_hard);
+ return true;
+ }
+
+ return false;
+}
+
+void IntakeArm::set_max_voltage(double voltage) {
+ loop_->set_max_voltage(0, voltage);
+}
+
+void IntakeArm::AdjustProfile(double max_angular_velocity,
+ double max_angular_acceleration) {
+ profile_.set_maximum_velocity(UseUnlessZero(max_angular_velocity, 10.0));
+ profile_.set_maximum_acceleration(
+ UseUnlessZero(max_angular_acceleration, 10.0));
+}
+
+void IntakeArm::Reset() {
+ estimator_.Reset();
+ initialized_ = false;
+ zeroed_ = false;
+}
+
+EstimatorState IntakeArm::IntakeEstimatorState() {
+ EstimatorState estimator_state;
+ ::frc971::zeroing::PopulateEstimatorState(estimator_, &estimator_state);
+
+ return estimator_state;
+}
+
+} // namespace intake
+} // namespace control_loops
+} // namespace y2016_bot3
diff --git a/y2016_bot3/control_loops/intake/intake_controls.h b/y2016_bot3/control_loops/intake/intake_controls.h
new file mode 100644
index 0000000..0b2daa0
--- /dev/null
+++ b/y2016_bot3/control_loops/intake/intake_controls.h
@@ -0,0 +1,112 @@
+#ifndef Y2016_BOT3_CONTROL_LOOPS_INTAKE_INTAKE_CONTROLS_H_
+#define Y2016_BOT3_CONTROL_LOOPS_INTAKE_INTAKE_CONTROLS_H_
+
+#include <memory>
+
+#include "aos/common/controls/control_loop.h"
+#include "frc971/control_loops/state_feedback_loop.h"
+#include "frc971/control_loops/simple_capped_state_feedback_loop.h"
+#include "aos/common/util/trapezoid_profile.h"
+
+#include "frc971/zeroing/zeroing.h"
+#include "y2016_bot3/control_loops/intake/intake.q.h"
+
+namespace y2016_bot3 {
+namespace control_loops {
+namespace intake {
+namespace testing {
+class IntakeTest_DisabledGoalTest_Test;
+} // namespace testing
+
+class IntakeArm {
+ public:
+ IntakeArm();
+ // Returns whether the estimators have been initialized and zeroed.
+ bool initialized() const { return initialized_; }
+ bool zeroed() const { return zeroed_; }
+ // Returns whether an error has occured
+ bool error() const { return estimator_.error(); }
+
+ // Updates our estimator with the latest position.
+ void Correct(::frc971::PotAndIndexPosition position);
+ // Runs the controller and profile generator for a cycle.
+ void Update(bool disabled);
+ // Sets the maximum voltage that will be commanded by the loop.
+ void set_max_voltage(double voltage);
+
+ // Forces the current goal to the provided goal, bypassing the profiler.
+ void ForceGoal(double goal);
+ // Sets the unprofiled goal. The profiler will generate a profile to go to
+ // this goal.
+ void set_unprofiled_goal(double unprofiled_goal);
+ // Limits our profiles to a max velocity and acceleration for proper motion.
+ void AdjustProfile(double max_angular_velocity,
+ double max_angular_acceleration);
+
+ // Returns true if we have exceeded any hard limits.
+ bool CheckHardLimits();
+ // Resets the internal state.
+ void Reset();
+
+ // Returns the current internal estimator state for logging.
+ ::frc971::EstimatorState IntakeEstimatorState();
+
+ // Returns the requested intake voltage.
+ double intake_voltage() const { return loop_->U(0, 0); }
+
+ // Returns the current position.
+ double angle() const { return Y_(0, 0); }
+
+ // Returns the controller error.
+ const StateFeedbackLoop<3, 1, 1> &controller() const { return *loop_; }
+
+ // Returns the filtered goal.
+ const Eigen::Matrix<double, 3, 1> &goal() const { return loop_->R(); }
+ double goal(int row, int col) const { return loop_->R(row, col); }
+
+ // Returns the unprofiled goal.
+ const Eigen::Matrix<double, 3, 1> &unprofiled_goal() const {
+ return unprofiled_goal_;
+ }
+ double unprofiled_goal(int row, int col) const {
+ return unprofiled_goal_(row, col);
+ }
+
+ // Returns the current state estimate.
+ const Eigen::Matrix<double, 3, 1> &X_hat() const { return loop_->X_hat(); }
+ double X_hat(int row, int col) const { return loop_->X_hat(row, col); }
+
+ // For testing:
+ // Triggers an estimator error.
+ void TriggerEstimatorError() { estimator_.TriggerError(); }
+
+ private:
+ // Limits the provided goal to the soft limits. Prints "name" when it fails
+ // to aid debugging.
+ void CapGoal(const char *name, Eigen::Matrix<double, 3, 1> *goal);
+
+ void UpdateIntakeOffset(double offset);
+
+ ::std::unique_ptr<
+ ::frc971::control_loops::SimpleCappedStateFeedbackLoop<3, 1, 1>> loop_;
+
+ ::frc971::zeroing::ZeroingEstimator estimator_;
+ aos::util::TrapezoidProfile profile_;
+
+ // Current measurement.
+ Eigen::Matrix<double, 1, 1> Y_;
+ // Current offset. Y_ = offset_ + raw_sensor;
+ Eigen::Matrix<double, 1, 1> offset_;
+
+ // The goal that the profile tries to reach.
+ Eigen::Matrix<double, 3, 1> unprofiled_goal_;
+
+ bool initialized_ = false;
+ bool zeroed_ = false;
+};
+
+} // namespace intake
+} // namespace control_loops
+} // namespace y2016_bot3
+
+#endif // Y2016_CONTROL_LOOPS_SUPERSTRUCTURE_SUPERSTRUCTURE_CONTROLS_H_
diff --git a/y2016_bot3/control_loops/intake/intake_lib_test.cc b/y2016_bot3/control_loops/intake/intake_lib_test.cc
new file mode 100644
index 0000000..43232aa
--- /dev/null
+++ b/y2016_bot3/control_loops/intake/intake_lib_test.cc
@@ -0,0 +1,552 @@
+#include "y2016_bot3/control_loops/intake/intake.h"
+
+#include <unistd.h>
+
+#include <memory>
+
+#include "gtest/gtest.h"
+#include "aos/common/queue.h"
+#include "aos/common/controls/control_loop_test.h"
+#include "aos/common/commonmath.h"
+#include "aos/common/time.h"
+#include "frc971/control_loops/position_sensor_sim.h"
+#include "y2016_bot3/control_loops/intake/intake.q.h"
+#include "y2016_bot3/control_loops/intake/intake_plant.h"
+
+using ::aos::time::Time;
+using ::frc971::control_loops::PositionSensorSimulator;
+
+namespace y2016_bot3 {
+namespace control_loops {
+namespace intake {
+namespace testing {
+
+class IntakePlant : public StateFeedbackPlant<2, 1, 1> {
+ public:
+ explicit IntakePlant(StateFeedbackPlant<2, 1, 1> &&other)
+ : StateFeedbackPlant<2, 1, 1>(::std::move(other)) {}
+
+ void CheckU() override {
+ for (int i = 0; i < kNumInputs; ++i) {
+ assert(U(i, 0) <= U_max(i, 0) + 0.00001 + voltage_offset_);
+ assert(U(i, 0) >= U_min(i, 0) - 0.00001 + voltage_offset_);
+ }
+ }
+
+ double voltage_offset() const { return voltage_offset_; }
+ void set_voltage_offset(double voltage_offset) {
+ voltage_offset_ = voltage_offset;
+ }
+
+ private:
+ double voltage_offset_ = 0.0;
+};
+
+// Class which simulates the intake and sends out queue messages with
+// the position.
+class IntakeSimulation {
+ public:
+ static constexpr double kNoiseScalar = 0.1;
+ IntakeSimulation()
+ : intake_plant_(new IntakePlant(MakeIntakePlant())),
+ pot_encoder_intake_(
+ y2016_bot3::constants::kIntakeEncoderIndexDifference),
+ intake_queue_(".y2016_bot3.control_loops.intake", 0x0,
+ ".y2016_bot3.control_loops.intake.goal",
+ ".y2016_bot3.control_loops.intake.status",
+ ".y2016_bot3.control_loops.intake.output",
+ ".y2016_bot3.control_loops.intake.status") {
+ InitializeIntakePosition(0.0);
+ }
+
+ void InitializeIntakePosition(double start_pos) {
+ intake_plant_->mutable_X(0, 0) = start_pos;
+ intake_plant_->mutable_X(1, 0) = 0.0;
+
+ pot_encoder_intake_.Initialize(start_pos, kNoiseScalar);
+ }
+
+ // Sends a queue message with the position.
+ void SendPositionMessage() {
+ ::aos::ScopedMessagePtr<control_loops::IntakeQueue::Position> position =
+ intake_queue_.position.MakeMessage();
+
+ pot_encoder_intake_.GetSensorValues(&position->intake);
+
+ position.Send();
+ }
+
+ double intake_angle() const { return intake_plant_->X(0, 0); }
+ double intake_angular_velocity() const { return intake_plant_->X(1, 0); }
+
+ // Sets the difference between the commanded and applied powers.
+ // This lets us test that the integrators work.
+ void set_power_error(double power_error_intake) {
+ intake_plant_->set_voltage_offset(power_error_intake);
+ }
+
+ // Simulates for a single timestep.
+ void Simulate() {
+ EXPECT_TRUE(intake_queue_.output.FetchLatest());
+
+ // Feed voltages into physics simulation.
+ intake_plant_->mutable_U() << intake_queue_.output->voltage_intake +
+ intake_plant_->voltage_offset();
+
+ // Verify that the correct power limits are being respected depending on
+ // which mode we are in.
+ EXPECT_TRUE(intake_queue_.status.FetchLatest());
+ if (intake_queue_.status->state == Intake::RUNNING) {
+ CHECK_LE(::std::abs(intake_queue_.output->voltage_intake),
+ Intake::kOperatingVoltage);
+ } else {
+ CHECK_LE(::std::abs(intake_queue_.output->voltage_intake),
+ Intake::kZeroingVoltage);
+ }
+
+ // Use the plant to generate the next physical state given the voltages to
+ // the motors.
+ intake_plant_->Update();
+
+ const double angle_intake = intake_plant_->Y(0, 0);
+
+ // Use the physical state to simulate sensor readings.
+ pot_encoder_intake_.MoveTo(angle_intake);
+
+ // Validate that everything is within range.
+ EXPECT_GE(angle_intake, y2016_bot3::constants::kIntakeRange.lower_hard);
+ EXPECT_LE(angle_intake, y2016_bot3::constants::kIntakeRange.upper_hard);
+ }
+
+ private:
+ ::std::unique_ptr<IntakePlant> intake_plant_;
+
+ PositionSensorSimulator pot_encoder_intake_;
+
+ IntakeQueue intake_queue_;
+};
+
+class IntakeTest : public ::aos::testing::ControlLoopTest {
+ protected:
+ IntakeTest()
+ : intake_queue_(".y2016_bot3.control_loops.intake", 0x0,
+ ".y2016_bot3.control_loops.intake.goal",
+ ".y2016_bot3.control_loops.intake.status",
+ ".y2016_bot3.control_loops.intake.output",
+ ".y2016_bot3.control_loops.intake.status"),
+ intake_(&intake_queue_),
+ intake_plant_() {}
+
+ void VerifyNearGoal() {
+ intake_queue_.goal.FetchLatest();
+ intake_queue_.status.FetchLatest();
+
+ EXPECT_TRUE(intake_queue_.goal.get() != nullptr);
+ EXPECT_TRUE(intake_queue_.status.get() != nullptr);
+
+ EXPECT_NEAR(intake_queue_.goal->angle_intake,
+ intake_queue_.status->intake.angle, 0.001);
+ EXPECT_NEAR(intake_queue_.goal->angle_intake, intake_plant_.intake_angle(),
+ 0.001);
+ }
+
+ // Runs one iteration of the whole simulation
+ void RunIteration(bool enabled = true) {
+ SendMessages(enabled);
+
+ intake_plant_.SendPositionMessage();
+ intake_.Iterate();
+ intake_plant_.Simulate();
+
+ TickTime();
+ }
+
+ // Runs iterations until the specified amount of simulated time has elapsed.
+ void RunForTime(const Time &run_for, bool enabled = true) {
+ const auto start_time = Time::Now();
+ while (Time::Now() < start_time + run_for) {
+ const auto loop_start_time = Time::Now();
+ double begin_intake_velocity = intake_plant_.intake_angular_velocity();
+ RunIteration(enabled);
+ const double loop_time = (Time::Now() - loop_start_time).ToSeconds();
+ const double intake_acceleration =
+ (intake_plant_.intake_angular_velocity() - begin_intake_velocity) /
+ loop_time;
+ EXPECT_GE(peak_intake_acceleration_, intake_acceleration);
+ EXPECT_LE(-peak_intake_acceleration_, intake_acceleration);
+
+ EXPECT_GE(peak_intake_velocity_, intake_plant_.intake_angular_velocity());
+ EXPECT_LE(-peak_intake_velocity_,
+ intake_plant_.intake_angular_velocity());
+ }
+ }
+
+ // Runs iterations while watching the average acceleration per cycle and
+ // making sure it doesn't exceed the provided bounds.
+ void set_peak_intake_acceleration(double value) {
+ peak_intake_acceleration_ = value;
+ }
+ void set_peak_intake_velocity(double value) { peak_intake_velocity_ = value; }
+
+
+
+ // Create a new instance of the test queue so that it invalidates the queue
+ // that it points to. Otherwise, we will have a pointed to
+ // shared memory that is no longer valid.
+ IntakeQueue intake_queue_;
+
+ // Create a control loop and simulation.
+ Intake intake_;
+ IntakeSimulation intake_plant_;
+
+ private:
+ // The acceleration limits to check for while moving for the 3 axes.
+ double peak_intake_acceleration_ = 1e10;
+ // The velocity limits to check for while moving for the 3 axes.
+ double peak_intake_velocity_ = 1e10;
+};
+
+// Tests that the intake does nothing when the goal is zero.
+TEST_F(IntakeTest, DoesNothing) {
+ ASSERT_TRUE(intake_queue_.goal.MakeWithBuilder()
+ .angle_intake(0)
+ .max_angular_velocity_intake(20)
+ .max_angular_acceleration_intake(20)
+ .Send());
+
+ // TODO(phil): Send a goal of some sort.
+ RunForTime(Time::InSeconds(5));
+ VerifyNearGoal();
+}
+
+// Tests that the loop can reach a goal.
+TEST_F(IntakeTest, ReachesGoal) {
+ // Set a reasonable goal.
+ ASSERT_TRUE(intake_queue_.goal.MakeWithBuilder()
+ .angle_intake(M_PI / 4.0)
+ .max_angular_velocity_intake(20)
+ .max_angular_acceleration_intake(20)
+ .Send());
+
+ // Give it a lot of time to get there.
+ RunForTime(Time::InSeconds(8));
+
+ VerifyNearGoal();
+}
+
+// Tests that the loop doesn't try and go beyond the physical range of the
+// mechanisms.
+TEST_F(IntakeTest, RespectsRange) {
+ // Set some ridiculous goals to test upper limits.
+ ASSERT_TRUE(intake_queue_.goal.MakeWithBuilder()
+ .angle_intake(M_PI * 10)
+ .max_angular_velocity_intake(20)
+ .max_angular_acceleration_intake(20)
+ .Send());
+ RunForTime(Time::InSeconds(10));
+
+ // Check that we are near our soft limit.
+ intake_queue_.status.FetchLatest();
+ EXPECT_NEAR(y2016_bot3::constants::kIntakeRange.upper,
+ intake_queue_.status->intake.angle, 0.001);
+
+
+ // Set some ridiculous goals to test lower limits.
+ ASSERT_TRUE(intake_queue_.goal.MakeWithBuilder()
+ .angle_intake(-M_PI * 10)
+ .max_angular_velocity_intake(20)
+ .max_angular_acceleration_intake(20)
+ .Send());
+
+ RunForTime(Time::InSeconds(10));
+
+ // Check that we are near our soft limit.
+ intake_queue_.status.FetchLatest();
+ EXPECT_NEAR(y2016_bot3::constants::kIntakeRange.lower,
+ intake_queue_.status->intake.angle, 0.001);
+}
+
+// Tests that the loop zeroes when run for a while.
+TEST_F(IntakeTest, ZeroTest) {
+ ASSERT_TRUE(intake_queue_.goal.MakeWithBuilder()
+ .angle_intake(y2016_bot3::constants::kIntakeRange.lower)
+ .max_angular_velocity_intake(20)
+ .max_angular_acceleration_intake(20)
+ .Send());
+
+ RunForTime(Time::InSeconds(10));
+
+ VerifyNearGoal();
+}
+
+// Tests that the loop zeroes when run for a while without a goal.
+TEST_F(IntakeTest, ZeroNoGoal) {
+ RunForTime(Time::InSeconds(5));
+
+ EXPECT_EQ(Intake::RUNNING, intake_.state());
+}
+
+// Tests that starting at the lower hardstops doesn't cause an abort.
+TEST_F(IntakeTest, LowerHardstopStartup) {
+ intake_plant_.InitializeIntakePosition(
+ y2016_bot3::constants::kIntakeRange.lower);
+ ASSERT_TRUE(intake_queue_.goal.MakeWithBuilder()
+ .angle_intake(y2016_bot3::constants::kIntakeRange.upper)
+ .Send());
+
+ RunForTime(Time::InSeconds(15));
+ VerifyNearGoal();
+}
+
+// Tests that starting at the upper hardstops doesn't cause an abort.
+TEST_F(IntakeTest, UpperHardstopStartup) {
+ intake_plant_.InitializeIntakePosition(
+ y2016_bot3::constants::kIntakeRange.upper);
+ ASSERT_TRUE(intake_queue_.goal.MakeWithBuilder()
+ .angle_intake(y2016_bot3::constants::kIntakeRange.lower)
+ .Send());
+
+ RunForTime(Time::InSeconds(15));
+ VerifyNearGoal();
+}
+
+// Tests that resetting WPILib results in a rezero.
+TEST_F(IntakeTest, ResetTest) {
+ intake_plant_.InitializeIntakePosition(
+ y2016_bot3::constants::kIntakeRange.upper);
+
+ ASSERT_TRUE(intake_queue_.goal.MakeWithBuilder()
+ .angle_intake(y2016_bot3::constants::kIntakeRange.lower + 0.3)
+ .Send());
+ RunForTime(Time::InSeconds(15));
+
+ EXPECT_EQ(Intake::RUNNING, intake_.state());
+ VerifyNearGoal();
+ SimulateSensorReset();
+ RunForTime(Time::InMS(100));
+ EXPECT_NE(Intake::RUNNING, intake_.state());
+ RunForTime(Time::InMS(10000));
+ EXPECT_EQ(Intake::RUNNING, intake_.state());
+ VerifyNearGoal();
+}
+
+// Tests that the internal goals don't change while disabled.
+TEST_F(IntakeTest, DisabledGoalTest) {
+ ASSERT_TRUE(
+ intake_queue_.goal.MakeWithBuilder()
+ .angle_intake(y2016_bot3::constants::kIntakeRange.lower + 0.03)
+ .Send());
+
+ RunForTime(Time::InMS(100), false);
+ EXPECT_EQ(0.0, intake_.intake_.goal(0, 0));
+
+ // Now make sure they move correctly
+ RunForTime(Time::InMS(4000), true);
+ EXPECT_NE(0.0, intake_.intake_.goal(0, 0));
+}
+
+// Tests that disabling while zeroing at any state restarts from beginning
+TEST_F(IntakeTest, DisabledWhileZeroingHigh) {
+ intake_plant_.InitializeIntakePosition(
+ y2016_bot3::constants::kIntakeRange.upper);
+
+ ASSERT_TRUE(intake_queue_.goal.MakeWithBuilder()
+ .angle_intake(y2016_bot3::constants::kIntakeRange.upper)
+ .max_angular_velocity_intake(20)
+ .max_angular_acceleration_intake(20)
+ .Send());
+
+ // Expected states to cycle through and check in order.
+ Intake::State ExpectedStateOrder[] = {
+ Intake::DISABLED_INITIALIZED, Intake::ZERO_LOWER_INTAKE};
+
+ // Cycle through until intake_ is initialized in intake.cc
+ while (intake_.state() < Intake::DISABLED_INITIALIZED) {
+ RunIteration(true);
+ }
+
+ static const int kNumberOfStates =
+ sizeof(ExpectedStateOrder) / sizeof(ExpectedStateOrder[0]);
+
+ // Next state when reached to disable
+ for (int i = 0; i < kNumberOfStates; i++) {
+ // Next expected state after being disabled that is expected until next
+ // state to disable at is reached
+ for (int j = 0; intake_.state() != ExpectedStateOrder[i] && j <= i; j++) {
+ // RunIteration until next expected state is reached with a maximum
+ // of 10000 times to ensure a breakout
+ for (int o = 0; intake_.state() < ExpectedStateOrder[j] && o < 10000;
+ o++) {
+ RunIteration(true);
+ }
+ EXPECT_EQ(ExpectedStateOrder[j], intake_.state());
+ }
+
+ EXPECT_EQ(ExpectedStateOrder[i], intake_.state());
+
+ // Disable
+ RunIteration(false);
+
+ EXPECT_EQ(Intake::DISABLED_INITIALIZED, intake_.state());
+ }
+
+ RunForTime(Time::InSeconds(10));
+ EXPECT_EQ(Intake::RUNNING, intake_.state());
+}
+
+// Tests that disabling while zeroing at any state restarts from beginning
+TEST_F(IntakeTest, DisabledWhileZeroingLow) {
+ intake_plant_.InitializeIntakePosition(
+ y2016_bot3::constants::kIntakeRange.lower);
+
+ ASSERT_TRUE(intake_queue_.goal.MakeWithBuilder()
+ .angle_intake(y2016_bot3::constants::kIntakeRange.lower)
+ .max_angular_velocity_intake(20)
+ .max_angular_acceleration_intake(20)
+ .Send());
+
+ // Expected states to cycle through and check in order.
+ Intake::State ExpectedStateOrder[] = {
+ Intake::DISABLED_INITIALIZED, Intake::ZERO_LIFT_INTAKE};
+
+ // Cycle through until intake_ is initialized in intake.cc
+ while (intake_.state() < Intake::DISABLED_INITIALIZED) {
+ RunIteration(true);
+ }
+
+ static const int kNumberOfStates =
+ sizeof(ExpectedStateOrder) / sizeof(ExpectedStateOrder[0]);
+
+ // Next state when reached to disable
+ for (int i = 0; i < kNumberOfStates; i++) {
+ // Next expected state after being disabled that is expected until next
+ // state to disable at is reached
+ for (int j = 0; intake_.state() != ExpectedStateOrder[i] && j <= i; j++) {
+ // RunIteration until next expected state is reached with a maximum
+ // of 10000 times to ensure a breakout
+ for (int o = 0; intake_.state() < ExpectedStateOrder[j] && o < 10000;
+ o++) {
+ RunIteration(true);
+ }
+ EXPECT_EQ(ExpectedStateOrder[j], intake_.state());
+ }
+
+ EXPECT_EQ(ExpectedStateOrder[i], intake_.state());
+
+ // Disable
+ RunIteration(false);
+
+ EXPECT_EQ(Intake::DISABLED_INITIALIZED, intake_.state());
+ }
+
+ RunForTime(Time::InSeconds(10));
+ EXPECT_EQ(Intake::RUNNING, intake_.state());
+}
+
+// Tests that MoveButKeepBelow returns sane values.
+TEST_F(IntakeTest, MoveButKeepBelowTest) {
+ EXPECT_EQ(1.0, Intake::MoveButKeepBelow(1.0, 10.0, 1.0));
+ EXPECT_EQ(1.0, Intake::MoveButKeepBelow(1.0, 2.0, 1.0));
+ EXPECT_EQ(0.0, Intake::MoveButKeepBelow(1.0, 1.0, 1.0));
+ EXPECT_EQ(1.0, Intake::MoveButKeepBelow(1.0, 0.0, 1.0));
+}
+
+// Tests that the integrators works.
+TEST_F(IntakeTest, IntegratorTest) {
+ intake_plant_.InitializeIntakePosition(
+ y2016_bot3::constants::kIntakeRange.lower);
+ intake_plant_.set_power_error(1.0);
+ intake_queue_.goal.MakeWithBuilder().angle_intake(0.0).Send();
+
+ RunForTime(Time::InSeconds(8));
+
+ VerifyNearGoal();
+}
+
+// Tests that zeroing while disabled works. Starts the superstructure near a
+// pulse, lets it initialize, moves it past the pulse, enables, and then make
+// sure it goes to the right spot.
+TEST_F(IntakeTest, DisabledZeroTest) {
+ intake_plant_.InitializeIntakePosition(-0.001);
+
+ intake_queue_.goal.MakeWithBuilder().angle_intake(0.0).Send();
+
+ // Run disabled for 2 seconds
+ RunForTime(Time::InSeconds(2), false);
+ EXPECT_EQ(Intake::DISABLED_INITIALIZED, intake_.state());
+
+ intake_plant_.set_power_error(1.0);
+
+ RunForTime(Time::InSeconds(1), false);
+
+ EXPECT_EQ(Intake::SLOW_RUNNING, intake_.state());
+ RunForTime(Time::InSeconds(2), true);
+
+ VerifyNearGoal();
+}
+
+// Tests that the zeroing errors in the intake are caught
+TEST_F(IntakeTest, IntakeZeroingErrorTest) {
+ RunIteration();
+ EXPECT_NE(Intake::ESTOP, intake_.state());
+ intake_.intake_.TriggerEstimatorError();
+ RunIteration();
+
+ EXPECT_EQ(Intake::ESTOP, intake_.state());
+}
+
+// Tests that the loop respects intake acceleration limits while moving.
+TEST_F(IntakeTest, IntakeAccelerationLimitTest) {
+ ASSERT_TRUE(intake_queue_.goal.MakeWithBuilder()
+ .angle_intake(0.0)
+ .max_angular_velocity_intake(20)
+ .max_angular_acceleration_intake(20)
+ .Send());
+
+ RunForTime(Time::InSeconds(6));
+ EXPECT_EQ(Intake::RUNNING, intake_.state());
+
+ VerifyNearGoal();
+
+ ASSERT_TRUE(intake_queue_.goal.MakeWithBuilder()
+ .angle_intake(0.5)
+ .max_angular_velocity_intake(1)
+ .max_angular_acceleration_intake(1)
+ .Send());
+
+ set_peak_intake_acceleration(1.20);
+ RunForTime(Time::InSeconds(4));
+
+ VerifyNearGoal();
+}
+
+// Tests that the loop respects intake handles saturation while accelerating
+// correctly.
+TEST_F(IntakeTest, SaturatedIntakeProfileTest) {
+ ASSERT_TRUE(intake_queue_.goal.MakeWithBuilder()
+ .angle_intake(0.0)
+ .max_angular_velocity_intake(20)
+ .max_angular_acceleration_intake(20)
+ .Send());
+
+ RunForTime(Time::InSeconds(6));
+ EXPECT_EQ(Intake::RUNNING, intake_.state());
+
+ VerifyNearGoal();
+
+ ASSERT_TRUE(intake_queue_.goal.MakeWithBuilder()
+ .angle_intake(0.5)
+ .max_angular_velocity_intake(4.5)
+ .max_angular_acceleration_intake(800)
+ .Send());
+
+ set_peak_intake_velocity(4.65);
+ RunForTime(Time::InSeconds(4));
+
+ VerifyNearGoal();
+}
+
+} // namespace testing
+} // namespace intake
+} // namespace control_loops
+} // namespace frc971
diff --git a/y2016_bot3/control_loops/intake/intake_main.cc b/y2016_bot3/control_loops/intake/intake_main.cc
new file mode 100644
index 0000000..a60f914
--- /dev/null
+++ b/y2016_bot3/control_loops/intake/intake_main.cc
@@ -0,0 +1,11 @@
+#include "y2016_bot3/control_loops/intake/intake.h"
+
+#include "aos/linux_code/init.h"
+
+int main() {
+ ::aos::Init();
+ ::y2016_bot3::control_loops::intake::Intake intake;
+ intake.Run();
+ ::aos::Cleanup();
+ return 0;
+}