Remove potentiometer reading for the hood
Change-Id: Ia6b8650d30adf2212284bbf8d651bd04aafe98b0
diff --git a/frc971/wpilib/encoder_and_potentiometer.cc b/frc971/wpilib/encoder_and_potentiometer.cc
index 800c49b..1787c3f 100644
--- a/frc971/wpilib/encoder_and_potentiometer.cc
+++ b/frc971/wpilib/encoder_and_potentiometer.cc
@@ -6,7 +6,7 @@
namespace frc971 {
namespace wpilib {
-void DMAEncoderAndPotentiometer::UpdateFromSample(const DMASample &sample) {
+bool DMAEncoder::DoUpdateFromSample(const DMASample &sample) {
if (index_last_value_) {
// It was already true last time, so check if it's reset back to false yet.
index_last_value_ = sample.Get(index_.get());
@@ -15,8 +15,9 @@
index_last_value_ = true;
++index_posedge_count_;
last_encoder_value_ = sample.GetRaw(encoder_.get());
- last_potentiometer_voltage_ = sample.GetVoltage(potentiometer_.get());
+ return true;
}
+ return false;
}
void InterruptEncoderAndPotentiometer::Start() {
diff --git a/frc971/wpilib/encoder_and_potentiometer.h b/frc971/wpilib/encoder_and_potentiometer.h
index 7f784e9..09c1244 100644
--- a/frc971/wpilib/encoder_and_potentiometer.h
+++ b/frc971/wpilib/encoder_and_potentiometer.h
@@ -88,11 +88,11 @@
DISALLOW_COPY_AND_ASSIGN(InterruptEncoderAndPotentiometer);
};
-// Latches values from an encoder and potentiometer on positive edges from
-// another input using DMA.
-class DMAEncoderAndPotentiometer : public DMASampleHandlerInterface {
+// Latches values from an encoder on positive edges from another input using
+// DMA.
+class DMAEncoder : public DMASampleHandlerInterface {
public:
- DMAEncoderAndPotentiometer() {}
+ DMAEncoder() {}
void set_encoder(::std::unique_ptr<Encoder> encoder) {
encoder_ = ::std::move(encoder);
@@ -104,62 +104,102 @@
}
DigitalSource *index() const { return index_.get(); }
- void set_potentiometer(::std::unique_ptr<AnalogInput> potentiometer) {
- potentiometer_ = ::std::move(potentiometer);
- }
- AnalogInput *potentiometer() const { return potentiometer_.get(); }
-
// Returns the most recent polled value of the encoder.
uint32_t polled_encoder_value() const { return polled_encoder_value_; }
- // Returns the most recent polled voltage of the potentiometer.
- float polled_potentiometer_voltage() const {
- return polled_potentiometer_voltage_;
- }
// Returns the number of poseges that have happened on the index input.
uint32_t index_posedge_count() const { return index_posedge_count_; }
// Returns the value of the encoder at the last index posedge.
int32_t last_encoder_value() const { return last_encoder_value_; }
- // Returns the voltage of the potentiometer at the last index posedge.
- float last_potentiometer_voltage() const {
- return last_potentiometer_voltage_;
+
+ void UpdateFromSample(const DMASample &sample) override {
+ DoUpdateFromSample(sample);
}
- virtual void UpdateFromSample(const DMASample &sample) override;
-
- virtual void PollFromSample(const DMASample &sample) override {
+ void PollFromSample(const DMASample &sample) override {
polled_encoder_value_ = sample.GetRaw(encoder_.get());
- polled_potentiometer_voltage_ = sample.GetVoltage(potentiometer_.get());
}
- virtual void UpdatePolledValue() override {
+ void UpdatePolledValue() override {
polled_encoder_value_ = encoder_->GetRaw();
- polled_potentiometer_voltage_ = potentiometer_->GetVoltage();
}
- virtual void AddToDMA(DMA *dma) override {
+ void AddToDMA(DMA *dma) override {
dma->Add(encoder_.get());
dma->Add(index_.get());
- dma->Add(potentiometer_.get());
dma->SetExternalTrigger(index_.get(), true, true);
}
+ protected:
+ // The same as UpdateFromSample except also returns true if this sample is a
+ // new edge on the index.
+ bool DoUpdateFromSample(const DMASample &sample);
+
private:
::std::unique_ptr<Encoder> encoder_;
::std::unique_ptr<DigitalSource> index_;
- ::std::unique_ptr<AnalogInput> potentiometer_;
int32_t polled_encoder_value_ = 0;
- float polled_potentiometer_voltage_ = 0.0f;
int32_t last_encoder_value_ = 0;
- float last_potentiometer_voltage_ = 0.0f;
uint32_t index_posedge_count_ = 0;
// Whether or not it was triggered in the last sample.
bool index_last_value_ = false;
+ DISALLOW_COPY_AND_ASSIGN(DMAEncoder);
+};
+
+// Latches values from an encoder and potentiometer on positive edges from
+// another input using DMA.
+class DMAEncoderAndPotentiometer : public DMAEncoder {
+ public:
+ DMAEncoderAndPotentiometer() {}
+
+ void set_potentiometer(::std::unique_ptr<AnalogInput> potentiometer) {
+ potentiometer_ = ::std::move(potentiometer);
+ }
+ AnalogInput *potentiometer() const { return potentiometer_.get(); }
+
+ // Returns the most recent polled voltage of the potentiometer.
+ float polled_potentiometer_voltage() const {
+ return polled_potentiometer_voltage_;
+ }
+
+ // Returns the voltage of the potentiometer at the last index posedge.
+ float last_potentiometer_voltage() const {
+ return last_potentiometer_voltage_;
+ }
+
+ void UpdateFromSample(const DMASample &sample) override {
+ if (DMAEncoder::DoUpdateFromSample(sample)) {
+ last_potentiometer_voltage_ = sample.GetVoltage(potentiometer_.get());
+ }
+ }
+
+ void PollFromSample(const DMASample &sample) override {
+ polled_potentiometer_voltage_ = sample.GetVoltage(potentiometer_.get());
+ DMAEncoder::PollFromSample(sample);
+ }
+
+ void UpdatePolledValue() override {
+ polled_potentiometer_voltage_ = potentiometer_->GetVoltage();
+ DMAEncoder::UpdatePolledValue();
+ }
+
+ void AddToDMA(DMA *dma) override {
+ dma->Add(potentiometer_.get());
+ DMAEncoder::AddToDMA(dma);
+ }
+
+ private:
+ ::std::unique_ptr<AnalogInput> potentiometer_;
+
+ float polled_potentiometer_voltage_ = 0.0f;
+
+ float last_potentiometer_voltage_ = 0.0f;
+
DISALLOW_COPY_AND_ASSIGN(DMAEncoderAndPotentiometer);
};
diff --git a/y2017/constants.cc b/y2017/constants.cc
index 2ac4875..b0d7fd5 100644
--- a/y2017/constants.cc
+++ b/y2017/constants.cc
@@ -42,8 +42,8 @@
constexpr ::frc971::constants::Range Values::kIntakeRange;
constexpr double Values::kHoodEncoderCountsPerRevolution,
- Values::kHoodEncoderRatio, Values::kHoodPotRatio,
- Values::kHoodEncoderIndexDifference, Values::kMaxHoodEncoderPulsesPerSecond;
+ Values::kHoodEncoderRatio, Values::kHoodEncoderIndexDifference,
+ Values::kMaxHoodEncoderPulsesPerSecond;
constexpr ::frc971::constants::Range Values::kHoodRange;
constexpr double Values::kTurretEncoderCountsPerRevolution,
diff --git a/y2017/constants.h b/y2017/constants.h
index 109d1b5..49b7afa 100644
--- a/y2017/constants.h
+++ b/y2017/constants.h
@@ -80,7 +80,6 @@
static constexpr double kHoodEncoderCountsPerRevolution = 2048 * 4;
static constexpr double kHoodEncoderRatio = 20.0 / 345.0;
- static constexpr double kHoodPotRatio = 20.0 / 345.0;
static constexpr double kHoodEncoderIndexDifference =
2.0 * M_PI * kHoodEncoderRatio;
static constexpr double kMaxHoodEncoderPulsesPerSecond =
diff --git a/y2017/wpilib_interface.cc b/y2017/wpilib_interface.cc
index 6954a05..93f2ef4 100644
--- a/y2017/wpilib_interface.cc
+++ b/y2017/wpilib_interface.cc
@@ -105,12 +105,6 @@
(2 * M_PI /*radians*/);
}
-// TODO(Travis): Make sure the number of turns is right.
-double hood_pot_translate(double voltage) {
- return voltage * Values::kHoodPotRatio * (3.0 /*turns*/ / 5.0 /*volts*/) *
- (2 * M_PI /*radians*/);
-}
-
double turret_pot_translate(double voltage) {
return voltage * Values::kTurretPotRatio * (10.0 /*turns*/ / 5.0 /*volts*/) *
(2 * M_PI /*radians*/);
@@ -266,10 +260,6 @@
hood_encoder_.set_encoder(::std::move(encoder));
}
- void set_hood_potentiometer(::std::unique_ptr<AnalogInput> potentiometer) {
- hood_encoder_.set_potentiometer(::std::move(potentiometer));
- }
-
void set_hood_index(::std::unique_ptr<DigitalInput> index) {
slow_encoder_filter_.Add(index.get());
hood_encoder_.set_index(::std::move(index));
@@ -351,8 +341,7 @@
CopyPosition(hood_encoder_, &superstructure_message->hood,
Values::kHoodEncoderCountsPerRevolution,
- Values::kHoodEncoderRatio, hood_pot_translate, false,
- values.hood.pot_offset);
+ Values::kHoodEncoderRatio, false);
CopyPosition(turret_encoder_, &superstructure_message->turret,
Values::kTurretEncoderCountsPerRevolution,
@@ -384,27 +373,19 @@
(2.0 * M_PI);
}
- void CopyPosition(const ::frc971::wpilib::DMAEncoderAndPotentiometer &encoder,
- ::frc971::PotAndIndexPosition *position,
+ void CopyPosition(const ::frc971::wpilib::DMAEncoder &encoder,
+ ::frc971::IndexPosition *position,
double encoder_counts_per_revolution, double encoder_ratio,
- ::std::function<double(double)> potentiometer_translate,
- bool reverse, double pot_offset) {
+ bool reverse) {
const double multiplier = reverse ? -1.0 : 1.0;
position->encoder =
multiplier * encoder_translate(encoder.polled_encoder_value(),
encoder_counts_per_revolution,
encoder_ratio);
- position->pot = multiplier * potentiometer_translate(
- encoder.polled_potentiometer_voltage()) +
- pot_offset;
position->latched_encoder =
multiplier * encoder_translate(encoder.last_encoder_value(),
encoder_counts_per_revolution,
encoder_ratio);
- position->latched_pot =
- multiplier *
- potentiometer_translate(encoder.last_potentiometer_voltage()) +
- pot_offset;
position->index_pulses = encoder.index_posedge_count();
}
@@ -442,7 +423,7 @@
::std::unique_ptr<AnalogInput> indexer_hall_;
AbsoluteEncoderAndPotentiometer turret_encoder_;
- ::frc971::wpilib::DMAEncoderAndPotentiometer hood_encoder_;
+ ::frc971::wpilib::DMAEncoder hood_encoder_;
::std::unique_ptr<Encoder> shooter_encoder_;
::std::array<::std::unique_ptr<DigitalInput>, 4> autonomous_modes_;