#21 fix to try and work with new Arduino core API, move all interrupt handling into base package. IN PROGRESS

Author: davetcc

examples/marshalInterrupt/marshalInterrupt.ino

@@ -10,26 +10,30 @@
  */
 
 #include <TaskManagerIO.h>
+#include <BasicInterruptAbstraction.h>
 
 // choose any pin on your board to register an interrupt against.
 const int interruptPin = 2;
 
 // now we create an InterruptAbstraction, for this example we use the simple inbuilt ArduinoInterruptExample, but you
 // can also use any IoAbstractionRef from IoAbstraction library too.
-ArduinoInterruptAbstraction interruptAbstraction;
+BasicArduinoInterruptAbstraction interruptAbstraction;
 
 //
 // Here we register the interrupt handler task, it will not be called in an ISR, so it's safe to call most functions
 // apart from delay here.
 //
-void interruptTask(pinid_t thePin) {
+void interruptTask(pintype_t thePin) {
     Serial.println("Interrupt triggered");
 }
 
 //
 // Here we set the interrupt task handler, and add the interrupt, the syntax is very similar to attachInterrupt.
 //
 void setup() {
+    Serial.begin(115200);
+    Serial.println("Starting interrupt example");
+
     taskManager.setInterruptCallback(interruptTask);
     taskManager.addInterrupt(&interruptAbstraction, interruptPin, CHANGE);
 }

examples/taskManagement/taskManagement.ino

@@ -15,7 +15,7 @@ Written by Dave Cherry of thecoderscorner.com in 2017
 
 #include <Arduino.h>
 #include <TaskManagerIO.h>
-#include "../../src/TaskManagerIO.h"
+#include <BasicInterruptAbstraction.h>
 
 // here we define an interrupt capable pin that will be varied in value during execution causing the
 // task manager interrupt handler to be executed. Task manager will marshal the interrupt back into 

src/BasicInterruptAbstraction.h

@@ -0,0 +1,35 @@
+//
+// Created by dave on 23/12/2020.
+//
+
+#ifndef TASKMANAGERIO_BASICINTERRUPTABSTRACTION_H
+#define TASKMANAGERIO_BASICINTERRUPTABSTRACTION_H
+
+#include <TaskPlatformDeps.h>
+#include <TaskManagerIO.h>
+
+#ifdef IOA_USE_ARDUINO
+
+inline void internalHandleInterrupt(pintype_t pin, RawIntHandler fn, uint8_t mode) {
+#if defined(ARDUINO_MBED_MODE) || (ARDUINO_API_VERSION >= 10200)
+    ::attachInterrupt(pin, fn, (PinStatus)mode);
+#elif defined(PARTICLE)
+    ::attachInterrupt(pin, fn, (InterruptMode)mode);
+#else
+    ::attachInterrupt(pin, fn, mode);
+#endif // Interrupt mode conditionals
+}
+
+/**
+ * For Arduino devices when NOT using IoAbstraction, this is the minimum possible implementation that can call
+ * through to the Arduino platform ::attachInterrupt call. You can pass a pointer to one of these to the task manager
+ * interrupt functions. If you are using IoAbstraction, all IoAbstractionRef's implement InterruptAbstraction.
+ */
+class BasicArduinoInterruptAbstraction : public InterruptAbstraction {
+    void attachInterrupt(pintype_t pin, RawIntHandler fn, uint8_t mode) override {
+        internalHandleInterrupt(pin, fn, mode);
+    }
+};
+#endif // IOA_USE_ARDUINO - Arduino Only
+
+#endif //TASKMANAGERIO_BASICINTERRUPTABSTRACTION_H

src/TaskManagerIO.h

@@ -70,25 +70,6 @@ class InterruptAbstraction {
     virtual void attachInterrupt(pintype_t pin, RawIntHandler fn, uint8_t mode) = 0;
 };
 
-#ifdef IOA_USE_ARDUINO
-/**
- * For Arduino devices when NOT using IoAbstraction, this is the minimum possible implementation that can call
- * through to the Arduino platform ::attachInterrupt call. You can pass a pointer to one of these to the task manager
- * interrupt functions. If you are using IoAbstraction, all IoAbstractionRef's implement InterruptAbstraction.
- */
-class BasicArduinoInterruptAbstraction : public InterruptAbstraction {
-    void attachInterrupt(pintype_t pin, RawIntHandler fn, uint8_t mode) override {
-#if defined(ARDUINO_MBED_MODE)
-        ::attachInterrupt(pin, fn, (PinStatus)mode);
-#elif defined(PARTICLE)
-        ::attachInterrupt(pin, fn, (InterruptMode)mode);
-#else
-        ::attachInterrupt(pin, fn, mode);
-#endif // ARDUINO_MBED_MODE
-    }
-};
-#endif // IOA_USE_ARDUINO - Arduino Only
-
 /**
  * TaskManager is a lightweight cooperative co-routine implementation for Arduino, it works by scheduling tasks to be
  * done either immediately, or at a future point in time. It is quite efficient at scheduling tasks as internally tasks