fixes

src/concurrency/Lock.h

@@ -4,7 +4,9 @@
 
 namespace concurrency {
 
-// Simple wrapper around FreeRTOS API for implementing a mutex lock.
+/**
+ * @brief Simple wrapper around FreeRTOS API for implementing a mutex lock
+ */
 class Lock
 {
   public:

src/concurrency/LockGuard.h

@@ -4,7 +4,9 @@
 
 namespace concurrency {
 
-// RAII lock guard.
+/**
+ * @brief RAII lock guard
+ */
 class LockGuard
 {
   public:

src/concurrency/NotifiedWorkerThread.h

@@ -5,7 +5,7 @@
 namespace concurrency {
 
 /**
- * A worker thread that waits on a freertos notification
+ * @brief A worker thread that waits on a freertos notification
  */
 class NotifiedWorkerThread : public WorkerThread
 {

src/concurrency/Periodic.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "PeriodicTask.h"
+
+namespace concurrency {
+
+/**
+ * @brief Periodically invoke a callback. This just provides C-style callback conventions 
+ *        rather than a virtual function - FIXME, remove?
+ */
+class Periodic : public PeriodicTask
+{
+    uint32_t (*callback)();
+
+  public:
+    // callback returns the period for the next callback invocation (or 0 if we should no longer be called)
+    Periodic(uint32_t (*_callback)()) : callback(_callback) {}
+
+  protected:
+    void doTask() {
+        uint32_t p = callback();
+        setPeriod(p);
+    }
+};
+
+} // namespace concurrency

src/concurrency/PeriodicScheduler.cpp

@@ -0,0 +1,35 @@
+#include "PeriodicScheduler.h"
+#include "PeriodicTask.h"
+#include "LockGuard.h"
+#include "../time.h"
+
+namespace concurrency {
+
+/// call this from loop
+void PeriodicScheduler::loop()
+{
+    LockGuard lg(&lock);
+
+    uint32_t now = time::millis();
+    for (auto t : tasks) {
+        if (t->period && (now - t->lastMsec) >= t->period) {
+
+            t->doTask();
+            t->lastMsec = now;
+        }
+    }
+}
+
+void PeriodicScheduler::schedule(PeriodicTask *t)
+{
+    LockGuard lg(&lock);
+    tasks.insert(t);
+}
+
+void PeriodicScheduler::unschedule(PeriodicTask *t)
+{
+    LockGuard lg(&lock);
+    tasks.erase(t);
+}
+
+} // namespace concurrency

src/concurrency/PeriodicScheduler.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "Lock.h"
+#include <cstdint>
+#include <unordered_set>
+
+namespace concurrency {
+
+class PeriodicTask;
+
+/**
+ * @brief Runs all PeriodicTasks in the system. Currently called from main loop() 
+ *        but eventually should be its own thread blocked on a freertos timer.
+ */
+class PeriodicScheduler
+{
+    friend class PeriodicTask;
+
+    /**
+     * This really should be some form of heap, and when the period gets changed on a task it should get
+     * rescheduled in that heap.  Currently it is just a dumb array and everytime we run loop() we check
+     * _every_ tasks.  If it was a heap we'd only have to check the first task.
+     */
+    std::unordered_set<PeriodicTask *> tasks;
+
+    // Protects the above variables.
+    Lock lock;
+
+  public:
+    /// Run any next tasks which are due for execution
+    void loop();
+
+  private:
+    void schedule(PeriodicTask *t);
+    void unschedule(PeriodicTask *t);
+};
+
+extern PeriodicScheduler periodicScheduler;
+
+} // namespace concurrency

src/concurrency/PeriodicTask.cpp

@@ -0,0 +1,16 @@
+#include "PeriodicTask.h"
+#include "Periodic.h"
+#include "LockGuard.h"
+
+namespace concurrency {
+
+PeriodicScheduler periodicScheduler;
+
+PeriodicTask::PeriodicTask(uint32_t initialPeriod) : period(initialPeriod) {}
+
+void PeriodicTask::setup()
+{
+    periodicScheduler.schedule(this);
+}
+
+} // namespace concurrency

src/concurrency/PeriodicTask.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "PeriodicScheduler.h"
+#include "../time.h"
+
+namespace concurrency {
+
+/**
+ * A base class for tasks that want their doTask() method invoked periodically
+ *
+ * FIXME: currently just syntatic sugar for polling in loop (you must call .loop), but eventually
+ * generalize with the freertos scheduler so we can save lots of power by having everything either in
+ * something like this or triggered off of an irq.
+ */
+class PeriodicTask
+{
+    friend class PeriodicScheduler;
+
+    uint32_t lastMsec = 0;
+    uint32_t period = 1; // call soon after creation
+
+  public:
+    virtual ~PeriodicTask() { periodicScheduler.unschedule(this); }
+
+    /**
+     * Constructor (will schedule with the global PeriodicScheduler)
+     */
+    PeriodicTask(uint32_t initialPeriod = 1);
+
+    /** MUST be be called once at startup (but after threading is running - i.e. not from a constructor)
+     */
+    void setup();
+
+    /**
+     * Set a new period in msecs (can be called from doTask or elsewhere and the scheduler will cope)
+     * While zero this task is disabled and will not run
+     */
+    void setPeriod(uint32_t p)
+    {
+        lastMsec = time::millis(); // reset starting from now
+        period = p;
+    }
+
+    uint32_t getPeriod() const { return period; }
+
+    /**
+     * Syntatic sugar for suspending tasks
+     */
+    void disable() { setPeriod(0); }
+
+  protected:
+    virtual void doTask() = 0;
+};
+
+} // namespace concurrency

src/concurrency/Thread.h

@@ -4,6 +4,9 @@
 
 namespace concurrency {
 
+/**
+ * @brief Base threading
+ */
 class Thread
 {
   protected:

src/concurrency/WorkerThread.h

@@ -5,11 +5,10 @@
 namespace concurrency {
 
 /**
- * This wraps threading (FreeRTOS for now) with a blocking API intended for efficiently converting onlyschool arduino loop() code.
+ * @brief This wraps threading (FreeRTOS for now) with a blocking API intended for efficiently converting 
+ *        old-school arduino loop() code. Use as a mixin base class for the classes you want to convert.
  *
- * Use as a mixin base class for the classes you want to convert.
- *
- * https://www.freertos.org/RTOS_Task_Notification_As_Mailbox.html
+ * @link https://www.freertos.org/RTOS_Task_Notification_As_Mailbox.html
  */
 class WorkerThread : public Thread
 {