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             : #if defined(Encoder_h_) || defined(IDE)
      60             : #include <Selectors/EncoderSelector.hpp>
      61             : 
      62             : BEGIN_CS_NAMESPACE
      63             : 
      64             : /**
      65             :  * @brief   @copybrief EncoderSelector
      66             :  *          This version displays the setting using LEDs.
      67             :  * @details @copydetails EncoderSelector
      68             :  * @ingroup SelectorsLEDs
      69             :  */
      70             : template <setting_t N>
      71           1 : class EncoderSelectorLEDs
      72             :     : public GenericEncoderSelector<N, SelectorLEDsCallback<N>> {
      73             :   public:
      74           1 :     EncoderSelectorLEDs(Selectable<N> &selectable,
      75             :                         const EncoderSwitchPinList &pins,
      76             :                         const PinList<N> &ledPins, int8_t pulsesPerStep = 4,
      77             :                         Wrap wrap = Wrap::Wrap)
      78           1 :         : GenericEncoderSelector<N, SelectorLEDsCallback<N>>{
      79           1 :               selectable, {ledPins}, pins, pulsesPerStep, wrap,
      80           2 :           } {}
      81             : };
      82             : 
      83             : END_CS_NAMESPACE
      84             : #endif
      85             : 
      86             : // -------------------------------------------------------------------------- //
      87             : 
      88             : #include <Selectors/IncrementDecrementSelector.hpp>
      89             : 
      90             : BEGIN_CS_NAMESPACE
      91             : 
      92             : /**
      93             :  * @brief   @copybrief IncrementDecrementSelector
      94             :  *          This version displays the setting using LEDs.
      95             :  * @details @copydetails IncrementDecrementSelector
      96             :  * @ingroup SelectorsLEDs
      97             :  */
      98             : template <setting_t N>
      99           1 : class IncrementDecrementSelectorLEDs
     100             :     : public GenericIncrementDecrementSelector<N, SelectorLEDsCallback<N>> {
     101             :   public:
     102           1 :     IncrementDecrementSelectorLEDs(Selectable<N> &selectable,
     103             :                                    const AH::IncrementDecrementButtons &buttons,
     104             :                                    const PinList<N> &ledPins,
     105             :                                    Wrap wrap = Wrap::Wrap)
     106           1 :         : GenericIncrementDecrementSelector<N, SelectorLEDsCallback<N>>{
     107           1 :               selectable,
     108           1 :               {ledPins},
     109           1 :               buttons,
     110           1 :               wrap,
     111           2 :           } {}
     112             : };
     113             : 
     114             : END_CS_NAMESPACE
     115             : 
     116             : // -------------------------------------------------------------------------- //
     117             : 
     118             : #include <Selectors/IncrementSelector.hpp>
     119             : 
     120             : BEGIN_CS_NAMESPACE
     121             : 
     122             : /**
     123             :  * @brief   @copybrief IncrementSelector
     124             :  *          This version displays the setting using LEDs.
     125             :  * @details @copydetails IncrementSelector
     126             :  * @ingroup SelectorsLEDs
     127             :  */
     128             : template <setting_t N>
     129           1 : class IncrementSelectorLEDs
     130             :     : public GenericIncrementSelector<N, SelectorLEDsCallback<N>> {
     131             :   public:
     132           1 :     IncrementSelectorLEDs(Selectable<N> &selectable, const AH::Button &button,
     133             :                           const PinList<N> &ledPins, Wrap wrap = Wrap::Wrap)
     134           1 :         : GenericIncrementSelector<N, SelectorLEDsCallback<N>>{
     135           1 :               selectable,
     136           1 :               {ledPins},
     137           1 :               button,
     138           1 :               wrap,
     139           2 :           } {}
     140             : };
     141             : 
     142             : END_CS_NAMESPACE
     143             : 
     144             : // -------------------------------------------------------------------------- //
     145             : 
     146             : #include <Selectors/ManyButtonsSelector.hpp>
     147             : 
     148             : BEGIN_CS_NAMESPACE
     149             : 
     150             : /**
     151             :  * @brief   @copybrief ManyButtonsSelector
     152             :  *          This version displays the setting using LEDs.
     153             :  * @details @copydetails ManyButtonsSelector
     154             :  * @ingroup SelectorsLEDs
     155             :  */
     156             : template <setting_t N>
     157           1 : class ManyButtonsSelectorLEDs
     158             :     : public GenericManyButtonsSelector<N, SelectorLEDsCallback<N>> {
     159             :   public:
     160           1 :     ManyButtonsSelectorLEDs(Selectable<N> &selectable,
     161             :                             const PinList<N> &buttonPins,
     162             :                             const PinList<N> &ledPins)
     163           1 :         : GenericManyButtonsSelector<N, SelectorLEDsCallback<N>>{
     164           1 :               selectable,
     165           1 :               {ledPins},
     166           1 :               buttonPins,
     167           2 :           } {}
     168             : };
     169             : 
     170             : END_CS_NAMESPACE
     171             : 
     172             : // -------------------------------------------------------------------------- //
     173             : 
     174             : #include <Selectors/ProgramChangeSelector.hpp>
     175             : 
     176             : BEGIN_CS_NAMESPACE
     177             : 
     178             : /**
     179             :  * @brief   @copybrief ProgramChangeSelector
     180             :  *          This version displays the setting using LEDs.
     181             :  * @details @copydetails ProgramChangeSelector
     182             :  * @ingroup SelectorsLEDs
     183             :  */
     184             : template <setting_t N>
     185           1 : class ProgramChangeSelectorLEDs
     186             :     : public GenericProgramChangeSelector<N, SelectorLEDsCallback<N>> {
     187             :   public:
     188           1 :     ProgramChangeSelectorLEDs(Selectable<N> &selectable,
     189             :                               const MIDICNChannel &address,
     190             :                               const PinList<N> &ledPins)
     191           1 :         : GenericProgramChangeSelector<N, SelectorLEDsCallback<N>>{
     192           1 :               selectable,
     193           1 :               {ledPins},
     194           1 :               address,
     195           2 :           } {}
     196             : };
     197             : 
     198             : END_CS_NAMESPACE
     199             : 
     200             : // -------------------------------------------------------------------------- //
     201             : 
     202             : #include <Selectors/SwitchSelector.hpp>
     203             : 
     204             : BEGIN_CS_NAMESPACE
     205             : 
     206             : /**
     207             :  * @brief   @copybrief SwitchSelector
     208             :  *          This version displays the setting using LEDs.
     209             :  * @details @copydetails SwitchSelector
     210             :  * @ingroup SelectorsLEDs
     211             :  */
     212           1 : class SwitchSelectorLED
     213             :     : public GenericSwitchSelector<SelectorSingleLEDCallback> {
     214             :   public:
     215           1 :     SwitchSelectorLED(Selectable<2> &selectable, const AH::Button &button,
     216             :                       pin_t ledPin)
     217           1 :         : GenericSwitchSelector<SelectorSingleLEDCallback>{
     218           1 :               selectable,
     219           1 :               {ledPin},
     220           1 :               button,
     221           2 :           } {}
     222             : };
     223             : 
     224             : END_CS_NAMESPACE