Update wpilib_interface.
Change-Id: If0e00a97faf0653a43e9acff9a8cff6ce3d3e6cb
diff --git a/y2014/wpilib/wpilib_interface.cc b/y2014/wpilib/wpilib_interface.cc
index 1c141a8..f47bad3 100644
--- a/y2014/wpilib/wpilib_interface.cc
+++ b/y2014/wpilib/wpilib_interface.cc
@@ -17,11 +17,12 @@
#include "aos/linux_code/init.h"
#include "aos/common/messages/robot_state.q.h"
-#include "y2014/constants.h"
-#include "frc971/control_loops/control_loops.q.h"
+#include "frc971/shifter_hall_effect.h"
#include "y2014/control_loops/drivetrain/drivetrain.q.h"
-#include "frc971/control_loops/fridge/fridge.q.h"
#include "y2014/control_loops/claw/claw.q.h"
+#include "y2014/control_loops/shooter/shooter.q.h"
+#include "y2014/constants.h"
+#include "y2014/queues/auto_mode.q.h"
#include "frc971/wpilib/hall_effect.h"
#include "frc971/wpilib/joystick_sender.h"
@@ -48,189 +49,203 @@
#define M_PI 3.14159265358979323846
#endif
-using ::aos::util::SimpleLogInterval;
using ::frc971::control_loops::drivetrain_queue;
-using ::frc971::control_loops::fridge_queue;
using ::frc971::control_loops::claw_queue;
+using ::frc971::control_loops::shooter_queue;
namespace frc971 {
namespace wpilib {
+// TODO(brian): Replace this with ::std::make_unique once all our toolchains
+// have support.
+template <class T, class... U>
+std::unique_ptr<T> make_unique(U &&... u) {
+ return std::unique_ptr<T>(new T(std::forward<U>(u)...));
+}
+
double drivetrain_translate(int32_t in) {
return static_cast<double>(in) /
(256.0 /*cpr*/ * 4.0 /*4x*/) *
constants::GetValues().drivetrain_encoder_ratio *
- (4 /*wheel diameter*/ * 2.54 / 100.0 * M_PI);
+ (3.5 /*wheel diameter*/ * 2.54 / 100.0 * M_PI);
}
-double arm_translate(int32_t in) {
- return -static_cast<double>(in) /
- (512.0 /*cpr*/ * 4.0 /*4x*/) *
- constants::GetValues().arm_encoder_ratio *
- (2 * M_PI /*radians*/);
-}
+float hall_translate(const constants::ShifterHallEffect &k, float in_low,
+ float in_high) {
+ const float low_ratio =
+ 0.5 * (in_low - static_cast<float>(k.low_gear_low)) /
+ static_cast<float>(k.low_gear_middle - k.low_gear_low);
+ const float high_ratio =
+ 0.5 + 0.5 * (in_high - static_cast<float>(k.high_gear_middle)) /
+ static_cast<float>(k.high_gear_high - k.high_gear_middle);
-double arm_potentiometer_translate(double voltage) {
- return voltage *
- constants::GetValues().arm_pot_ratio *
- (5.0 /*turns*/ / 5.0 /*volts*/) *
- (2 * M_PI /*radians*/);
-}
-
-double elevator_translate(int32_t in) {
- return static_cast<double>(in) /
- (512.0 /*cpr*/ * 4.0 /*4x*/) *
- constants::GetValues().elev_encoder_ratio *
- (2 * M_PI /*radians*/) *
- constants::GetValues().elev_distance_per_radian;
-}
-
-double elevator_potentiometer_translate(double voltage) {
- return -voltage *
- constants::GetValues().elev_pot_ratio *
- (2 * M_PI /*radians*/) *
- constants::GetValues().elev_distance_per_radian *
- (5.0 /*turns*/ / 5.0 /*volts*/);
+ // Return low when we are below 1/2, and high when we are above 1/2.
+ if (low_ratio + high_ratio < 1.0) {
+ return low_ratio;
+ } else {
+ return high_ratio;
+ }
}
double claw_translate(int32_t in) {
- return static_cast<double>(in) /
- (512.0 /*cpr*/ * 4.0 /*4x*/) *
- constants::GetValues().claw_encoder_ratio *
- (2 * M_PI /*radians*/);
+ return static_cast<double>(in) / (256.0 /*cpr*/ * 4.0 /*quad*/) /
+ (18.0 / 48.0 /*encoder gears*/) / (12.0 / 60.0 /*chain reduction*/) *
+ (M_PI / 180.0);
}
-double claw_potentiometer_translate(double voltage) {
- return -voltage *
- constants::GetValues().claw_pot_ratio *
- (5.0 /*turns*/ / 5.0 /*volts*/) *
- (2 * M_PI /*radians*/);
+double shooter_translate(int32_t in) {
+ return static_cast<double>(in) / (256.0 /*cpr*/ * 4.0 /*quad*/) *
+ 16 /*sprocket teeth*/ * 0.375 /*chain pitch*/
+ * (2.54 / 100.0 /*in to m*/);
}
static const double kMaximumEncoderPulsesPerSecond =
- 19500.0 /* free speed RPM */ * 12.0 / 56.0 /* belt reduction */ /
- 60.0 /* seconds / minute */ * 256.0 /* CPR */ *
- 4.0 /* index pulse = 1/4 cycle */;
+ 5600.0 /* free speed RPM */ * 14.0 / 48.0 /* bottom gear reduction */ *
+ 18.0 / 32.0 /* big belt reduction */ *
+ 18.0 / 66.0 /* top gear reduction */ * 48.0 / 18.0 /* encoder gears */ /
+ 60.0 /* seconds / minute */ * 256.0 /* CPR */;
class SensorReader {
public:
SensorReader() {
// Set it to filter out anything shorter than 1/4 of the minimum pulse width
// we should ever see.
- filter_.SetPeriodNanoSeconds(
+ encoder_filter_.SetPeriodNanoSeconds(
static_cast<int>(1 / 4.0 / kMaximumEncoderPulsesPerSecond * 1e9 + 0.5));
+ hall_filter_.SetPeriodNanoSeconds(100000);
}
- void set_arm_left_encoder(::std::unique_ptr<Encoder> encoder) {
- filter_.Add(encoder.get());
- arm_left_encoder_.set_encoder(::std::move(encoder));
+ void set_auto_selector_analog(::std::unique_ptr<AnalogInput> analog) {
+ auto_selector_analog_ = ::std::move(analog);
}
- void set_arm_left_index(::std::unique_ptr<DigitalSource> index) {
- filter_.Add(index.get());
- arm_left_encoder_.set_index(::std::move(index));
+ void set_drivetrain_left_encoder(::std::unique_ptr<Encoder> encoder) {
+ drivetrain_left_encoder_ = ::std::move(encoder);
}
- void set_arm_left_potentiometer(
- ::std::unique_ptr<AnalogInput> potentiometer) {
- arm_left_encoder_.set_potentiometer(::std::move(potentiometer));
+ void set_drivetrain_right_encoder(::std::unique_ptr<Encoder> encoder) {
+ drivetrain_right_encoder_ = ::std::move(encoder);
}
- void set_arm_right_encoder(::std::unique_ptr<Encoder> encoder) {
- filter_.Add(encoder.get());
- arm_right_encoder_.set_encoder(::std::move(encoder));
+ void set_high_left_drive_hall(::std::unique_ptr<AnalogInput> analog) {
+ high_left_drive_hall_ = ::std::move(analog);
}
- void set_arm_right_index(::std::unique_ptr<DigitalSource> index) {
- filter_.Add(index.get());
- arm_right_encoder_.set_index(::std::move(index));
+ void set_low_right_drive_hall(::std::unique_ptr<AnalogInput> analog) {
+ low_right_drive_hall_ = ::std::move(analog);
}
- void set_arm_right_potentiometer(
- ::std::unique_ptr<AnalogInput> potentiometer) {
- arm_right_encoder_.set_potentiometer(::std::move(potentiometer));
+ void set_high_right_drive_hall(::std::unique_ptr<AnalogInput> analog) {
+ high_right_drive_hall_ = ::std::move(analog);
}
- void set_elevator_left_encoder(::std::unique_ptr<Encoder> encoder) {
- filter_.Add(encoder.get());
- elevator_left_encoder_.set_encoder(::std::move(encoder));
+ void set_low_left_drive_hall(::std::unique_ptr<AnalogInput> analog) {
+ low_left_drive_hall_ = ::std::move(analog);
}
- void set_elevator_left_index(::std::unique_ptr<DigitalSource> index) {
- filter_.Add(index.get());
- elevator_left_encoder_.set_index(::std::move(index));
+ void set_top_claw_encoder(::std::unique_ptr<Encoder> encoder) {
+ encoder_filter_.Add(encoder.get());
+ top_reader_.set_encoder(::std::move(encoder));
}
- void set_elevator_left_potentiometer(
- ::std::unique_ptr<AnalogInput> potentiometer) {
- elevator_left_encoder_.set_potentiometer(::std::move(potentiometer));
+ void set_top_claw_front_hall(::std::unique_ptr<DigitalSource> hall) {
+ hall_filter_.Add(hall.get());
+ top_reader_.set_front_hall(::std::move(hall));
}
- void set_elevator_right_encoder(::std::unique_ptr<Encoder> encoder) {
- filter_.Add(encoder.get());
- elevator_right_encoder_.set_encoder(::std::move(encoder));
+ void set_top_claw_calibration_hall(::std::unique_ptr<DigitalSource> hall) {
+ hall_filter_.Add(hall.get());
+ top_reader_.set_calibration_hall(::std::move(hall));
}
- void set_elevator_right_index(::std::unique_ptr<DigitalSource> index) {
- filter_.Add(index.get());
- elevator_right_encoder_.set_index(::std::move(index));
+ void set_top_claw_back_hall(::std::unique_ptr<DigitalSource> hall) {
+ hall_filter_.Add(hall.get());
+ top_reader_.set_back_hall(::std::move(hall));
}
- void set_elevator_right_potentiometer(
- ::std::unique_ptr<AnalogInput> potentiometer) {
- elevator_right_encoder_.set_potentiometer(::std::move(potentiometer));
+ void set_bottom_claw_encoder(::std::unique_ptr<Encoder> encoder) {
+ encoder_filter_.Add(encoder.get());
+ bottom_reader_.set_encoder(::std::move(encoder));
}
- void set_wrist_encoder(::std::unique_ptr<Encoder> encoder) {
- filter_.Add(encoder.get());
- wrist_encoder_.set_encoder(::std::move(encoder));
+ void set_bottom_claw_front_hall(::std::unique_ptr<DigitalSource> hall) {
+ hall_filter_.Add(hall.get());
+ bottom_reader_.set_front_hall(::std::move(hall));
}
- void set_wrist_index(::std::unique_ptr<DigitalSource> index) {
- filter_.Add(index.get());
- wrist_encoder_.set_index(::std::move(index));
+ void set_bottom_claw_calibration_hall(::std::unique_ptr<DigitalSource> hall) {
+ hall_filter_.Add(hall.get());
+ bottom_reader_.set_calibration_hall(::std::move(hall));
}
- void set_wrist_potentiometer(::std::unique_ptr<AnalogInput> potentiometer) {
- wrist_encoder_.set_potentiometer(::std::move(potentiometer));
+ void set_bottom_claw_back_hall(::std::unique_ptr<DigitalSource> hall) {
+ hall_filter_.Add(hall.get());
+ bottom_reader_.set_back_hall(::std::move(hall));
}
- void set_left_encoder(::std::unique_ptr<Encoder> left_encoder) {
- left_encoder_ = ::std::move(left_encoder);
+ void set_shooter_encoder(::std::unique_ptr<Encoder> encoder) {
+ encoder_filter_.Add(encoder.get());
+ shooter_encoder_ = ::std::move(encoder);
}
- void set_right_encoder(::std::unique_ptr<Encoder> right_encoder) {
- right_encoder_ = ::std::move(right_encoder);
+ void set_shooter_proximal(::std::unique_ptr<DigitalSource> hall) {
+ hall_filter_.Add(hall.get());
+ shooter_proximal_ = ::std::move(hall);
+ }
+
+ void set_shooter_distal(::std::unique_ptr<DigitalSource> hall) {
+ hall_filter_.Add(hall.get());
+ shooter_distal_ = ::std::move(hall);
+ }
+
+ void set_shooter_plunger(::std::unique_ptr<DigitalSource> hall) {
+ hall_filter_.Add(hall.get());
+ shooter_plunger_ = ::std::move(hall);
+ shooter_plunger_reader_ =
+ make_unique<DMADigitalReader>(shooter_plunger_.get());
+ }
+
+ void set_shooter_latch(::std::unique_ptr<DigitalSource> hall) {
+ hall_filter_.Add(hall.get());
+ shooter_latch_ = ::std::move(hall);
+ shooter_latch_reader_ = make_unique<DMADigitalReader>(shooter_latch_.get());
}
// All of the DMA-related set_* calls must be made before this, and it doesn't
// hurt to do all of them.
void set_dma(::std::unique_ptr<DMA> dma) {
+ shooter_proximal_counter_ = make_unique<DMAEdgeCounter>(
+ shooter_encoder_.get(), shooter_proximal_.get());
+ shooter_distal_counter_ = make_unique<DMAEdgeCounter>(
+ shooter_encoder_.get(), shooter_distal_.get());
+
dma_synchronizer_.reset(new DMASynchronizer(::std::move(dma)));
- dma_synchronizer_->Add(&arm_left_encoder_);
- dma_synchronizer_->Add(&elevator_left_encoder_);
- dma_synchronizer_->Add(&arm_right_encoder_);
- dma_synchronizer_->Add(&elevator_right_encoder_);
+ dma_synchronizer_->Add(shooter_proximal_counter_.get());
+ dma_synchronizer_->Add(shooter_distal_counter_.get());
+ dma_synchronizer_->Add(shooter_plunger_reader_.get());
+ dma_synchronizer_->Add(shooter_latch_reader_.get());
}
void operator()() {
- LOG(INFO, "In sensor reader thread\n");
::aos::SetCurrentThreadName("SensorReader");
+ LOG(INFO, "In sensor reader thread\n");
my_pid_ = getpid();
ds_ = DriverStation::GetInstance();
- wrist_encoder_.Start();
+ top_reader_.Start();
+ bottom_reader_.Start();
dma_synchronizer_->Start();
LOG(INFO, "Things are now started\n");
::aos::SetCurrentThreadRealtimePriority(kPriority);
while (run_) {
- ::aos::time::PhasedLoopXMS(5, 4000);
+ ::aos::time::PhasedLoopXMS(10, 9000);
RunIteration();
}
- wrist_encoder_.Stop();
+ top_reader_.Quit();
+ bottom_reader_.Quit();
}
void RunIteration() {
@@ -254,45 +269,48 @@
new_state.Send();
}
+ const auto &values = constants::GetValues();
+
{
auto drivetrain_message = drivetrain_queue.position.MakeMessage();
drivetrain_message->right_encoder =
- -drivetrain_translate(right_encoder_->GetRaw());
+ drivetrain_translate(drivetrain_right_encoder_->GetRaw());
drivetrain_message->left_encoder =
- drivetrain_translate(left_encoder_->GetRaw());
+ -drivetrain_translate(drivetrain_left_encoder_->GetRaw());
+ drivetrain_message->left_shifter_position =
+ hall_translate(values.left_drive, low_left_drive_hall_->GetVoltage(),
+ high_left_drive_hall_->GetVoltage());
+ drivetrain_message->right_shifter_position = hall_translate(
+ values.right_drive, low_right_drive_hall_->GetVoltage(),
+ high_right_drive_hall_->GetVoltage());
drivetrain_message.Send();
}
+ ::frc971::sensors::auto_mode.MakeWithBuilder()
+ .voltage(auto_selector_analog_->GetVoltage())
+ .Send();
+
dma_synchronizer_->RunIteration();
- const auto &values = constants::GetValues();
-
{
- auto fridge_message = fridge_queue.position.MakeMessage();
- CopyPotAndIndexPosition(arm_left_encoder_, &fridge_message->arm.left,
- arm_translate, arm_potentiometer_translate, false,
- values.fridge.left_arm_potentiometer_offset);
- CopyPotAndIndexPosition(
- arm_right_encoder_, &fridge_message->arm.right, arm_translate,
- arm_potentiometer_translate, true,
- values.fridge.right_arm_potentiometer_offset);
- CopyPotAndIndexPosition(
- elevator_left_encoder_, &fridge_message->elevator.left,
- elevator_translate, elevator_potentiometer_translate, false,
- values.fridge.left_elevator_potentiometer_offset);
- CopyPotAndIndexPosition(
- elevator_right_encoder_, &fridge_message->elevator.right,
- elevator_translate, elevator_potentiometer_translate, true,
- values.fridge.right_elevator_potentiometer_offset);
- fridge_message.Send();
+ auto shooter_message = shooter_queue.position.MakeMessage();
+ shooter_message->position = shooter_translate(shooter_encoder_->GetRaw());
+ shooter_message->plunger = shooter_plunger_reader_->value();
+ shooter_message->latch = shooter_latch_reader_->value();
+ CopyShooterPosedgeCounts(shooter_proximal_counter_.get(),
+ &shooter_message->pusher_proximal);
+ CopyShooterPosedgeCounts(shooter_distal_counter_.get(),
+ &shooter_message->pusher_distal);
+
+ shooter_message.Send();
}
{
auto claw_message = claw_queue.position.MakeMessage();
- CopyPotAndIndexPosition(wrist_encoder_, &claw_message->joint,
- claw_translate, claw_potentiometer_translate,
- false, values.claw.potentiometer_offset);
+ top_reader_.RunIteration(&claw_message->top);
+ bottom_reader_.RunIteration(&claw_message->bottom);
+
claw_message.Send();
}
}
@@ -300,73 +318,133 @@
void Quit() { run_ = false; }
private:
+ class HalfClawReader {
+ public:
+ HalfClawReader(bool reversed) : reversed_(reversed) {}
+
+ void set_encoder(::std::unique_ptr<Encoder> encoder) {
+ encoder_ = ::std::move(encoder);
+ }
+
+ void set_front_hall(::std::unique_ptr<DigitalSource> front_hall) {
+ front_hall_ = ::std::move(front_hall);
+ }
+
+ void set_calibration_hall(
+ ::std::unique_ptr<DigitalSource> calibration_hall) {
+ calibration_hall_ = ::std::move(calibration_hall);
+ }
+
+ void set_back_hall(::std::unique_ptr<DigitalSource> back_hall) {
+ back_hall_ = ::std::move(back_hall);
+ }
+
+ void Start() {
+ front_counter_ =
+ make_unique<EdgeCounter>(encoder_.get(), front_hall_.get());
+ synchronizer_.Add(front_counter_.get());
+ calibration_counter_ =
+ make_unique<EdgeCounter>(encoder_.get(), calibration_hall_.get());
+ synchronizer_.Add(calibration_counter_.get());
+ back_counter_ =
+ make_unique<EdgeCounter>(encoder_.get(), back_hall_.get());
+ synchronizer_.Add(back_counter_.get());
+ synchronized_encoder_ =
+ make_unique<InterruptSynchronizedEncoder>(encoder_.get());
+ synchronizer_.Add(synchronized_encoder_.get());
+
+ synchronizer_.Start();
+ }
+
+ void Quit() { synchronizer_.Quit(); }
+
+ void RunIteration(control_loops::HalfClawPosition *half_claw_position) {
+ const double multiplier = reversed_ ? -1.0 : 1.0;
+
+ synchronizer_.RunIteration();
+
+ CopyPosition(front_counter_.get(), &half_claw_position->front);
+ CopyPosition(calibration_counter_.get(),
+ &half_claw_position->calibration);
+ CopyPosition(back_counter_.get(), &half_claw_position->back);
+ half_claw_position->position =
+ multiplier * claw_translate(synchronized_encoder_->get());
+ }
+
+ private:
+ void CopyPosition(const EdgeCounter *counter, HallEffectStruct *out) {
+ const double multiplier = reversed_ ? -1.0 : 1.0;
+
+ out->current = counter->polled_value();
+ out->posedge_count = counter->positive_interrupt_count();
+ out->negedge_count = counter->negative_interrupt_count();
+ out->posedge_value =
+ multiplier * claw_translate(counter->last_positive_encoder_value());
+ out->negedge_value =
+ multiplier * claw_translate(counter->last_negative_encoder_value());
+ }
+
+ InterruptSynchronizer synchronizer_{kInterruptPriority};
+
+ ::std::unique_ptr<EdgeCounter> front_counter_;
+ ::std::unique_ptr<EdgeCounter> calibration_counter_;
+ ::std::unique_ptr<EdgeCounter> back_counter_;
+ ::std::unique_ptr<InterruptSynchronizedEncoder> synchronized_encoder_;
+
+ ::std::unique_ptr<Encoder> encoder_;
+ ::std::unique_ptr<DigitalSource> front_hall_;
+ ::std::unique_ptr<DigitalSource> calibration_hall_;
+ ::std::unique_ptr<DigitalSource> back_hall_;
+
+ const bool reversed_;
+ };
+
static const int kPriority = 30;
static const int kInterruptPriority = 55;
+ void CopyShooterPosedgeCounts(const DMAEdgeCounter *counter,
+ PosedgeOnlyCountedHallEffectStruct *output) {
+ output->current = counter->polled_value();
+ output->posedge_count = counter->positive_count();
+ output->negedge_count = counter->negative_count();
+ output->posedge_value =
+ shooter_translate(counter->last_positive_encoder_value());
+ }
+
int32_t my_pid_;
DriverStation *ds_;
- void CopyPotAndIndexPosition(
- const DMAEncoderAndPotentiometer &encoder, PotAndIndexPosition *position,
- ::std::function<double(int32_t)> encoder_translate,
- ::std::function<double(double)> potentiometer_translate, bool reverse,
- double potentiometer_offset) {
- const double multiplier = reverse ? -1.0 : 1.0;
- position->encoder =
- multiplier * encoder_translate(encoder.polled_encoder_value());
- position->pot = multiplier * potentiometer_translate(
- encoder.polled_potentiometer_voltage()) +
- potentiometer_offset;
- position->latched_encoder =
- multiplier * encoder_translate(encoder.last_encoder_value());
- position->latched_pot =
- multiplier *
- potentiometer_translate(encoder.last_potentiometer_voltage()) +
- potentiometer_offset;
- position->index_pulses = encoder.index_posedge_count();
- }
-
- void CopyPotAndIndexPosition(
- const InterruptEncoderAndPotentiometer &encoder,
- PotAndIndexPosition *position,
- ::std::function<double(int32_t)> encoder_translate,
- ::std::function<double(double)> potentiometer_translate, bool reverse,
- double potentiometer_offset) {
- const double multiplier = reverse ? -1.0 : 1.0;
- position->encoder =
- multiplier * encoder_translate(encoder.encoder()->GetRaw());
- position->pot = multiplier * potentiometer_translate(
- encoder.potentiometer()->GetVoltage()) +
- potentiometer_offset;
- position->latched_encoder =
- multiplier * encoder_translate(encoder.last_encoder_value());
- position->latched_pot =
- multiplier *
- potentiometer_translate(encoder.last_potentiometer_voltage()) +
- potentiometer_offset;
- position->index_pulses = encoder.index_posedge_count();
- }
-
::std::unique_ptr<DMASynchronizer> dma_synchronizer_;
- DMAEncoderAndPotentiometer arm_left_encoder_, arm_right_encoder_,
- elevator_left_encoder_, elevator_right_encoder_;
+ ::std::unique_ptr<AnalogInput> auto_selector_analog_;
- InterruptEncoderAndPotentiometer wrist_encoder_{kInterruptPriority};
+ ::std::unique_ptr<Encoder> drivetrain_left_encoder_;
+ ::std::unique_ptr<Encoder> drivetrain_right_encoder_;
+ ::std::unique_ptr<AnalogInput> low_left_drive_hall_;
+ ::std::unique_ptr<AnalogInput> high_left_drive_hall_;
+ ::std::unique_ptr<AnalogInput> low_right_drive_hall_;
+ ::std::unique_ptr<AnalogInput> high_right_drive_hall_;
- ::std::unique_ptr<Encoder> left_encoder_;
- ::std::unique_ptr<Encoder> right_encoder_;
+ HalfClawReader top_reader_{false}, bottom_reader_{true};
+
+ ::std::unique_ptr<Encoder> shooter_encoder_;
+ ::std::unique_ptr<DigitalSource> shooter_proximal_, shooter_distal_;
+ ::std::unique_ptr<DigitalSource> shooter_plunger_, shooter_latch_;
+ ::std::unique_ptr<DMAEdgeCounter> shooter_proximal_counter_,
+ shooter_distal_counter_;
+ ::std::unique_ptr<DMADigitalReader> shooter_plunger_reader_,
+ shooter_latch_reader_;
::std::atomic<bool> run_{true};
- DigitalGlitchFilter filter_;
+ DigitalGlitchFilter encoder_filter_, hall_filter_;
};
class SolenoidWriter {
public:
SolenoidWriter(const ::std::unique_ptr<BufferedPcm> &pcm)
: pcm_(pcm),
- fridge_(".frc971.control_loops.fridge_queue.output"),
- claw_(".frc971.control_loops.claw_queue.output") {}
+ shooter_(".frc971.control_loops.shooter_queue.output"),
+ drivetrain_(".frc971.control_loops.drivetrain_queue.output") {}
void set_pressure_switch(::std::unique_ptr<DigitalSource> pressure_switch) {
pressure_switch_ = ::std::move(pressure_switch);
@@ -376,34 +454,20 @@
compressor_relay_ = ::std::move(compressor_relay);
}
- void set_fridge_grabbers_top_front(::std::unique_ptr<BufferedSolenoid> s) {
- fridge_grabbers_top_front_ = ::std::move(s);
+ void set_drivetrain_left(::std::unique_ptr<BufferedSolenoid> s) {
+ drivetrain_left_ = ::std::move(s);
}
- void set_fridge_grabbers_top_back(::std::unique_ptr<BufferedSolenoid> s) {
- fridge_grabbers_top_back_ = ::std::move(s);
+ void set_drivetrain_right(::std::unique_ptr<BufferedSolenoid> s) {
+ drivetrain_right_ = ::std::move(s);
}
- void set_fridge_grabbers_bottom_front(
- ::std::unique_ptr<BufferedSolenoid> s) {
- fridge_grabbers_bottom_front_ = ::std::move(s);
+ void set_shooter_latch(::std::unique_ptr<BufferedSolenoid> s) {
+ shooter_latch_ = ::std::move(s);
}
- void set_fridge_grabbers_bottom_back(
- ::std::unique_ptr<BufferedSolenoid> s) {
- fridge_grabbers_bottom_back_ = ::std::move(s);
- }
-
- void set_claw_pinchers(::std::unique_ptr<BufferedSolenoid> s) {
- claw_pinchers_ = ::std::move(s);
- }
-
- void set_grabber_latch_release(::std::unique_ptr<BufferedSolenoid> s) {
- grabber_latch_release_ = ::std::move(s);
- }
-
- void set_grabber_fold_up(::std::unique_ptr<BufferedSolenoid> s) {
- grabber_fold_up_ = ::std::move(s);
+ void set_shooter_brake(::std::unique_ptr<BufferedSolenoid> s) {
+ shooter_brake_ = ::std::move(s);
}
void operator()() {
@@ -414,30 +478,23 @@
::aos::time::PhasedLoopXMS(20, 1000);
{
- fridge_.FetchLatest();
- if (fridge_.get()) {
- LOG_STRUCT(DEBUG, "solenoids", *fridge_);
- fridge_grabbers_top_front_->Set(!fridge_->grabbers.top_front);
- fridge_grabbers_top_back_->Set(!fridge_->grabbers.top_back);
- fridge_grabbers_bottom_front_->Set(!fridge_->grabbers.bottom_front);
- fridge_grabbers_bottom_back_->Set(!fridge_->grabbers.bottom_back);
+ shooter_.FetchLatest();
+ if (shooter_.get()) {
+ LOG_STRUCT(DEBUG, "solenoids", *shooter_);
+ shooter_latch_->Set(!shooter_->latch_piston);
+ shooter_brake_->Set(!shooter_->brake_piston);
}
}
{
- claw_.FetchLatest();
- if (claw_.get()) {
- LOG_STRUCT(DEBUG, "solenoids", *claw_);
- claw_pinchers_->Set(claw_->rollers_closed);
+ drivetrain_.FetchLatest();
+ if (drivetrain_.get()) {
+ LOG_STRUCT(DEBUG, "solenoids", *drivetrain_);
+ drivetrain_left_->Set(drivetrain_->left_high);
+ drivetrain_right_->Set(drivetrain_->right_high);
}
}
- ::aos::joystick_state.FetchLatest();
- grabber_latch_release_->Set(::aos::joystick_state.get() != nullptr &&
- ::aos::joystick_state->autonomous);
- grabber_fold_up_->Set(::aos::joystick_state.get() != nullptr &&
- ::aos::joystick_state->joysticks[1].buttons & 1);
-
{
PneumaticsToLog to_log;
{
@@ -461,18 +518,17 @@
private:
const ::std::unique_ptr<BufferedPcm> &pcm_;
- ::std::unique_ptr<BufferedSolenoid> fridge_grabbers_top_front_;
- ::std::unique_ptr<BufferedSolenoid> fridge_grabbers_top_back_;
- ::std::unique_ptr<BufferedSolenoid> fridge_grabbers_bottom_front_;
- ::std::unique_ptr<BufferedSolenoid> fridge_grabbers_bottom_back_;
- ::std::unique_ptr<BufferedSolenoid> claw_pinchers_;
- ::std::unique_ptr<BufferedSolenoid> grabber_latch_release_;
- ::std::unique_ptr<BufferedSolenoid> grabber_fold_up_;
+
+ ::std::unique_ptr<BufferedSolenoid> drivetrain_left_;
+ ::std::unique_ptr<BufferedSolenoid> drivetrain_right_;
+ ::std::unique_ptr<BufferedSolenoid> shooter_latch_;
+ ::std::unique_ptr<BufferedSolenoid> shooter_brake_;
+
::std::unique_ptr<DigitalSource> pressure_switch_;
::std::unique_ptr<Relay> compressor_relay_;
- ::aos::Queue<::frc971::control_loops::FridgeQueue::Output> fridge_;
- ::aos::Queue<::frc971::control_loops::ClawQueue::Output> claw_;
+ ::aos::Queue<::frc971::control_loops::ShooterQueue::Output> shooter_;
+ ::aos::Queue<::frc971::control_loops::DrivetrainQueue::Output> drivetrain_;
::std::atomic<bool> run_{true};
};
@@ -509,180 +565,166 @@
::std::unique_ptr<Talon> right_drivetrain_talon_;
};
-class FridgeWriter : public LoopOutputHandler {
+class ShooterWriter : public LoopOutputHandler {
public:
- void set_left_arm_talon(::std::unique_ptr<Talon> t) {
- left_arm_talon_ = ::std::move(t);
- }
-
- void set_right_arm_talon(::std::unique_ptr<Talon> t) {
- right_arm_talon_ = ::std::move(t);
- }
-
- void set_left_elevator_talon(::std::unique_ptr<Talon> t) {
- left_elevator_talon_ = ::std::move(t);
- }
-
- void set_right_elevator_talon(::std::unique_ptr<Talon> t) {
- right_elevator_talon_ = ::std::move(t);
+ void set_shooter_talon(::std::unique_ptr<Talon> t) {
+ shooter_talon_ = ::std::move(t);
}
private:
virtual void Read() override {
- ::frc971::control_loops::fridge_queue.output.FetchAnother();
+ ::frc971::control_loops::shooter_queue_group.output.FetchAnother();
}
virtual void Write() override {
- auto &queue = ::frc971::control_loops::fridge_queue.output;
+ auto &queue = ::frc971::control_loops::shooter_queue_group.output;
LOG_STRUCT(DEBUG, "will output", *queue);
- left_arm_talon_->Set(queue->left_arm / 12.0);
- right_arm_talon_->Set(-queue->right_arm / 12.0);
- left_elevator_talon_->Set(queue->left_elevator / 12.0);
- right_elevator_talon_->Set(-queue->right_elevator / 12.0);
+ shooter_talon_->Set(queue->voltage / 12.0);
}
virtual void Stop() override {
- LOG(WARNING, "Fridge output too old.\n");
- left_arm_talon_->Disable();
- right_arm_talon_->Disable();
- left_elevator_talon_->Disable();
- right_elevator_talon_->Disable();
+ LOG(WARNING, "shooter output too old\n");
+ shooter_talon_->Disable();
}
- ::std::unique_ptr<Talon> left_arm_talon_;
- ::std::unique_ptr<Talon> right_arm_talon_;
- ::std::unique_ptr<Talon> left_elevator_talon_;
- ::std::unique_ptr<Talon> right_elevator_talon_;
+ ::std::unique_ptr<Talon> shooter_talon_;
};
class ClawWriter : public LoopOutputHandler {
public:
- void set_left_intake_talon(::std::unique_ptr<Talon> t) {
- left_intake_talon_ = ::std::move(t);
+ void set_top_claw_talon(::std::unique_ptr<Talon> t) {
+ top_claw_talon_ = ::std::move(t);
}
- void set_right_intake_talon(::std::unique_ptr<Talon> t) {
- right_intake_talon_ = ::std::move(t);
+ void set_bottom_claw_talon(::std::unique_ptr<Talon> t) {
+ bottom_claw_talon_ = ::std::move(t);
}
- void set_wrist_talon(::std::unique_ptr<Talon> t) {
- wrist_talon_ = ::std::move(t);
+ void set_left_tusk_talon(::std::unique_ptr<Talon> t) {
+ left_tusk_talon_ = ::std::move(t);
+ }
+
+ void set_right_tusk_talon(::std::unique_ptr<Talon> t) {
+ right_tusk_talon_ = ::std::move(t);
+ }
+
+ void set_intake1_talon(::std::unique_ptr<Talon> t) {
+ intake1_talon_ = ::std::move(t);
+ }
+
+ void set_intake2_talon(::std::unique_ptr<Talon> t) {
+ intake2_talon_ = ::std::move(t);
}
private:
virtual void Read() override {
- ::frc971::control_loops::claw_queue.output.FetchAnother();
+ ::frc971::control_loops::claw_queue_group.output.FetchAnother();
}
virtual void Write() override {
- auto &queue = ::frc971::control_loops::claw_queue.output;
+ auto &queue = ::frc971::control_loops::claw_queue_group.output;
LOG_STRUCT(DEBUG, "will output", *queue);
- left_intake_talon_->Set(queue->intake_voltage / 12.0);
- right_intake_talon_->Set(-queue->intake_voltage / 12.0);
- wrist_talon_->Set(-queue->voltage / 12.0);
+ intake1_talon_->Set(queue->intake_voltage / 12.0);
+ intake2_talon_->Set(queue->intake_voltage / 12.0);
+ bottom_claw_talon_->Set(-queue->bottom_claw_voltage / 12.0);
+ top_claw_talon_->Set(queue->top_claw_voltage / 12.0);
+ left_tusk_talon_->Set(queue->tusk_voltage / 12.0);
+ right_tusk_talon_->Set(-queue->tusk_voltage / 12.0);
}
virtual void Stop() override {
- LOG(WARNING, "Claw output too old.\n");
- left_intake_talon_->Disable();
- right_intake_talon_->Disable();
- wrist_talon_->Disable();
+ LOG(WARNING, "claw output too old\n");
+ intake1_talon_->Disable();
+ intake2_talon_->Disable();
+ bottom_claw_talon_->Disable();
+ top_claw_talon_->Disable();
+ left_tusk_talon_->Disable();
+ right_tusk_talon_->Disable();
}
- ::std::unique_ptr<Talon> left_intake_talon_;
- ::std::unique_ptr<Talon> right_intake_talon_;
- ::std::unique_ptr<Talon> wrist_talon_;
+ ::std::unique_ptr<Talon> top_claw_talon_;
+ ::std::unique_ptr<Talon> bottom_claw_talon_;
+ ::std::unique_ptr<Talon> left_tusk_talon_;
+ ::std::unique_ptr<Talon> right_tusk_talon_;
+ ::std::unique_ptr<Talon> intake1_talon_;
+ ::std::unique_ptr<Talon> intake2_talon_;
};
-// TODO(brian): Replace this with ::std::make_unique once all our toolchains
-// have support.
-template <class T, class... U>
-std::unique_ptr<T> make_unique(U &&... u) {
- return std::unique_ptr<T>(new T(std::forward<U>(u)...));
-}
-
class WPILibRobot : public RobotBase {
public:
- ::std::unique_ptr<Encoder> encoder(int index) {
+ ::std::unique_ptr<Encoder> make_encoder(int index) {
return make_unique<Encoder>(10 + index * 2, 11 + index * 2, false,
Encoder::k4X);
}
+
virtual void StartCompetition() {
::aos::InitNRT();
::aos::SetCurrentThreadName("StartCompetition");
JoystickSender joystick_sender;
::std::thread joystick_thread(::std::ref(joystick_sender));
- // TODO(austin): Compressor needs to use a spike.
SensorReader reader;
LOG(INFO, "Creating the reader\n");
- reader.set_arm_left_encoder(encoder(1));
- reader.set_arm_left_index(make_unique<DigitalInput>(1));
- reader.set_arm_left_potentiometer(make_unique<AnalogInput>(1));
- reader.set_arm_right_encoder(encoder(5));
- reader.set_arm_right_index(make_unique<DigitalInput>(5));
- reader.set_arm_right_potentiometer(make_unique<AnalogInput>(5));
+ reader.set_auto_selector_analog(make_unique<AnalogInput>(4));
- reader.set_elevator_left_encoder(encoder(0));
- reader.set_elevator_left_index(make_unique<DigitalInput>(0));
- reader.set_elevator_left_potentiometer(make_unique<AnalogInput>(0));
+ reader.set_drivetrain_left_encoder(make_encoder(0));
+ reader.set_drivetrain_right_encoder(make_encoder(1));
+ reader.set_high_left_drive_hall(make_unique<AnalogInput>(1));
+ reader.set_low_left_drive_hall(make_unique<AnalogInput>(0));
+ reader.set_high_right_drive_hall(make_unique<AnalogInput>(2));
+ reader.set_low_right_drive_hall(make_unique<AnalogInput>(3));
- reader.set_elevator_right_encoder(encoder(4));
- reader.set_elevator_right_index(make_unique<DigitalInput>(4));
- reader.set_elevator_right_potentiometer(make_unique<AnalogInput>(4));
+ reader.set_top_claw_encoder(make_encoder(3));
+ reader.set_top_claw_front_hall(make_unique<HallEffect>(4)); // R2
+ reader.set_top_claw_calibration_hall(make_unique<HallEffect>(3)); // R3
+ reader.set_top_claw_back_hall(make_unique<HallEffect>(5)); // R1
- reader.set_wrist_encoder(encoder(6));
- reader.set_wrist_index(make_unique<DigitalInput>(6));
- reader.set_wrist_potentiometer(make_unique<AnalogInput>(6));
+ reader.set_bottom_claw_encoder(make_encoder(5));
+ reader.set_bottom_claw_front_hall(make_unique<HallEffect>(1)); // L2
+ reader.set_bottom_claw_calibration_hall(make_unique<HallEffect>(0)); // L3
+ reader.set_bottom_claw_back_hall(make_unique<HallEffect>(2)); // L1
- reader.set_left_encoder(encoder(2));
- reader.set_right_encoder(encoder(3));
+ reader.set_shooter_encoder(make_encoder(2));
+ reader.set_shooter_proximal(make_unique<HallEffect>(6)); // S1
+ reader.set_shooter_distal(make_unique<HallEffect>(7)); // S2
+ reader.set_shooter_plunger(make_unique<HallEffect>(8)); // S3
+ reader.set_shooter_latch(make_unique<HallEffect>(9)); // S4
+
reader.set_dma(make_unique<DMA>());
::std::thread reader_thread(::std::ref(reader));
+
GyroSender gyro_sender;
::std::thread gyro_thread(::std::ref(gyro_sender));
DrivetrainWriter drivetrain_writer;
drivetrain_writer.set_left_drivetrain_talon(
- ::std::unique_ptr<Talon>(new Talon(8)));
+ ::std::unique_ptr<Talon>(new Talon(5)));
drivetrain_writer.set_right_drivetrain_talon(
- ::std::unique_ptr<Talon>(new Talon(0)));
+ ::std::unique_ptr<Talon>(new Talon(2)));
::std::thread drivetrain_writer_thread(::std::ref(drivetrain_writer));
- // TODO(sensors): Get real PWM output and relay numbers for the fridge and
- // claw.
- FridgeWriter fridge_writer;
- fridge_writer.set_left_arm_talon(
- ::std::unique_ptr<Talon>(new Talon(6)));
- fridge_writer.set_right_arm_talon(
- ::std::unique_ptr<Talon>(new Talon(2)));
- fridge_writer.set_left_elevator_talon(
- ::std::unique_ptr<Talon>(new Talon(7)));
- fridge_writer.set_right_elevator_talon(
- ::std::unique_ptr<Talon>(new Talon(1)));
- ::std::thread fridge_writer_thread(::std::ref(fridge_writer));
-
- ClawWriter claw_writer;
- claw_writer.set_left_intake_talon(
- ::std::unique_ptr<Talon>(new Talon(5)));
- claw_writer.set_right_intake_talon(
- ::std::unique_ptr<Talon>(new Talon(3)));
- claw_writer.set_wrist_talon(
- ::std::unique_ptr<Talon>(new Talon(4)));
+ ::frc971::wpilib::ClawWriter claw_writer;
+ claw_writer.set_top_claw_talon(::std::unique_ptr<Talon>(new Talon(1)));
+ claw_writer.set_bottom_claw_talon(::std::unique_ptr<Talon>(new Talon(0)));
+ claw_writer.set_left_tusk_talon(::std::unique_ptr<Talon>(new Talon(4)));
+ claw_writer.set_right_tusk_talon(::std::unique_ptr<Talon>(new Talon(3)));
+ claw_writer.set_intake1_talon(::std::unique_ptr<Talon>(new Talon(7)));
+ claw_writer.set_intake2_talon(::std::unique_ptr<Talon>(new Talon(8)));
::std::thread claw_writer_thread(::std::ref(claw_writer));
+ ::frc971::wpilib::ShooterWriter shooter_writer;
+ shooter_writer.set_shooter_talon(::std::unique_ptr<Talon>(new Talon(6)));
+ ::std::thread shooter_writer_thread(::std::ref(shooter_writer));
+
::std::unique_ptr<::frc971::wpilib::BufferedPcm> pcm(
new ::frc971::wpilib::BufferedPcm());
SolenoidWriter solenoid_writer(pcm);
- solenoid_writer.set_fridge_grabbers_top_front(pcm->MakeSolenoid(0));
- solenoid_writer.set_fridge_grabbers_top_back(pcm->MakeSolenoid(0));
- solenoid_writer.set_fridge_grabbers_bottom_front(pcm->MakeSolenoid(2));
- solenoid_writer.set_fridge_grabbers_bottom_back(pcm->MakeSolenoid(1));
- solenoid_writer.set_claw_pinchers(pcm->MakeSolenoid(4));
- solenoid_writer.set_grabber_latch_release(pcm->MakeSolenoid(7));
- solenoid_writer.set_grabber_fold_up(pcm->MakeSolenoid(5));
+ solenoid_writer.set_drivetrain_left(pcm->MakeSolenoid(6));
+ solenoid_writer.set_drivetrain_right(pcm->MakeSolenoid(7));
+ solenoid_writer.set_shooter_latch(pcm->MakeSolenoid(5));
+ solenoid_writer.set_shooter_brake(pcm->MakeSolenoid(4));
solenoid_writer.set_pressure_switch(make_unique<DigitalInput>(9));
solenoid_writer.set_compressor_relay(make_unique<Relay>(0));
@@ -702,6 +744,10 @@
drivetrain_writer.Quit();
drivetrain_writer_thread.join();
+ shooter_writer.Quit();
+ shooter_writer_thread.join();
+ claw_writer.Quit();
+ claw_writer_thread.join();
solenoid_writer.Quit();
solenoid_thread.join();