Added:

  Button
  GarageControl
  Led
  List
  Relay
  Timer

Author: jonathan-meyer

Button.cpp

@@ -0,0 +1,144 @@
+#include "Button.h"
+
+Button::Button(uint8_t pin, uint8_t pressed_value, bool use_pullup) :
+    m_pin(pin),
+    m_pressed_is_high(pressed_value == HIGH),
+
+    m_debounce_t(0),
+    m_click_t(0),
+    m_dbl_click_t(0),
+    m_click_count(0),
+    m_last_read(false),
+    m_current_state(false),
+    m_held(false)
+{
+  memset(m_handler, 0, ButtonEvent_Count);
+
+  pinMode(m_pin, use_pullup ? INPUT_PULLUP : INPUT);
+}
+
+Button::~Button()
+{
+  pinMode(m_pin, OUTPUT);
+  digitalWrite(m_pin, LOW);
+}
+
+void Button::attach(ButtonEvent event, ButtonEventHandler handler)
+{
+  m_handler[event] = handler;
+}
+
+void Button::fire(ButtonEvent event)
+{
+  if (m_handler[event] != NULL)
+  {
+    m_handler[event](*this);
+  }
+}
+
+uint8_t Button::clicks() const
+{
+  return m_click_count;
+}
+
+void Button::run()
+{
+  // read the button
+  bool state = read();
+
+  // if latch up
+  if (state && !m_current_state)
+  {
+    m_current_state = state;
+    m_click_t = millis();
+
+    // trigger the pressed event
+    fire(bePressed);
+  }
+  else
+  // if latch down
+  if (!state && m_current_state)
+  {
+    m_current_state = state;
+    m_held = false;
+
+    // check to see if the button was pressed long enough
+    // to identify a click
+    if (millis() - m_click_t <= BUTTON_CLICK_TIMEOUT)
+    {
+      m_click_count++;
+      // trigger the click event
+      fire(beClick);
+
+      if (m_click_count == 1)
+      {
+        m_dbl_click_t = millis();
+      }
+      else if (m_click_count == 2)
+      {
+        m_click_count = 0;
+
+        if ((millis() - m_dbl_click_t) <= BUTTON_DOUBLE_CLICK_TIMEOUT)
+        {
+          // trigger the double click event
+          fire(beDblClick);
+        }
+      }
+    }
+    else
+    {
+      m_click_count = 0;
+    }
+
+    // trigger the released event
+    fire(beReleased);
+  }
+
+  if (m_current_state)
+  {
+    if (!m_held && ((millis() - m_click_t) > BUTTON_HELD_TIMEOUT))
+    {
+      m_held = true;
+      // trigger the held event
+      fire(beHeld);
+    }
+  }
+  else
+  {
+    if ((millis() - m_dbl_click_t) > BUTTON_DOUBLE_CLICK_TIMEOUT)
+    {
+      m_click_count = 0;
+    }
+  }
+}
+
+bool Button::read()
+{
+  // store the current state
+  bool state = m_current_state;
+
+  // read the button
+  bool current_read =
+      m_pressed_is_high ?
+          (digitalRead(m_pin) == HIGH) : (digitalRead(m_pin) == LOW);
+
+  // if the button state changed
+  if (current_read != m_last_read)
+  {
+    // reset the timer
+    m_debounce_t = millis();
+
+    // save the current read as the last read
+    m_last_read = current_read;
+  }
+
+  // if the timer has been running long enough
+  // set the actual state to the current state
+  if ((millis() - m_debounce_t) >= BUTTON_DEBOUNCE_DELAY)
+  {
+    // save the new state
+    state = m_last_read;
+  } // endif delay enough
+
+  return state;
+}

Button.h

@@ -0,0 +1,67 @@
+#ifndef __Button_h_
+#define __Button_h_
+
+#include "Arduino.h"
+
+// the amount of time required to identify a latch
+#define BUTTON_DEBOUNCE_DELAY 50
+
+// the max amount of time allowed to identify a click / double click
+#define BUTTON_CLICK_TIMEOUT 200
+#define BUTTON_DOUBLE_CLICK_TIMEOUT 500
+#define BUTTON_HELD_TIMEOUT 1000
+
+class Button;
+
+typedef void (*ButtonEventHandler)(Button & button);
+
+enum ButtonEvent
+{
+  bePressed, beReleased, beClick, beDblClick, beHeld, ButtonEvent_Count
+};
+
+class Button
+{
+public:
+  // CTOR: creates a button object
+  //    pin: the pin that the button is attached to
+  //    pressed_value: either HIGH or LOW; the value indicating the  (defaults to HIGH)
+  //                   button was pressed
+  Button(uint8_t pin, uint8_t pressed_value = HIGH, bool use_pullup = false);
+  ~Button();
+
+  // setup an event handler
+  void attach(ButtonEvent event, ButtonEventHandler handler);
+
+  // returns the number of clicks that have occurred
+  uint8_t clicks() const;
+
+  // returns the current state of the button accounting for debounce
+  bool read();
+
+  // reads the button and executes events as they occur
+  void run();
+
+private:
+
+  // executes an event
+  void fire(ButtonEvent event);
+
+  Button(const Button & rhs);
+  Button & operator=(const Button & rhs);
+
+  uint8_t m_pin;
+  bool m_pressed_is_high;
+
+  uint32_t m_debounce_t;
+  uint32_t m_click_t;
+  uint32_t m_dbl_click_t;
+  uint8_t m_click_count;
+  bool m_last_read;
+  bool m_current_state;
+  bool m_held;
+
+  ButtonEventHandler m_handler[ButtonEvent_Count];
+};
+
+#endif // __Button_h_

GarageControl.h

@@ -0,0 +1,108 @@
+#ifndef __GarageControl_h_
+#define __GarageControl_h_
+
+#if ARDUINO >= 100
+ #include "Arduino.h"
+#else
+ #include "WProgram.h"
+#endif
+
+// This is the list of recognized commands. These can be commands that can either be sent or received. 
+// In order to receive, attach a callback function to these events
+enum GC
+{
+  GC_Acknowledge,     // 0
+  GC_Error,           // 1
+  GC_Temperature,     // 2
+  GC_DoorStatus,      // 3
+  GC_PushButton,      // 4
+  GC_CloseDoor,       // 5
+  GC_OpenDoor,        // 6
+  GC_GetTemperature,  // 7
+  GC_GetDoorStatus,   // 8
+};
+
+enum DS
+{
+  DS_Unknown, // 0
+  DS_Open,    // 1
+  DS_Opening, // 2
+  DS_Closed,  // 3
+  DS_Closing  // 4
+};
+
+struct Response
+{
+  GC code;
+  uint32_t value;
+};
+
+String toString(DS door)
+{
+  switch( door )
+  {
+    case DS_Unknown:
+      return "Unknown";
+    case DS_Open:
+      return "Open";
+    case DS_Opening:
+      return "Opening";
+    case DS_Closed:
+      return "Closed";
+    case DS_Closing:
+      return "Closing";
+  }
+  
+  return "??";
+}
+
+Print & operator<<(Print & ps, GC e)
+{
+  switch( e )
+  {
+    case GC_Acknowledge:
+      ps.print("GC_Acknowledge");
+    break;
+
+    case GC_Error:
+      ps.print("GC_Error");
+    break;
+   
+    case GC_GetTemperature:
+      ps.print("GC_GetTemperature");
+    break;
+    
+    case GC_Temperature:
+      ps.print("GC_Temperature");
+    break;
+
+    case GC_GetDoorStatus:
+      ps.print("GC_GetDoorStatus");
+    break;
+    
+    case GC_DoorStatus:
+      ps.print("GC_DoorStatus");
+    break;
+
+    default:
+      ps.print("??");
+  }
+  
+  ps.print(" (");
+  ps.print(e);
+  ps.print(")");
+  
+  return ps;
+}
+
+Print & operator<<(Print & ps, const Response & r)
+{
+  ps.print("code: ");
+  ps << r.code;
+  ps.print("; value: ");
+  ps.print(r.value);
+  
+  return ps;
+}
+
+#endif // __GarageControl_h_