Line data    Source code

       1             : #pragma once
       2             : 
       3             : #include <AH/Hardware/ExtendedInputOutput/ExtendedInputOutput.hpp>
       4             : #include <Def/Def.hpp>
       5             : #include <Selectors/Selector.hpp>
       6             : 
       7             : BEGIN_CS_NAMESPACE
       8             : 
       9             : template <setting_t N>
      10             : class SelectorLEDsCallback {
      11             :   public:
      12           5 :     SelectorLEDsCallback(const PinList<N> &ledPins) : ledPins(ledPins) {}
      13             : 
      14             :     /// Initialize.
      15           0 :     void begin() {
      16           0 :         for (pin_t pin : ledPins) {
      17           0 :             AH::ExtIO::pinMode(pin, OUTPUT);
      18           0 :             AH::ExtIO::digitalWrite(pin, LOW);
      19             :         }
      20           0 :     }
      21             : 
      22             :     /// Refresh, called periodically.
      23           0 :     void update() {}
      24             : 
      25             :     /// Called when the setting changes.
      26           0 :     void update(setting_t oldSetting, setting_t newSetting) {
      27           0 :         AH::ExtIO::digitalWrite(ledPins[oldSetting], LOW);
      28           0 :         AH::ExtIO::digitalWrite(ledPins[newSetting], HIGH);
      29           0 :     }
      30             : 
      31             :   private:
      32             :     PinList<N> ledPins;
      33             : };
      34             : 
      35             : class SelectorSingleLEDCallback {
      36             :   public:
      37           1 :     SelectorSingleLEDCallback(pin_t ledPin) : ledPin(ledPin) {}
      38             : 
      39             :     /// Initialize.
      40           0 :     void begin() { AH::ExtIO::pinMode(ledPin, OUTPUT); }
      41             : 
      42             :     /// Refresh, called periodically.
      43           0 :     void update() {}
      44             : 
      45             :     /// Called when the setting changes.
      46           0 :     void update(setting_t oldSetting, setting_t newSetting) {
      47             :         (void)oldSetting;
      48           0 :         AH::ExtIO::digitalWrite(ledPin, newSetting == 0 ? LOW : HIGH);
      49           0 :     }
      50             : 
      51             :   private:
      52             :     pin_t ledPin;
      53             : };
      54             : 
      55             : END_CS_NAMESPACE
      56             : 
      57             : // -------------------------------------------------------------------------- //
      58             : 
      59             : #include <Selectors/EncoderSelector.hpp>
      60             : 
      61             : BEGIN_CS_NAMESPACE
      62             : 
      63             : /**
      64             :  * @brief   @copybrief EncoderSelector
      65             :  *          This version displays the setting using LEDs.
      66             :  * @details @copydetails EncoderSelector
      67             :  * @ingroup SelectorsLEDs
      68             :  */
      69             : template <setting_t N>
      70             : class EncoderSelectorLEDs
      71             :     : public GenericEncoderSelector<N, SelectorLEDsCallback<N>> {
      72             :   public:
      73           1 :     EncoderSelectorLEDs(Selectable<N> &selectable,
      74             :                         const EncoderSwitchPinList &pins,
      75             :                         const PinList<N> &ledPins, int8_t pulsesPerStep = 4,
      76             :                         Wrap wrap = Wrap::Wrap)
      77             :         : GenericEncoderSelector<N, SelectorLEDsCallback<N>> {
      78             :               selectable, {ledPins}, pins, pulsesPerStep, wrap,
      79           1 :           } {}
      80             : };
      81             : 
      82             : END_CS_NAMESPACE
      83             : 
      84             : // -------------------------------------------------------------------------- //
      85             : 
      86             : #include <Selectors/IncrementDecrementSelector.hpp>
      87             : 
      88             : BEGIN_CS_NAMESPACE
      89             : 
      90             : /**
      91             :  * @brief   @copybrief IncrementDecrementSelector
      92             :  *          This version displays the setting using LEDs.
      93             :  * @details @copydetails IncrementDecrementSelector
      94             :  * @ingroup SelectorsLEDs
      95             :  */
      96             : template <setting_t N>
      97             : class IncrementDecrementSelectorLEDs
      98             :     : public GenericIncrementDecrementSelector<N, SelectorLEDsCallback<N>> {
      99             :   public:
     100           1 :     IncrementDecrementSelectorLEDs(Selectable<N> &selectable,
     101             :                                    const AH::IncrementDecrementButtons &buttons,
     102             :                                    const PinList<N> &ledPins,
     103             :                                    Wrap wrap = Wrap::Wrap)
     104             :         : GenericIncrementDecrementSelector<N, SelectorLEDsCallback<N>> {
     105             :               selectable,
     106             :               {ledPins},
     107             :               buttons,
     108             :               wrap,
     109           1 :           } {}
     110             : };
     111             : 
     112             : END_CS_NAMESPACE
     113             : 
     114             : // -------------------------------------------------------------------------- //
     115             : 
     116             : #include <Selectors/IncrementSelector.hpp>
     117             : 
     118             : BEGIN_CS_NAMESPACE
     119             : 
     120             : /**
     121             :  * @brief   @copybrief IncrementSelector
     122             :  *          This version displays the setting using LEDs.
     123             :  * @details @copydetails IncrementSelector
     124             :  * @ingroup SelectorsLEDs
     125             :  */
     126             : template <setting_t N>
     127             : class IncrementSelectorLEDs
     128             :     : public GenericIncrementSelector<N, SelectorLEDsCallback<N>> {
     129             :   public:
     130           1 :     IncrementSelectorLEDs(Selectable<N> &selectable, const AH::Button &button,
     131             :                           const PinList<N> &ledPins)
     132             :         : GenericIncrementSelector<N, SelectorLEDsCallback<N>> {
     133           1 :               selectable, {ledPins}, button} {}
     134             : };
     135             : 
     136             : END_CS_NAMESPACE
     137             : 
     138             : // -------------------------------------------------------------------------- //
     139             : 
     140             : #include <Selectors/ManyButtonsSelector.hpp>
     141             : 
     142             : BEGIN_CS_NAMESPACE
     143             : 
     144             : /**
     145             :  * @brief   @copybrief ManyButtonsSelector
     146             :  *          This version displays the setting using LEDs.
     147             :  * @details @copydetails ManyButtonsSelector
     148             :  * @ingroup SelectorsLEDs
     149             :  */
     150             : template <setting_t N>
     151             : class ManyButtonsSelectorLEDs
     152             :     : public GenericManyButtonsSelector<N, SelectorLEDsCallback<N>> {
     153             :   public:
     154           1 :     ManyButtonsSelectorLEDs(Selectable<N> &selectable,
     155             :                             const PinList<N> &buttonPins,
     156             :                             const PinList<N> &ledPins)
     157             :         : GenericManyButtonsSelector<N, SelectorLEDsCallback<N>> {
     158             :               selectable,
     159             :               {ledPins},
     160             :               buttonPins,
     161           1 :           } {}
     162             : };
     163             : 
     164             : END_CS_NAMESPACE
     165             : 
     166             : // -------------------------------------------------------------------------- //
     167             : 
     168             : #include <Selectors/ProgramChangeSelector.hpp>
     169             : 
     170             : BEGIN_CS_NAMESPACE
     171             : 
     172             : /**
     173             :  * @brief   @copybrief ProgramChangeSelector
     174             :  *          This version displays the setting using LEDs.
     175             :  * @details @copydetails ProgramChangeSelector
     176             :  * @ingroup SelectorsLEDs
     177             :  */
     178             : template <setting_t N>
     179             : class ProgramChangeSelectorLEDs
     180             :     : public GenericProgramChangeSelector<N, SelectorLEDsCallback<N>> {
     181             :   public:
     182           1 :     ProgramChangeSelectorLEDs(Selectable<N> &selectable,
     183             :                               MIDIChannelCable address,
     184             :                               const PinList<N> &ledPins)
     185             :         : GenericProgramChangeSelector<N, SelectorLEDsCallback<N>> {
     186             :               selectable,
     187             :               {ledPins},
     188             :               address,
     189           1 :           } {}
     190             : };
     191             : 
     192             : END_CS_NAMESPACE
     193             : 
     194             : // -------------------------------------------------------------------------- //
     195             : 
     196             : #include <Selectors/SwitchSelector.hpp>
     197             : 
     198             : BEGIN_CS_NAMESPACE
     199             : 
     200             : /**
     201             :  * @brief   @copybrief SwitchSelector
     202             :  *          This version displays the setting using LEDs.
     203             :  * @details @copydetails SwitchSelector
     204             :  * @ingroup SelectorsLEDs
     205             :  */
     206             : class SwitchSelectorLED
     207             :     : public GenericSwitchSelector<SelectorSingleLEDCallback> {
     208             :   public:
     209           1 :     SwitchSelectorLED(Selectable<2> &selectable, const AH::Button &button,
     210             :                       pin_t ledPin)
     211           1 :         : GenericSwitchSelector<SelectorSingleLEDCallback> {
     212             :               selectable,
     213             :               {ledPin},
     214             :               button,
     215           1 :           } {}
     216             : };
     217             : 
     218             : END_CS_NAMESPACE