/*
  * A demo app that calculates the ammount of time taken by the
  * AceButton::check() method. It acts like a stopwatch, supporting the following
  * operations:
  *
  * - press: start the stopwatch
  * - press: stop the stopwatch, printing out the result
  * - long press: reset the stopwatch, allowing press to start the process again
  *
  * Each 'long press' alternates between enableAllEvents() and disableAllEvents()
  * so that we can compare the timing of check() when all events are off (except
  * Pressed and Released) and when all events are on.
  */
 
 #include <AceButton.h>
 
 using namespace ace_button;
 
 // The pin number attached to the button.
 const uint8_t BUTTON_PIN = 2;
 
 // Create one button.
 AceButton button;
 
 // counters to determine the duration of a single call to AceButton::check()
 uint16_t innerLoopCounter = 0;
 uint16_t outerLoopCounter = 0;
 unsigned long startMillis = 0;
 unsigned long stopMillis  = 0;
 
 // states of the stopwatch
 const uint8_t STOPWATCH_INIT = 0;
 const uint8_t STOPWATCH_STARTED = 1;
 const uint8_t STOPWATCH_STOPPED = 2;
 
 // implements a finite state machine (FSM)
 uint8_t stopwatchState = STOPWATCH_INIT;
 
 bool allEventsEnabled = false;
 
 void handleEvent(AceButton*, uint8_t, uint8_t);
 
 void setup() {
   delay(1000); // some boards reboot twice
   Serial.begin(115200);
   while (! Serial); // Wait until Serial is ready - Leonardo/Micro
   Serial.println(F("setup(): begin"));
 
   // Button uses the built-in pull up register.
   pinMode(BUTTON_PIN, INPUT_PULLUP);
   button.init(BUTTON_PIN);
 
   // Configure the ButtonConfig with the event handler and enable LongPress.
   // SupressAfterLongPress is optional since we don't do anything if we get it.
   ButtonConfig* buttonConfig = button.getButtonConfig();
   buttonConfig->setEventHandler(handleEvent);
   buttonConfig->setFeature(ButtonConfig::kFeatureLongPress);
   buttonConfig->setLongPressDelay(2000);
 
   Serial.println(F("setup(): stopwatch ready"));
 }
 
 void loop() {
   // We split the loop into an inner loop and an outer loop. The inner loop
   // allows us to measure the speed of button.check() without the overhead of
   // the outer loop. However, we must allow the outer loop() method to return
   // periodically to allow the microcontroller to its own stuff. This is
   // especially true on an ESP8266 board, where a Watch Dog Timer will
   // soft-reset the board if loop() doesn't return every few seconds.
   do {
     // button.check() Should be called every 20ms or faster for the default
     // debouncing time of ~50ms.
     button.check();
 
     // increment loop counter
     if (stopwatchState == STOPWATCH_STARTED) {
       innerLoopCounter++;
     }
   } while (innerLoopCounter);
 
   // Each time the innerLoopCounter rolls over (65536), increment the outer loop
   // counter, and return from loop(), to prevent WDT errors on ESP8266.
   outerLoopCounter++;
 }
 
 // The event handler for the button.
 void handleEvent(AceButton* /* button */, uint8_t eventType,
     uint8_t /* buttonState */) {
   unsigned long now = millis();
   switch (eventType) {
     case AceButton::kEventPressed:
       if (stopwatchState == STOPWATCH_INIT) {
 
         // enable or disable higher level events, to get different performance
         // numbers
         if (allEventsEnabled) {
           enableAllEvents();
         } else {
           disableAllEvents();
         }
 
         Serial.println(F("handleEvent(): stopwatch started"));
         startMillis = now;
         innerLoopCounter = 0;
         outerLoopCounter = 0;
         stopwatchState = STOPWATCH_STARTED;
       } else if (stopwatchState == STOPWATCH_STARTED) {
         stopMillis = now;
         stopwatchState = STOPWATCH_STOPPED;
         unsigned long duration = stopMillis - startMillis;
         uint32_t loopCounter = ((uint32_t) outerLoopCounter << 16) +
             innerLoopCounter;
         float microsPerLoop = duration * 1000.0f / loopCounter;
 
         // reenable all events after stopping
         enableAllEvents();
 
         Serial.println(F("handleEvent(): stopwatch stopped"));
         Serial.print(F("handleEvent(): duration (ms): "));
         Serial.print(duration);
         Serial.print(F("; loopCount: "));
         Serial.print(loopCounter);
         Serial.print(F("; micros/loop: "));
         Serial.println(microsPerLoop);
 
         // Setting 0 allows the loop() function to return periodically.
         innerLoopCounter = 0;
       }
       break;
     case AceButton::kEventLongPressed:
       if (stopwatchState == STOPWATCH_STOPPED) {
         stopwatchState = STOPWATCH_INIT;
         Serial.println(F("handleEvent(): stopwatch reset"));
         allEventsEnabled = !allEventsEnabled;
       }
       break;
   }
 }
 
 void enableAllEvents() {
   Serial.println(F("enabling high level events"));
   button.getButtonConfig()->setFeature(ButtonConfig::kFeatureClick);
   button.getButtonConfig()->setFeature(ButtonConfig::kFeatureDoubleClick);
   button.getButtonConfig()->setFeature(ButtonConfig::kFeatureLongPress);
   button.getButtonConfig()->setFeature(ButtonConfig::kFeatureRepeatPress);
 }
 
 void disableAllEvents() {
   Serial.println(F("disabling high level events"));
   button.getButtonConfig()->clearFeature(ButtonConfig::kFeatureClick);
   button.getButtonConfig()->clearFeature(ButtonConfig::kFeatureDoubleClick);
   button.getButtonConfig()->clearFeature(ButtonConfig::kFeatureLongPress);
   button.getButtonConfig()->clearFeature(ButtonConfig::kFeatureRepeatPress);
 }

© 2023 acidvegas, inc • generated with stagit