[DO NOT MERGE] kurt/helios-RAII-wasm

Helios/Button.cpp

@@ -13,29 +13,26 @@
 
 #include "Helios.h"
 
-// static members of Button
-uint32_t Button::m_pressTime = 0;
-uint32_t Button::m_releaseTime = 0;
-uint32_t Button::m_holdDuration = 0;
-uint32_t Button::m_releaseDuration = 0;
-uint8_t Button::m_releaseCount = 0;
-bool Button::m_buttonState = false;
-bool Button::m_newPress = false;
-bool Button::m_newRelease = false;
-bool Button::m_isPressed = false;
-bool Button::m_shortClick = false;
-bool Button::m_longClick = false;
-bool Button::m_holdClick = false;
-
+Button::Button(Helios &helios) :
+  m_pressTime(0),
+  m_releaseTime(0),
+  m_holdDuration(0),
+  m_releaseDuration(0),
+  m_releaseCount(0),
+  m_buttonState(false),
+  m_newPress(false),
+  m_newRelease(false),
+  m_isPressed(false),
+  m_shortClick(false),
+  m_longClick(false),
+  m_holdClick(false),
 #ifdef HELIOS_CLI
-// an input queue for the button, each tick one even is processed
-// out of this queue and used to produce input
-std::queue<char> Button::m_inputQueue;
-// the virtual pin state
-bool Button::m_pinState = false;
-// whether the button is waiting to wake the device
-bool Button::m_enableWake = false;
+  m_pinState(false),
+  m_enableWake(false),
 #endif
+  m_helios(helios)
+{
+}
 
 // initialize a new button object with a pin number
 bool Button::init()
@@ -85,6 +82,7 @@ void Button::enableWake()
 ISR(PCINT0_vect) {
   PCMSK &= ~(1 << PCINT3);
   GIMSK &= ~(1 << PCIE);
+  helios.wakeup();
 }
 #endif
 
@@ -100,7 +98,7 @@ bool Button::check()
 #elif defined(HELIOS_CLI)
   // then just return the pin state as-is, the input event may have
   // adjusted this value
-  return m_pinState;
+  return m_helios.callbacks().checkPinHook(m_pinState);
 #endif
 }
 
@@ -129,15 +127,15 @@ void Button::update()
     m_buttonState = newButtonState;
     m_isPressed = m_buttonState;
     if (m_isPressed) {
-      m_pressTime = Time::getCurtime();
+      m_pressTime = m_helios.time().getCurtime();
       m_newPress = true;
     } else {
-      m_releaseTime = Time::getCurtime();
+      m_releaseTime = m_helios.time().getCurtime();
       m_newRelease = true;
       m_releaseCount++;
     }
   }
-  const uint32_t curtime = Time::getCurtime();
+  const uint32_t curtime = m_helios.time().getCurtime();
   if (m_isPressed) {
     m_holdDuration = (curtime >= m_pressTime) ? (uint32_t)(curtime - m_pressTime) : 0;
   } else {
@@ -156,7 +154,7 @@ void Button::update()
 
   if (m_enableWake) {
     if (m_isPressed || m_shortClick || m_longClick) {
-      Helios::wakeup();
+      m_helios.wakeup();
     }
   }
 #endif
@@ -180,7 +178,7 @@ bool Button::processPreInput()
     doToggle();
     break;
   case 'q': // quit
-    Helios::terminate();
+    m_helios.terminate();
     break;
   case 'w': // wait
     // wait is pre input I guess
@@ -222,7 +220,7 @@ void Button::doShortClick()
 {
   m_newRelease = true;
   m_shortClick = true;
-  m_pressTime = Time::getCurtime();
+  m_pressTime = m_helios.time().getCurtime();
   m_holdDuration = SHORT_CLICK_THRESHOLD - 1;
   m_releaseCount++;
 }
@@ -231,7 +229,7 @@ void Button::doLongClick()
 {
   m_newRelease = true;
   m_longClick = true;
-  m_pressTime = Time::getCurtime();
+  m_pressTime = m_helios.time().getCurtime();
   m_holdDuration = SHORT_CLICK_THRESHOLD + 1;
   m_releaseCount++;
 }
@@ -240,7 +238,7 @@ void Button::doHoldClick()
 {
   m_newRelease = true;
   m_holdClick = true;
-  m_pressTime = Time::getCurtime();
+  m_pressTime = m_helios.time().getCurtime();
   m_holdDuration = HOLD_CLICK_START + 1;
   m_releaseCount++;
 }
@@ -268,11 +266,8 @@ void Button::queueInput(char input)
   m_inputQueue.push(input);
 }
 
-uint32_t Button::inputQueueSize()
+uint32_t Button::inputQueueSize() const
 {
   return m_inputQueue.size();
 }
 #endif
-
-// global button
-Button button;

Helios/Button.h

@@ -7,48 +7,51 @@
 #include <queue>
 #endif
 
+class Helios;
+
 class Button
 {
 public:
+  explicit Button(Helios &helios);
   // initialize a new button object with a pin number
-  static bool init();
+  bool init();
   // directly poll the pin for whether it's pressed right now
-  static bool check();
+  bool check();
   // poll the button pin and update the state of the button object
-  static void update();
+  void update();
 
   // whether the button was pressed this tick
-  static bool onPress() { return m_newPress; }
+  bool onPress() const { return m_newPress; }
   // whether the button was released this tick
-  static bool onRelease() { return m_newRelease; }
+  bool onRelease() const { return m_newRelease; }
   // whether the button is currently pressed
-  static bool isPressed() { return m_isPressed; }
+  bool isPressed() const { return m_isPressed; }
 
   // whether the button was shortclicked this tick
-  static bool onShortClick() { return m_shortClick; }
+  bool onShortClick() const { return m_shortClick; }
   // whether the button was long clicked this tick
-  static bool onLongClick() { return m_longClick; }
+  bool onLongClick() const { return m_longClick; }
   // whether the button was hold clicked this tick
-  static bool onHoldClick() { return m_holdClick; }
+  bool onHoldClick() const { return m_holdClick; }
 
   // detect if the button is being held past long click
-  static bool holdPressing();
+  bool holdPressing();
 
   // when the button was last pressed
-  static uint32_t pressTime() { return m_pressTime; }
+  uint32_t pressTime() const { return m_pressTime; }
   // when the button was last released
-  static uint32_t releaseTime() { return m_releaseTime; }
+  uint32_t releaseTime() const { return m_releaseTime; }
 
   // how long the button is currently or was last held down (in ticks)
-  static uint32_t holdDuration() { return m_holdDuration; }
+  uint32_t holdDuration() const { return m_holdDuration; }
   // how long the button is currently or was last released for (in ticks)
-  static uint32_t releaseDuration() { return m_releaseDuration; }
+  uint32_t releaseDuration() const { return m_releaseDuration; }
 
   // the number of releases
-  static uint8_t releaseCount() { return m_releaseCount; }
+  uint8_t releaseCount() const { return m_releaseCount; }
 
   // enable wake on press
-  static void enableWake();
+  void enableWake();
 
 #ifdef HELIOS_CLI
   // these will 'inject' a short/long click without actually touching the
@@ -58,67 +61,68 @@ class Button
   // will never trigger because the injected input event doesn't actually
   // press the button or change the button state it just sets the 'shortClick'
   // or 'longClick' values accordingly
-  static void doShortClick();
-  static void doLongClick();
-  static void doHoldClick();
+  void doShortClick();
+  void doLongClick();
+  void doHoldClick();
 
   // this will actually press down the button, it's your responsibility to wait
   // for the appropriate number of ticks and then release the button
-  static void doPress();
-  static void doRelease();
-  static void doToggle();
+  void doPress();
+  void doRelease();
+  void doToggle();
 
   // queue up an input event for the button
-  static void queueInput(char input);
-  static uint32_t inputQueueSize();
+  void queueInput(char input);
+  uint32_t inputQueueSize() const;
 #endif
 
 private:
   // ========================================
   // state data that is populated each check
 
   // the timestamp of when the button was pressed
-  static uint32_t m_pressTime;
+  uint32_t m_pressTime;
   // the timestamp of when the button was released
-  static uint32_t m_releaseTime;
+  uint32_t m_releaseTime;
 
   // the last hold duration
-  static uint32_t m_holdDuration;
+  uint32_t m_holdDuration;
   // the last release duration
-  static uint32_t m_releaseDuration;
+  uint32_t m_releaseDuration;
 
   // the number of times released, will overflow at 255
-  static uint8_t m_releaseCount;
+  uint8_t m_releaseCount;
 
   // the active state of the button
-  static bool m_buttonState;
+  bool m_buttonState;
 
   // whether pressed this tick
-  static bool m_newPress;
+  bool m_newPress;
   // whether released this tick
-  static bool m_newRelease;
+  bool m_newRelease;
   // whether currently pressed
-  static bool m_isPressed;
+  bool m_isPressed;
   // whether a short click occurred
-  static bool m_shortClick;
+  bool m_shortClick;
   // whether a long click occurred
-  static bool m_longClick;
+  bool m_longClick;
   // whether a long hold occurred
-  static bool m_holdClick;
+  bool m_holdClick;
 
 #ifdef HELIOS_CLI
   // process pre or post input events from the queue
-  static bool processPreInput();
-  static bool processPostInput();
+  bool processPreInput();
+  bool processPostInput();
 
   // an input queue for the button, each tick one even is processed
   // out of this queue and used to produce input
-  static std::queue<char> m_inputQueue;
+  std::queue<char> m_inputQueue;
   // the virtual pin state that is polled instead of a digital pin
-  static bool m_pinState;
+  bool m_pinState;
   // whether the button is waiting to wake the device
-  static bool m_enableWake;
+  bool m_enableWake;
 #endif
+  Helios &m_helios;
 };
 
 #endif // BUTTON_H