/*
* Teensy's EventResponder example/demonstrator:
* using IntervalTimer objects to do work and trigger event responders.
*
* > Blinks the built-in LED every half second, and prints a messages every
* > second using the arduino-timer library.
*
* This is a demonstrator, so update the loop function to experience the behavior with delay vs a dummy while
* case #1: delay: it is going to work correctly:
* - every 500ms toggle LED
* - every 1 sec print message
* since delay uses the 'yield' function while it is waiting.
* case #2: dummy while: it does not work as one want (but it is expected like this; this is not a bug).
* In this case there is no yield function called.
* The Arduino 'main' function calls loop-function, and it calls 'yield' function before it calls again the loop function.
* Meaning there is a yield function called every 10 milliseconds.
* And that is what you can observe in this case #2.
* case #3: dummy while with extra yield() call
* Improves response time with multiple events triggered
*
*/
#include <EventResponder.h>
IntervalTimer timer500;
IntervalTimer timer1000;
EventResponder event500, event1000;
uint32_t isInISR(void) { return (SCB_ICSR & 0x1FF);} // 0 if in thread; vector number if in ISR
void printWhere(void)
{
uint32_t vec = isInISR();
if (0 == vec)
Serial.print("Foreground: ");
else
Serial.printf("Vector %d: ", vec);
}
//=============================================================================
// IntervalTimer callbacks: these are within Interrupt Service Routines,
// so MUST not delay, and really shouldn't print() as it could block. But
// this is just a demo, so we'll allow it.
volatile bool printLoop;
void
toggle_led(void)
{
digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN)); // toggle the LED
printWhere();
Serial.printf("toggle_led: called at: %d\n",millis());
event500.triggerEvent(500,(void*) "toggle");
printLoop = true;
}
void
print_message(void)
{
printWhere();
Serial.print("print_message: called at: ");
Serial.println(millis());
event1000.triggerEvent(1000,(void*) "print");
printLoop = true;
}
//=============================================================================
// EventResponder callback: called from yield(), so any normal calls are safe,
// although a long-running function could cause issues.
void
event_response(EventResponderRef event_responder)
{
int status = event_responder.getStatus();
char* data = (char*) event_responder.getData();
// do the thing!
printWhere();
Serial.printf("Event at %d from timer%d: data=%s\n", millis(), status, data);
}
//=============================================================================
void
setup()
{
Serial.begin(9600);
pinMode(LED_BUILTIN, OUTPUT); // set LED pin to OUTPUT
// add the function to the events
event500.attach(&event_response);
event1000.attach(&event_response);
// call the toggle_led function every 500 millis (half second)
timer500.begin(toggle_led, 500'000);
//delay(100); // uncomment to stop IntervalTimer callbacks overlapping
// call the print_message function every 1000 millis (1 second)
timer1000.begin(print_message, 1000'000);
}
//=============================================================================
int demoCase = 2; // select from various options in loop() below
void
loop()
{
Serial.print('.'); // one dot per actual loop iteration
switch (demoCase)
{
// case #1: delay
// This demonstrates that even if loop() is not allowed to return
// for a long time, so long as there are frequent calls to yield()
// (which delay() has built-in), event responses occur in a
// timely manner.
case 1:
delay(3000);
break;
// case #2: dummy while
// This is the "interesting" case, as only one event response will be
// processed per loop(), and we've set up the IntervalTimer
// callbacks to run simultaneously. The "losing" response gets
// delayed by an extra 10ms.
//
// The while() loop simulates e.g. a slow-ish SPI display update
case 2:
{
unsigned long stop, start = millis();
while (stop = millis(), stop-start < 10)
;
}
break;
// case #3: dummy while with extra yield
// Allows prompt event response during long operations,
// BUT requires attention from the sketch or library
// writer, so not ideal.
case 3:
{
unsigned long stop, start = millis();
for (int i=0;i<2;i++)
{
while (stop = millis(), stop-start < 5)
;
if (0 == i) // just one extra yield
yield();
start = millis();
}
}
break;
}
//-------------------------------------------------------------
// Print "Loop" at exit, if an IntervalTimer callback
// has occurred recently. Shorter IntervalTimer is set
// to 500ms, so this should print that often.
if (printLoop)
{
Serial.printf("\nLoop exit at %d\n",millis());
printLoop = false;
}
}
