2 files changed, 124 insertions, 26 deletions

diff --git a/ButtonHandler/ButtonHandler.cpp b/ButtonHandler/ButtonHandler.cpp
index 23bcb02..edc9ea1 100644
--- a/ButtonHandler/ButtonHandler.cpp
+++ b/ButtonHandler/ButtonHandler.cpp
@@ -1,45 +1,136 @@
 #include "ButtonHandler.h"
 
+#define signal (int32_t)0xA0
+
+typedef enum {
+    b_none = 0,
+    b_sw1_fall,
+    b_sw1_rise,
+    b_sw2_fall,
+    b_sw2_rise
+} InternalButtonEvent;
+
+InternalButtonEvent event = b_none;
+bool check_sw1 = false;
+
+void b_worker(void const* argument) {
+    ButtonHandler* b = (ButtonHandler*)argument;
+    osEvent e;
+
+    while (true) {
+        e = Thread::signal_wait(signal, 250);
+        if (e.status == osEventSignal) {
+            switch (event) {
+                case b_sw1_fall:
+                    if (! b->_sw1_running) {
+                        check_sw1 = true;
+                        b->_sw1_running = true;
+                        b->_sw1_timer.reset();
+                        b->_sw1_timer.start();
+                    }
+                    break;
+                
+                case b_sw1_rise:
+                    if (b->_sw1_running) {
+                        check_sw1 = false;
+                        b->_sw1_running = false;
+                        b->_sw1_timer.stop();
+                        b->_sw1_time = b->_sw1_timer.read_ms();
+
+                        if (b->_sw1_time > b->_debounce_time) {
+                            b->_event = ButtonHandler::sw1_press;
+                            osSignalSet(b->_main, buttonSignal);
+                        }
+                    }
+                    break;
+
+                case b_sw2_fall:
+                    if (! b->_sw2_running) {
+                        b->_sw2_running = true;
+                        b->_sw2_timer.reset();
+                        b->_sw2_timer.start();
+                    }
+                    break;
+
+                case b_sw2_rise:
+                    if (b->_sw2_running) {
+                        b->_sw2_running = false;
+                        b->_sw2_timer.stop();
+                        b->_sw2_time = b->_sw2_timer.read_ms();
+
+                        if (b->_sw2_time > b->_debounce_time) {
+                            b->_event = ButtonHandler::sw2_press;
+                            osSignalSet(b->_main, buttonSignal);
+                        }
+                    }
+                    break;
+
+                default:
+                    break;
+            }
+        }
+
+        if (check_sw1) {
+            if (b->_sw1_timer.read_ms() > b->_hold_threshold) {
+                check_sw1 = false;
+                b->_sw1_running = false;
+                b->_sw1_timer.stop();
+                b->_event = ButtonHandler::sw1_hold;
+                osSignalSet(b->_main, buttonSignal);
+            }
+        }
+    }
+}
+
 ButtonHandler::ButtonHandler(osThreadId main)
   : _main(main),
+    _thread(b_worker, (void*)this),
     _sw1(PA_12),
     _sw2(PA_11),
     _sw1_time(0),
-    _event(none)
+    _sw2_time(0),
+    _event(none),
+    _debounce_time(20),
+    _hold_threshold(500)
 {
-    // gpio goes low when push button is pressed
-    // fall handler will be the press, rise handler will be the release
+    // fall handler called on press, rise handler called on release
     _sw1.fall(this, &ButtonHandler::sw1_fall);
     _sw1.rise(this, &ButtonHandler::sw1_rise);
     // need to set mode to PullUp after attaching handlers - won't work otherwise
     _sw1.mode(PullUp);
 
     _sw2.fall(this, &ButtonHandler::sw2_fall);
+    _sw2.rise(this, &ButtonHandler::sw2_rise);
     _sw2.mode(PullUp);
 }
 
-ButtonEvent ButtonHandler::getButtonEvent() {
+ButtonHandler::ButtonEvent ButtonHandler::getButtonEvent() {
     ButtonEvent event = _event;
     _event = none;
     return event;
 }
 
-void ButtonHandler::sw1_rise() {
-    _sw1_timer.stop();
-    _sw1_time = _sw1_timer.read_ms();
-
-    if (_sw1_time > 10) {
-        _event = (_sw1_time > 500) ? sw1_hold : sw1_press;
-        osSignalSet(_main, buttonSignal);
-    }
+void ButtonHandler::sw1_fall() {
+    event = b_sw1_fall;
+    _thread.signal_set(signal);
+    _thread.signal_clr(signal);
 }
 
-void ButtonHandler::sw1_fall() {
-    _sw1_timer.reset();
-    _sw1_timer.start();
+void ButtonHandler::sw1_rise() {
+    event = b_sw1_rise;
+    _thread.signal_set(signal);
+    _thread.signal_clr(signal);
 }
 
 void ButtonHandler::sw2_fall() {
-    _event = sw2_press;
-    osSignalSet(_main, buttonSignal);
+    event = b_sw2_fall;
+    _thread.signal_set(signal);
+    _thread.signal_clr(signal);
 }
+
+void ButtonHandler::sw2_rise() {
+    event = b_sw2_rise;
+    _thread.signal_set(signal);
+    _thread.signal_clr(signal);
+}
+
diff --git a/ButtonHandler/ButtonHandler.h b/ButtonHandler/ButtonHandler.h
index 3eb8298..e99c767 100644
--- a/ButtonHandler/ButtonHandler.h
+++ b/ButtonHandler/ButtonHandler.h
@@ -4,33 +4,40 @@
 #include "mbed.h"
 #include "rtos.h"
 
-#define buttonSignal (uint32_t)0x01
-
-typedef enum {
-    none = 0,
-    sw1_press,
-    sw1_hold,
-    sw2_press
-} ButtonEvent;
+#define buttonSignal (int32_t)0x01
 
 class ButtonHandler {
     public:
+        typedef enum {
+            none = 0,
+            sw1_press,
+            sw1_hold,
+            sw2_press
+        } ButtonEvent;
+
         ButtonHandler(osThreadId main);
         ~ButtonHandler();
 
         ButtonEvent getButtonEvent();
 
-    private:
         void sw1_fall();
         void sw1_rise();
         void sw2_fall();
+        void sw2_rise();
 
         osThreadId _main;
+        Thread _thread;
         InterruptIn _sw1;
         InterruptIn _sw2;
         Timer _sw1_timer;
+        Timer _sw2_timer;
         time_t _sw1_time;
+        time_t _sw2_time;
+        bool _sw1_running;
+        bool _sw2_running;
         ButtonEvent _event;
+        time_t _debounce_time;
+        time_t _hold_threshold;
 };
 
 #endif