Line data    Source code

       1             : #pragma once
       2             : 
       3             : #include <AH/STL/utility> // std::forward
       4             : #include <Banks/BankableAddresses.hpp>
       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             : namespace Bankable {
      19             : 
      20             : /**
      21             :  * @brief   An abstract class for rotary encoders that send absolute MIDI 
      22             :  *          events.
      23             :  */
      24             : template <class Enc, uint8_t NumBanks, class BankAddress, class Sender>
      25             : class GenericMIDIAbsoluteEncoder : public MIDIOutputElement {
      26             :   public:
      27           4 :     GenericMIDIAbsoluteEncoder(const BankAddress &address, Enc &&encoder,
      28             :                                int16_t speedMultiply, uint8_t pulsesPerStep,
      29             :                                const Sender &sender)
      30           4 :         : encoder(std::forward<Enc>(encoder)), address(address),
      31           8 :           encstate(speedMultiply, pulsesPerStep), sender(sender) {}
      32             : 
      33           0 :     void begin() override { begin_if_possible(encoder); }
      34             : 
      35           0 :     void update() override {
      36           0 :         auto encval = encoder.read();
      37           0 :         if (int16_t delta = encstate.update(encval)) {
      38           0 :             address.lock();
      39           0 :             int16_t oldValue = values[address.getSelection()];
      40           0 :             int16_t newValue = oldValue + delta;
      41           0 :             newValue = constrain(newValue, 0, maxValue);
      42           0 :             if (oldValue != newValue) {
      43           0 :                 values[address.getSelection()] = newValue;
      44           0 :                 forcedUpdate();
      45             :             }
      46           0 :             address.unlock();
      47             :         }
      48           0 :     }
      49             : 
      50             :     /// Send the current value over MIDI, even if the position of the encoder
      51             :     /// didn't change.
      52           0 :     void forcedUpdate() {
      53           0 :         sender.send(values[address.getSelection()], address.getActiveAddress());
      54           0 :     }
      55             :     void forcedUpdate(setting_t bank) {
      56             :         sender.send(values[bank], address.getActiveAddress(bank));
      57             :     }
      58             : 
      59             :     /**
      60             :      * @brief   Get the absolute value of the encoder in the given bank.
      61             :      */
      62             :     uint16_t getValue(setting_t bank) const { return values[bank]; }
      63             :     /**
      64             :      * @brief   Get the absolute value of the encoder in the active bank.
      65             :      */
      66             :     uint16_t getValue() const { return getValue(address.getSelection()); }
      67             : 
      68             :     /**
      69             :      * @brief   Set the absolute value of the encoder in the given bank.
      70             :      */
      71             :     void setValue(uint16_t value, setting_t bank) { values[bank] = value; }
      72             :     /**
      73             :      * @brief   Set the absolute value of the encoder in the active bank.
      74             :      */
      75             :     void setValue(uint16_t value) { setValue(value, address.getSelection()); }
      76             : 
      77             :     /// Get the maximum possible value that can be returned by @ref getValue.
      78             :     static int16_t getMaxValue() { return maxValue; }
      79             : 
      80             :     void setSpeedMultiply(int16_t speedMultiply) {
      81             :         encstate.setSpeedMultiply(speedMultiply);
      82             :     }
      83             :     int16_t getSpeedMultiply() const { return encstate.getSpeedMultiply(); }
      84             : 
      85             :     int16_t resetPositionOffset() {
      86             :         auto encval = encoder.read();
      87             :         return encstate.update(encval);
      88             :     }
      89             : 
      90             :   protected:
      91             :     Enc encoder;
      92             :     BankAddress address;
      93             :     Array<int16_t, NumBanks> values = {{}};
      94             :     EncoderState<decltype(encoder.read())> encstate;
      95             : 
      96             :     constexpr static int16_t maxValue = uint16_t(1u << Sender::precision()) - 1;
      97             : 
      98             :   public:
      99             :     Sender sender;
     100             : };
     101             : 
     102             : template <uint8_t NumBanks, class BankAddress, class Sender>
     103             : using MIDIAbsoluteEncoder =
     104             :     GenericMIDIAbsoluteEncoder<AHEncoder, NumBanks, BankAddress, Sender>;
     105             : 
     106             : template <uint8_t NumBanks, class BankAddress, class Sender>
     107             : using BorrowedMIDIAbsoluteEncoder =
     108             :     GenericMIDIAbsoluteEncoder<AHEncoder &, NumBanks, BankAddress, Sender>;
     109             : 
     110             : } // namespace Bankable
     111             : 
     112             : END_CS_NAMESPACE