Line data    Source code

       1             : #pragma once
       2             : 
       3             : #include "Selector.hpp"
       4             : #include <AH/Hardware/ExtendedInputOutput/ExtendedInputOutput.hpp>
       5             : #include <Def/Def.hpp>
       6             : #include <Def/TypeTraits.hpp>
       7             : 
       8             : #ifdef ARDUINO
       9             : #include <Submodules/Encoder/AHEncoder.hpp>
      10             : #else
      11             : #include <Encoder.h> // Mock
      12             : #endif
      13             : 
      14             : BEGIN_CS_NAMESPACE
      15             : 
      16             : template <setting_t N, class Callback = EmptySelectorCallback>
      17             : class GenericEncoderSelector : public GenericSelector<N, Callback> {
      18             :     using Parent = GenericSelector<N, Callback>;
      19             : 
      20             :   public:
      21           2 :     GenericEncoderSelector(Selectable<N> &selectable, const Callback &callback,
      22             :                            const EncoderSwitchPinList &pins,
      23             :                            int8_t pulsesPerStep = 4, Wrap wrap = Wrap::Wrap)
      24             :         : GenericSelector<N, Callback> {selectable, callback},
      25           2 :           encoder {pins.A, pins.B}, switchPin(pins.switchPin),
      26           4 :           pulsesPerStep(pulsesPerStep), wrap(wrap) {}
      27             : 
      28           0 :     void begin() override {
      29           0 :         Parent::begin();
      30           0 :         if (switchPin != NO_PIN)
      31           0 :             AH::ExtIO::pinMode(switchPin, INPUT_PULLUP);
      32           0 :         begin_if_possible(encoder);
      33           0 :     }
      34             : 
      35           0 :     void update() override {
      36           0 :         Parent::update();
      37             :         // TODO: use EncoderState
      38           0 :         long currentPosition = encoder.read();
      39           0 :         long difference = (currentPosition - previousPosition) / pulsesPerStep;
      40           0 :         if (difference) {
      41           0 :             previousPosition += difference * pulsesPerStep;
      42           0 :             if (difference > 0)
      43           0 :                 while (difference-- > 0)
      44           0 :                     this->increment(wrap);
      45             :             else
      46           0 :                 while (difference++ < 0)
      47           0 :                     this->decrement(wrap);
      48             :         }
      49             : 
      50           0 :         if (switchPin != NO_PIN) {
      51           0 :             bool currentState = AH::ExtIO::digitalRead(switchPin);
      52           0 :             if (previousSwitchState == HIGH && currentState == LOW) {
      53             :                 // TODO: invert?
      54           0 :                 this->reset();
      55             :             }
      56           0 :             previousSwitchState = currentState;
      57             :         }
      58           0 :     }
      59             : 
      60             :   private:
      61             :     AHEncoder encoder;
      62             :     pin_t switchPin;
      63             :     int8_t pulsesPerStep;
      64             :     Wrap wrap;
      65             : 
      66             :     long previousPosition = 0;
      67             :     bool previousSwitchState = HIGH;
      68             : };
      69             : 
      70             : // -------------------------------------------------------------------------- //
      71             : 
      72             : /**
      73             :  * @brief   Selector that reads from a rotary encoder. 
      74             :  * 
      75             :  * @ingroup Selectors
      76             :  * 
      77             :  * @tparam  N 
      78             :  *          The number of settings.
      79             :  */
      80             : template <setting_t N>
      81             : class EncoderSelector : public GenericEncoderSelector<N> {
      82             :   public:
      83           1 :     EncoderSelector(Selectable<N> &selectable, const EncoderSwitchPinList &pins,
      84             :                     int8_t pulsesPerStep = 4, Wrap wrap = Wrap::Wrap)
      85             :         : GenericEncoderSelector<N> {
      86             :               selectable, {}, pins, pulsesPerStep, wrap,
      87           1 :           } {}
      88             : };
      89             : 
      90             : END_CS_NAMESPACE