Merge branch 'debouncer' into 'master'

+debouncer.h

See merge request !19

Debouncer.h

+
+#pragma once
+
+#include <stdint.h>
+
+#ifndef DEBOUNCER_DEFAULT_DEBOUNCE_PUSH_MS
+#define DEBOUNCER_DEFAULT_DEBOUNCE_PUSH_MS    50    // debounce delay for push button
+#endif
+
+#ifndef DEBOUNCER_DEFAULT_DEBOUNCE_ROTARY_MS
+#define DEBOUNCER_DEFAULT_DEBOUNCE_ROTARY_MS  1     // debounce delay for rotary button
+#endif
+
+#ifndef DEBOUNCER_DEFAULT_SHORT_MS
+#define DEBOUNCER_DEFAULT_SHORT_MS            200   // max interval between multiple short clicks
+#endif
+
+#ifndef DEBOUNCER_DEFAULT_LONG_MS
+#define DEBOUNCER_DEFAULT_LONG_MS             400   // min interval for long click
+#endif
+
+#if defined(ESP8266) && !DEBOUNCER_WITH_MILLIS
+#pragma message "Debouncer: using esp_get_cycle_count"
+#define DEBOUNCER_DEFAULT_CYCLE_FUNC esp_get_cycle_count
+#define DEBOUNCER_DEFAULT_CYCLE_PER_MS (F_CPU / 1000)
+#else
+#if !defined(__AVR__)
+#pragma message "Debouncer: using millis"
+#endif
+#define DEBOUNCER_DEFAULT_CYCLE_FUNC millis
+#define DEBOUNCER_DEFAULT_CYCLE_PER_MS (1)
+#endif
+
+#if 0
+#define DEBUGBUTTON(x...)        do { Serial.print(cycle_f()); Serial.print(":"); x; } while (0)
+#else
+#define DEBUGBUTTON(x...)        do { } while (0)
+#endif
+
+#ifndef IRAM_ATTR
+#define IRAM_ATTR // nothing
+#endif
+
+///////////////////////////////////////////////////////////////
+
+/*
+    ButtonFast::
+        !enable_multi && !enable_long:
+            short click: response on click
+            no long click
+    
+    ButtonLong::
+        !enable_multi && enable_long:
+            short click: response on release + debounce time
+            long click: response on long click delay
+    
+    Debouncer<long_cycle=0>::
+        enable_multi && !enable_long:
+            short clicks number: response on final release + debounce time
+            no long click
+
+    Debouncer<true,≠0>:: (default)
+        enable_multi && enable_long:
+            short clicks number: reponse on final release + debounce time
+            long click: response on long click delay
+*/
+
+#if __GNUC__ <= 7
+
+#define __cycle_template_decl
+#define __cycle_template_args
+#define __cycle_template_impl
+#define cycle_f DEBOUNCER_DEFAULT_CYCLE_FUNC
+#define cyclePerMs DEBOUNCER_DEFAULT_CYCLE_PER_MS
+
+#else
+
+#define __cycle_template_decl \
+          auto cycle_f = DEBOUNCER_DEFAULT_CYCLE_FUNC, \
+          auto cyclePerMs = DEBOUNCER_DEFAULT_CYCLE_PER_MS, \
+
+#define __cycle_template_impl \
+        auto cycle_f, \
+        auto cyclePerMs, \
+
+#define __cycle_template_args \
+        cycle_f, \
+        cyclePerMs, \
+
+#endif
+
+template <const bool enable_multi = true,
+          __cycle_template_decl
+          const decltype(cycle_f()) long_cycle = DEBOUNCER_DEFAULT_LONG_MS * cyclePerMs, /* 0 to disable long press */
+          const decltype(cycle_f()) debounce_cycle = DEBOUNCER_DEFAULT_DEBOUNCE_PUSH_MS * cyclePerMs,
+          const decltype(cycle_f()) short_cycle = DEBOUNCER_DEFAULT_SHORT_MS * cyclePerMs>
+class Debouncer
+{
+protected:
+
+    using T = decltype(cycle_f());
+    
+    enum state_e
+    {
+        off,
+        on,
+        on_long,
+        on_debounce,
+        off_debounce,
+    };
+
+    state_e        state;
+    uint_fast8_t   short_count;
+    bool           long_state;
+    T              state_cycle;
+
+public:
+
+    Debouncer (): state(off), short_count(0), long_state(false), state_cycle(0)
+    {
+        DEBUGBUTTON(Serial.println(enable_multi));
+        DEBUGBUTTON(Serial.println(long_cycle));
+        DEBUGBUTTON(Serial.println(debounce_cycle));
+        DEBUGBUTTON(Serial.println(short_cycle));
+    }
+
+    // - must be called in the main loop or from interrupt
+    // - return true if a change has occured
+    bool update (bool pressed);
+
+    // simulate a long press
+    void simLongClick ()
+    {
+        long_state = true;
+    }
+    
+    // simulate n short presses
+    void simShortClick (uint_fast8_t n)
+    {
+        short_count += n;
+    }
+    
+    // returns long state, does not clear shorts
+    bool longState  ()
+    {
+        bool state = long_state;
+        long_state = false;
+        return state;
+    }
+
+    // returns short count, does not clear long
+    uint_fast8_t shortCount ()
+    {
+        auto count = short_count;
+        short_count = 0;
+        return count;
+    }
+
+    // returns long state and clears/ignore shorts
+    bool longClick  ()
+    {
+        return longState();
+    }
+
+    // returns short count and clears/ignore long
+    uint_fast8_t shortClick ()
+    {
+        return shortCount();
+    }
+
+    bool isOff () const
+    {
+        return state == off;
+    }
+
+    bool isLong ()
+    {
+        long_state = false;
+        return state == on_long;
+    }
+};
+
+///////////////////////////////////////////////////////////////
+
+template <__cycle_template_decl
+          const decltype(cycle_f()) debounce_cycle = DEBOUNCER_DEFAULT_DEBOUNCE_PUSH_MS * cyclePerMs,
+          const decltype(cycle_f()) short_cycle = DEBOUNCER_DEFAULT_SHORT_MS * cyclePerMs>
+class ButtonFast: public Debouncer</*no multi*/false, __cycle_template_args /*no long*/0, debounce_cycle, short_cycle>
+{
+public:
+    // multiclick disabled, longclick disabled
+    ButtonFast (): Debouncer<false, __cycle_template_args 0, debounce_cycle, short_cycle>() { }
+
+    bool pressed ()
+    {
+        using d = Debouncer<false, __cycle_template_args 0, debounce_cycle, short_cycle>;
+        return d::state == d::on_debounce || d::state == d::on;
+    }
+
+    bool longState () = delete;
+    uint_fast8_t shortCount () = delete;
+    bool longClick () = delete;
+    uint_fast8_t shortClick () = delete;
+};
+
+///////////////////////////////////////////////////////////////
+
+template <__cycle_template_decl
+          const decltype(cycle_f()) long_cycle = DEBOUNCER_DEFAULT_LONG_MS * cyclePerMs>
+class ButtonLong: public Debouncer</* no multi */false, __cycle_template_args long_cycle>
+{
+public:
+    ButtonLong (): Debouncer<false, __cycle_template_args long_cycle>() { }
+
+    bool pressed () { return Debouncer<false, __cycle_template_args long_cycle>::isLong(); }
+
+    bool longState () = delete;
+    uint_fast8_t shortCount () = delete;
+    bool longClick () = delete;
+    uint_fast8_t shortClick () = delete;
+};
+
+///////////////////////////////////////////////////////////////
+
+template <__cycle_template_decl
+          const decltype(cycle_f()) debounce_cycle = DEBOUNCER_DEFAULT_DEBOUNCE_ROTARY_MS * cyclePerMs>
+class Rotary
+{
+protected:
+    ButtonFast<__cycle_template_args debounce_cycle> b1, b2;
+    int_fast8_t rot;
+
+public:
+    Rotary (): b1(), b2(), rot(0) { }
+
+    bool update (bool in1, bool in2); // steady state with pullup: true, true
+    bool right  () { bool ret; if ((ret = (rot > 0))) --rot; return ret; }
+    bool left   () { bool ret; if ((ret = (rot < 0))) ++rot; return ret; }
+};
+
+///////////////////////////////////////////////////////////////
+
+template <const bool enable_multi,
+          __cycle_template_impl
+          const decltype(cycle_f()) long_cycle,
+          const decltype(cycle_f()) debounce_cycle,
+          const decltype(cycle_f()) short_cycle>
+IRAM_ATTR // can be called from ISR
+bool Debouncer<enable_multi, __cycle_template_args long_cycle, debounce_cycle, short_cycle>::update (bool pressed)
+{
+    // get current time
+    auto cycle = cycle_f();
+
+    switch (state)
+    {
+    case off:
+        if (pressed)
+        {
+            // button is off, and now pressed
+            DEBUGBUTTON(Serial.println("off->on_debounce"));
+            state_cycle = cycle;
+            if (!enable_multi && /*long press disabled*/(long_cycle == 0))
+            {
+                bool ret = state != on_debounce;
+                state = on_debounce;
+                return ret; // true on first change
+            }
+            state = on_debounce;
+        }
+        break; // off, no change, return unreaded state
+    
+    case on_long:
+        if (pressed)
+            return false; // no change
+        DEBUGBUTTON(Serial.println("on_long->off_debounce"));
+        state = off_debounce;
+        state_cycle = cycle;
+        return !enable_multi;
+
+    case on_debounce:
+        if ((cycle - state_cycle) < debounce_cycle)
+        {
+            // don't care before debounce delay
+            DEBUGBUTTON(Serial.println("debounce-on"));
+            return false;
+        }
+        DEBUGBUTTON(Serial.println("on_debounce->on"));
+        state = on;
+        // fall through
+    case on:
+        if (/*long press enabled*/(long_cycle > 0) && (cycle - state_cycle) > long_cycle)
+        {
+            // long press in progress
+            DEBUGBUTTON(Serial.println("on->on_long"));
+            state = on_long;
+            long_state = true;
+            return true;
+        }
+        if (!pressed)
+        {
+            // off after debounce delay
+            DEBUGBUTTON(Serial.println("on->off_debounce"));
+            state = off_debounce;
+            state_cycle = cycle;
+            if (!enable_multi)
+                // single press is released
+                return true;
+            // it was a short click
+            short_count++;
+            return !enable_multi && /*long press enabled*/(long_cycle > 0);
+        }
+        return false; // no change
+    
+    case off_debounce:
+        if ((cycle - state_cycle) < debounce_cycle)
+        {
+            // don't care before debounce delay
+            DEBUGBUTTON(Serial.println("debounce-off"));
+            return false;
+        }
+        if (pressed)
+        {
+            // multiclick in progress
+            DEBUGBUTTON(Serial.println("off_debounce->on_debounce"));
+            state = on_debounce;
+            state_cycle = cycle;
+            return false;
+        }
+        if (enable_multi && (cycle - state_cycle) < short_cycle)
+        {
+            // wait for multiclick
+            DEBUGBUTTON(Serial.println("(multiclick?)"));
+            return false;
+        }
+        // released for good
+        DEBUGBUTTON(Serial.println("off_debounce->off"));
+        state = off;
+        break;
+    }
+
+    return short_count || long_state;
+}
+
+///////////////////////////////////////////////////////////////
+
+template <__cycle_template_impl
+          const decltype(cycle_f()) debounce_cycle>
+bool Rotary<__cycle_template_args debounce_cycle>::update (bool pressed1, bool pressed2)
+{
+    bool b1u = b1.update(pressed1);
+    bool b2u = b2.update(pressed2);
+    if (b1u && b2.isOff() && b1.pressed())
+    {
+        rot++;
+        return true;
+    }
+    if (b2u && b1.isOff() && b2.pressed())
+    {
+        rot--;
+        return true;
+    }
+    return false;
+}
+
+///////////////////////////////////////////////////////////////