LCOV - code coverage report
Current view: top level - src/Selectors/LEDs - SelectorLEDs.hpp (source / functions) Hit Total Coverage
Test: 19d2efc7037c2e176feca44750a12594c76f466f Lines: 44 59 74.6 %
Date: 2019-11-24 14:50:27 Functions: 14 26 53.8 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.14-5-g4ff2ed6