Adding in user function scheduling

Author: finnkuusisto

Devlpr.cpp

@@ -6,26 +6,46 @@ Devlpr::Devlpr(int pin)
     emgPin = pin;
     emgRunningSum = 0;
     bufInd = BUFSIZE - 1;
+    numFuncs = 0;
 }
 
 void Devlpr::tick()
 {
     // check the current time
     unsigned long currMicros = micros();
     unsigned long microsDelta = currMicros - lastTickMicros;
-    // go through each function and see if we need to run it
+    //////////////////
+    // EMG Schedule //
+    //////////////////
     // accrue micros on the micros since last run
     microsSinceEMG += microsDelta;
-    // now see if enough time has passed to run this bad boy
+    // check if enough time has passed to read EMG
     if (microsSinceEMG > MICROS_SCHED_EMG) {
         readEMG();
         // and update micros since
         microsSinceEMG = 0;
-        // NOTE do we want to do some sort of remainder on
-        // NOTE the micros - ie do we want to play catch up
-        // NOTE or just make a best effort to run on sched?
+        // NOTE just a best effort to run on time
     }
-    // just pretend no time has passed since function start
+    ////////////////////////////
+    // User Function Schedule //
+    ////////////////////////////
+    // go through each function and check if it needs to run
+    for (byte i = 0; i < numFuncs; i++) {
+        // accrue micros on the micros since last run
+        microsSince[i] += microsDelta;
+        // check if enough time has passed to run it
+        if (microsSince[i] > schedMicros[i]) {
+            // run it
+            funcs[i](this);
+            // and update micros since
+            microsSince[i] = 0;
+            // NOTE just a best effort to run on time
+        }
+    }
+    ////////////////
+    // Wrap it up //
+    ////////////////
+    // pretend no time has passed since function start for best effort
     lastTickMicros = currMicros;
 }
 
@@ -46,6 +66,20 @@ int Devlpr::lastValueCentered()
     return lastVal - wAvg;
 }
 
+int Devlpr::scheduleFunction(void (*f)(Devlpr *d), unsigned int millisPer)
+{
+    // check first if we are out of space to attach more functions
+    if (numFuncs >= FUNCMAX) {
+        return -1;
+    }
+    // otherwise add it in
+    funcs[numFuncs] = f;
+    schedMicros[numFuncs] = millisPer * 1000L;
+    microsSince[numFuncs] = 0;
+    numFuncs++;
+    return (numFuncs - 1);
+}
+
 void Devlpr::readEMG()
 {
     // want bufInd to sit on the most recent value until tick

Devlpr.h

@@ -11,20 +11,28 @@ class Devlpr
         unsigned int lastValue();
         int lastValueCentered();
         unsigned int windowAvg();
+        int scheduleFunction(void (*f)(Devlpr *d), unsigned int millisPer);
     private:
-        // general buffer bookkeeping
-        static const byte BUFSIZE = 32; // power of 2 for integer avg calc
+        // emg buffer bookkeeping
+        static const byte BUFSIZE = 32; // power of 2 for fast integer avg calc
         unsigned int buf[BUFSIZE];
         byte bufInd;
-        // scheduling
-        unsigned long MICROS_SCHED_EMG = 1000;
-        unsigned long lastTickMicros = 0;
-        unsigned long microsSinceEMG = 0;
         // emg tracking
         int emgPin;
         unsigned int emgVal; // ATMEGA boards have 10-bit ADC (0-1023)
         unsigned int emgRunningSum; // if BUFSIZE is small, uint is fine
         void readEMG();
+        // scheduling
+        unsigned long lastTickMicros = 0;
+        // emg scheduling
+        static const unsigned long MICROS_SCHED_EMG = 1000;
+        unsigned long microsSinceEMG = 0;
+        // user function scheduling
+        static const byte FUNCMAX = 8;
+        void (*funcs[FUNCMAX])(Devlpr *d);
+        unsigned long schedMicros[FUNCMAX];
+        unsigned long microsSince[FUNCMAX];
+        byte numFuncs;
 };
 
 #endif

libdevlpr.ino

@@ -2,29 +2,19 @@
 
 Devlpr devlpr;
 
+void printEMG(Devlpr *d) {
+    int result = d->lastValueCentered();
+    Serial.println(result);
+}
+
 void setup() {
     Serial.begin(2000000);
+    // add our print function to our DEVLPR schedule
+    // try to run once every 1ms
+    devlpr.scheduleFunction(printEMG, 1);
 }
 
-unsigned long microsSincePrint = 0;
-unsigned long prevLoopMicros = 0;
-int result = 0;
 void loop() {
     // let the DEVLPR library do its job
     devlpr.tick();
-
-    // try to sample and print data at 1000Hz
-    unsigned long currMicros = micros();
-    unsigned long microsDelta = currMicros - prevLoopMicros;
-    microsSincePrint += microsDelta;
-    // has 1ms passed
-    if (microsSincePrint > 1000) {
-        // 1ms has passed, get the value
-        result = devlpr.lastValueCentered();
-        Serial.println(result);
-        // update our last filtered call
-        microsSincePrint = 0;
-    }
-    // update our last loop time
-    prevLoopMicros = currMicros;
 }