Core classes and examples

Author: mikeaustin

Arduino/libraries/Nexus_OS/Nexus_OS.cpp

@@ -0,0 +1,15 @@
+//
+// Nexus_OS.cpp
+//
+
+//#include "Nexus_OS.h"
+
+#include "Nexus_OS/Nexus_Task.cpp"
+
+namespace Nexus {
+
+    class Scheduler Scheduler;
+
+    Event Message::None = Event(false);
+
+}

Arduino/libraries/Nexus_OS/Nexus_OS.h

@@ -0,0 +1,24 @@
+//
+// Nexus.h
+//
+
+#include <Arduino.h>
+
+#include "Nexus_OS/Nexus_Symbol.h"
+#include "Nexus_OS/Nexus_Message.h"
+#include "Nexus_OS/Nexus_Task.h"
+#include "Nexus_OS/Nexus_Scheduler.h"
+#include "Nexus_OS/Nexus_Terminal.h"
+
+namespace Nexus {
+
+    extern class Scheduler Scheduler;
+
+}
+
+/*
+
+9  Bytes
+19 Bytes    First 'new'
+
+*/

Arduino/libraries/Nexus_OS/Nexus_OS/Nexus_Message.h

@@ -0,0 +1,57 @@
+//
+// Message.h
+//
+
+namespace Nexus {
+
+    template<typename Type>
+    struct TypeInfo {
+
+        static void *GetType() { return reinterpret_cast<void *>(&GetType); }
+
+    };
+    
+    class Event {
+
+      public:
+
+        Event(bool valid = true) : _valid(valid) { }
+
+        operator bool() const
+        {
+            return _valid;
+        }
+
+        bool _valid;
+
+    };
+
+    class Message {
+
+      public:
+
+        static Event None;
+
+        template<typename DataType>
+        Message(const DataType& event) : _event(event), _type(TypeInfo<DataType>::GetType())
+        { }
+
+        template<typename DataType>
+        const DataType& get() const
+        {
+            if (TypeInfo<DataType>::GetType() == _type)
+            {
+                return static_cast<const DataType&>(_event);
+            }
+
+            return static_cast<const DataType&>(None);
+        }
+
+      private:
+
+        const Event&  _event;
+        const void   *_type;
+
+    };
+
+}

Arduino/libraries/Nexus_OS/Nexus_OS/Nexus_Scheduler.h

@@ -0,0 +1,99 @@
+//
+// Nexus_Scheduler.h
+//
+
+#ifndef __Nexus_Scheduler__
+#define __Nexus_Scheduler__
+
+namespace Nexus {
+
+    /**
+
+    Coordinates adding, removing and scheduling coros and tasks
+
+    */
+    
+    class Scheduler {
+
+      public:
+
+        void addCoro(Coro *coro)
+        {
+            coro->_next = _coros;
+
+            _coros = coro;
+        }
+
+        void addTask(Task *task)
+        {
+            task->_next = _tasks;
+
+            _tasks = task;
+        }
+
+        // void addTask(Task* newTask)
+        // {
+        //     Task* task = _tasks;
+
+        //     while (task == NULL)
+        //     {
+        //         task = task->getNext();
+        //     }
+
+        //     if (task)
+        //         task->_next = newTask;
+        //     else
+        //         _tasks = newTask;
+        // }
+
+        Task* getTasks() { return _tasks; }
+
+        void send(Task& task, const Message& message)
+        {
+            if (!task._sleep)
+            {
+                task._run(task, message);
+            }
+        }
+
+        void tick(uint32_t msecs)
+        {
+            for (Coro *prev = NULL, *coro = _coros; coro != NULL; coro = coro->getNext())
+            {
+                coro->_run(*coro, Message(Event()));
+            }
+
+            for (Task *prev = NULL, *task = _tasks; task != NULL; task = task->getNext())
+            {
+                if (msecs >= task->_timeout)
+                {
+                    //TimeoutEvent event;
+
+                    //task->run(Message(event));
+                    //send(*task, Message());
+                    task->_run(*task, Message(Event()));
+                }
+
+                if (task->_context == NULL)
+                {
+                    if (prev)
+                        prev->_next = task->_next;
+                    else
+                        _tasks = (Task *)task->_next;
+
+                    task = prev;
+                }
+                else prev = task;
+            }
+        }
+
+      private:
+
+        Coro *_coros;
+        Task *_tasks;
+
+    };
+
+}
+
+#endif

Arduino/libraries/Nexus_OS/Nexus_OS/Nexus_Symbol.h

@@ -0,0 +1,32 @@
+//
+// Symbol
+//
+
+#ifndef __Nexus_Symbol__
+#define __Nexus_Symbol__
+
+namespace Nexus {
+    
+    /**
+
+    Make Flash strings easier to work with and promote their use
+
+    */
+
+    class symbol {
+
+      public:
+
+        symbol(const __FlashStringHelper *string) :
+          _string(reinterpret_cast<const char *>(string))
+        { }
+
+      private:
+
+        const char *_string;
+
+    };
+
+}
+
+#endif

Arduino/libraries/Nexus_OS/Nexus_OS/Nexus_Task.cpp

@@ -0,0 +1,14 @@
+//
+// Nexus_Task.cpp
+//
+
+#include "../Nexus_OS.h"
+
+namespace Nexus {
+    
+    void Task::send(const Message& message)
+    {
+        Scheduler.send(*this, message);
+    }
+
+}

Arduino/libraries/Nexus_OS/Nexus_OS/Nexus_Task.h

@@ -0,0 +1,100 @@
+//
+// Nexus_Task.h
+//
+
+#ifndef __Nexus_Task__
+#define __Nexus_Task__
+
+#include <Arduino.h>
+#include <limits.h>
+
+#define MERGE_LINE(line) label_##line
+#define LABEL_LINE(line) MERGE_LINE(line)
+
+#define coro_enter   if (_context) goto *_context;
+#define coro_yield() _context = &&LABEL_LINE(__LINE__); return; LABEL_LINE(__LINE__):
+#define coro_exit    _context = NULL; return;
+
+#define task_enter        coro_enter
+#define task_sleep(msecs) _timeout = millis() + msecs; _sleep = true; coro_yield()
+#define task_yield()      _timeout = 0; _sleep = false; coro_yield()
+#define task_wait()       _timeout = LONG_MAX; _sleep = false; coro_yield()
+#define task_wait4(msecs)       _timeout = millis() + msecs; _sleep = false; coro_yield()
+#define task_exit         coro_exit
+
+namespace Nexus {
+
+    /**
+
+    Used by the scheduler to provide cooperative multi-threading
+
+    */
+
+    class Coro {
+
+      public:
+
+        friend class Scheduler;
+
+        typedef void (*TickFunc)(Coro& coro, const Message& message);
+
+        Coro(TickFunc run) : _run(run), _context(NULL), _next(NULL) { }
+
+        Coro* getNext() { return _next; }
+
+      protected:
+
+        TickFunc _run;
+
+        void *_context;
+        Coro *_next;
+
+    };
+
+    /**
+
+    Helper class to avoid virtual function vtable memory overhead
+
+    */
+
+    template<typename T>
+    struct TaskHelper {
+
+        static void run(Coro& task, const Message& message)
+        {
+            static_cast<T *>(&task)->run(message);
+        }
+
+    };
+
+    /**
+
+    A named coro that supports sleeping for a set amount of time
+
+    */
+
+    class Task : public Coro {
+
+      public:
+
+        friend class Scheduler;
+
+        Task(TickFunc run, symbol name) : Coro(run),
+          _name(name), _timeout(0), _sleep(false)
+        { }
+
+        void send(const Message& message);
+
+        Task* getNext() { return static_cast<Task*>(Coro::getNext()); }
+
+      protected:
+
+        const symbol _name;
+        uint32_t     _timeout : 31;
+        bool         _sleep : 1;
+
+    };
+
+}
+
+#endif