Line data    Source code

       1             : #pragma once
       2             : 
       3             : #include <AH/STL/type_traits> // std::make_signed
       4             : #include <AH/STL/utility>     // std::forward
       5             : #include <Def/Def.hpp>
       6             : #include <Def/TypeTraits.hpp>
       7             : #include <MIDI_Outputs/Abstract/EncoderState.hpp>
       8             : #include <MIDI_Outputs/Abstract/MIDIOutputElement.hpp>
       9             : 
      10             : #ifdef ARDUINO
      11             : #include <Submodules/Encoder/AHEncoder.hpp>
      12             : #else
      13             : #include <Encoder.h> // Mock
      14             : #endif
      15             : 
      16             : BEGIN_CS_NAMESPACE
      17             : 
      18             : /**
      19             :  * @brief   An abstract class for rotary encoders that send absolute MIDI 
      20             :  *          events.
      21             :  */
      22             : template <class Enc, class Sender>
      23             : class GenericMIDIAbsoluteEncoder : public MIDIOutputElement {
      24             :   public:
      25           1 :     GenericMIDIAbsoluteEncoder(Enc &&encoder, MIDIAddress address,
      26             :                                int16_t speedMultiply, uint8_t pulsesPerStep,
      27             :                                const Sender &sender)
      28           1 :         : encoder(std::forward<Enc>(encoder)), address(address),
      29           2 :           encstate(speedMultiply, pulsesPerStep), sender(sender) {}
      30             : 
      31           0 :     void begin() override { begin_if_possible(encoder); }
      32             : 
      33           1 :     void update() override {
      34           1 :         auto encval = encoder.read();
      35           1 :         if (int16_t delta = encstate.update(encval)) {
      36           1 :             int16_t oldValue = value;
      37           1 :             int16_t newValue = oldValue + delta;
      38           1 :             newValue = constrain(newValue, 0, maxValue);
      39           1 :             if (oldValue != newValue) {
      40           1 :                 value = newValue;
      41           1 :                 forcedUpdate();
      42             :             }
      43             :         }
      44           1 :     }
      45             : 
      46             :     /// Send the current value over MIDI, even if the position of the encoder
      47             :     /// didn't change.
      48           1 :     void forcedUpdate() { sender.send(value, address); }
      49             : 
      50             :     /**
      51             :      * @brief   Get the absolute value of the encoder.
      52             :      */
      53           1 :     uint16_t getValue() const { return value; }
      54             : 
      55             :     /**
      56             :      * @brief   Set the absolute value of the encoder.
      57             :      */
      58           1 :     void setValue(uint16_t value) { this->value = value; }
      59             : 
      60             :     /// Get the maximum possible value that can be returned by @ref getValue.
      61             :     static int16_t getMaxValue() { return maxValue; }
      62             : 
      63             :     void setSpeedMultiply(int16_t speedMultiply) {
      64             :         encstate.setSpeedMultiply(speedMultiply);
      65             :     }
      66             :     int16_t getSpeedMultiply() const { return encstate.getSpeedMultiply(); }
      67             : 
      68             :     /// Get the MIDI address.
      69             :     MIDIAddress getAddress() const { return this->address; }
      70             :     /// Set the MIDI address.
      71             :     void setAddress(MIDIAddress address) { this->address = address; }
      72             : 
      73             :     int16_t resetPositionOffset() {
      74             :         auto encval = encoder.read();
      75             :         return encstate.update(encval);
      76             :     }
      77             : 
      78             :   private:
      79             :     Enc encoder;
      80             :     MIDIAddress address;
      81             :     int16_t value = 0;
      82             :     EncoderState<decltype(encoder.read())> encstate;
      83             : 
      84             :     constexpr static int16_t maxValue = uint16_t(1u << Sender::precision()) - 1;
      85             : 
      86             :   public:
      87             :     Sender sender;
      88             : };
      89             : 
      90             : template <class Sender>
      91             : using MIDIAbsoluteEncoder = GenericMIDIAbsoluteEncoder<AHEncoder, Sender>;
      92             : 
      93             : template <class Sender>
      94             : using BorrowedMIDIAbsoluteEncoder =
      95             :     GenericMIDIAbsoluteEncoder<AHEncoder &, Sender>;
      96             : 
      97             : END_CS_NAMESPACE