unit testing

lib/JC_Button/src/JC_Button.cpp

@@ -0,0 +1,100 @@
+// Arduino Button Library
+// https://github.com/JChristensen/JC_Button
+// Copyright (C) 2018 by Jack Christensen and licensed under
+// GNU GPL v3.0, https://www.gnu.org/licenses/gpl.html
+
+#include "JC_Button.h"
+
+/*----------------------------------------------------------------------*
+/ initialize a Button object and the pin it's connected to.             *
+/-----------------------------------------------------------------------*/
+void Button::begin()
+{
+    pinMode(m_pin, m_puEnable ? INPUT_PULLUP : INPUT);
+    m_state = digitalRead(m_pin);
+    if (m_invert) m_state = !m_state;
+    m_time = millis();
+    m_lastState = m_state;
+    m_changed = false;
+    m_lastChange = m_time;
+}
+
+/*----------------------------------------------------------------------*
+/ returns the state of the button, true if pressed, false if released.  *
+/ does debouncing, captures and maintains times, previous state, etc.   *
+/-----------------------------------------------------------------------*/
+bool Button::read()
+{
+    uint32_t ms = millis();
+    bool pinVal = digitalRead(m_pin);
+    if (m_invert) pinVal = !pinVal;
+    if (ms - m_lastChange < m_dbTime)
+    {
+        m_changed = false;
+    }
+    else
+    {
+        m_lastState = m_state;
+        m_state = pinVal;
+        m_changed = (m_state != m_lastState);
+        if (m_changed) m_lastChange = ms;
+    }
+    m_time = ms;
+    return m_state;
+}
+
+/*----------------------------------------------------------------------*
+ * isPressed() and isReleased() check the button state when it was last *
+ * read, and return false (0) or true (!=0) accordingly.                *
+ * These functions do not cause the button to be read.                  *
+ *----------------------------------------------------------------------*/
+bool Button::isPressed()
+{
+    return m_state;
+}
+
+bool Button::isReleased()
+{
+    return !m_state;
+}
+
+/*----------------------------------------------------------------------*
+ * wasPressed() and wasReleased() check the button state to see if it   *
+ * changed between the last two reads and return false (0) or           *
+ * true (!=0) accordingly.                                              *
+ * These functions do not cause the button to be read.                  *
+ *----------------------------------------------------------------------*/
+bool Button::wasPressed()
+{
+    return m_state && m_changed;
+}
+
+bool Button::wasReleased()
+{
+    return !m_state && m_changed;
+}
+
+/*----------------------------------------------------------------------*
+ * pressedFor(ms) and releasedFor(ms) check to see if the button is     *
+ * pressed (or released), and has been in that state for the specified  *
+ * time in milliseconds. Returns false (0) or true (!=0) accordingly.   *
+ * These functions do not cause the button to be read.                  *
+ *----------------------------------------------------------------------*/
+bool Button::pressedFor(uint32_t ms)
+{
+    return m_state && m_time - m_lastChange >= ms;
+}
+
+bool Button::releasedFor(uint32_t ms)
+{
+    return !m_state && m_time - m_lastChange >= ms;
+}
+
+/*----------------------------------------------------------------------*
+ * lastChange() returns the time the button last changed state,         *
+ * in milliseconds.                                                     *
+ *----------------------------------------------------------------------*/
+uint32_t Button::lastChange()
+{
+    return m_lastChange;
+}

lib/JC_Button/src/JC_Button.h

@@ -0,0 +1,111 @@
+// Arduino Button Library
+// https://github.com/JChristensen/JC_Button
+// Copyright (C) 2018 by Jack Christensen and licensed under
+// GNU GPL v3.0, https://www.gnu.org/licenses/gpl.html
+
+#ifndef JC_BUTTON_H_INCLUDED
+#define JC_BUTTON_H_INCLUDED
+
+#include <Arduino.h>
+
+class Button
+{
+    public:
+        // Button(pin, dbTime, puEnable, invert) instantiates a button object.
+        //
+        // Required parameter:
+        // pin      The Arduino pin the button is connected to
+        //
+        // Optional parameters:
+        // dbTime   Debounce time in milliseconds (default 25ms)
+        // puEnable true to enable the AVR internal pullup resistor (default true)
+        // invert   true to interpret a low logic level as pressed (default true)
+        Button(uint8_t pin, uint32_t dbTime=25, uint8_t puEnable=true, uint8_t invert=true)
+            : m_pin(pin), m_dbTime(dbTime), m_puEnable(puEnable), m_invert(invert) {}
+
+        // Initialize a Button object and the pin it's connected to
+        void begin();
+
+        // Returns the current debounced button state, true for pressed,
+        // false for released. Call this function frequently to ensure
+        // the sketch is responsive to user input.
+        bool read();
+
+        // Returns true if the button state was pressed at the last call to read().
+        // Does not cause the button to be read.
+        bool isPressed();
+
+        // Returns true if the button state was released at the last call to read().
+        // Does not cause the button to be read.
+        bool isReleased();
+
+        // Returns true if the button state at the last call to read() was pressed,
+        // and this was a change since the previous read.
+        bool wasPressed();
+
+        // Returns true if the button state at the last call to read() was released,
+        // and this was a change since the previous read.
+        bool wasReleased();
+
+        // Returns true if the button state at the last call to read() was pressed,
+        // and has been in that state for at least the given number of milliseconds.
+        bool pressedFor(uint32_t ms);
+
+        // Returns true if the button state at the last call to read() was released,
+        // and has been in that state for at least the given number of milliseconds.
+        bool releasedFor(uint32_t ms);
+
+        // Returns the time in milliseconds (from millis) that the button last
+        // changed state.
+        uint32_t lastChange();
+
+    private:
+        uint8_t m_pin;          // arduino pin number connected to button
+        uint32_t m_dbTime;      // debounce time (ms)
+        bool m_puEnable;        // internal pullup resistor enabled
+        bool m_invert;          // if true, interpret logic low as pressed, else interpret logic high as pressed
+        bool m_state;           // current button state, true=pressed
+        bool m_lastState;       // previous button state
+        bool m_changed;         // state changed since last read
+        uint32_t m_time;        // time of current state (ms from millis)
+        uint32_t m_lastChange;  // time of last state change (ms)
+};
+
+// a derived class for a "push-on, push-off" (toggle) type button.
+// initial state can be given, default is off (false).
+class ToggleButton : public Button
+{
+    public:
+    
+        // constructor is similar to Button, but includes the initial state for the toggle.
+        ToggleButton(uint8_t pin, bool initialState=false, uint32_t dbTime=25, uint8_t puEnable=true, uint8_t invert=true)
+            : Button(pin, dbTime, puEnable, invert), m_toggleState(initialState) {}
+
+        // read the button and return its state.
+        // should be called frequently.
+        bool read()
+        {
+            Button::read();
+            if (wasPressed())
+            {
+                m_toggleState = !m_toggleState;
+                m_changed = true;
+            }
+            else
+            {
+                m_changed = false;
+            }
+            return m_toggleState;
+        }
+
+        // has the state changed?
+        bool changed() {return m_changed;}
+
+        // return the current state
+        bool toggleState() {return m_toggleState;}
+
+    private:
+        bool m_toggleState;
+        bool m_changed;
+};
+#endif