V1.7.02 - Updates

- Switched Mega and Uno to interrupt-driven stepper motor driving.
- Added Unpark command to GO menu.

Author: ClutchplateDude

Software/Arduino code/OpenAstroTracker/InterruptCallback.cpp

@@ -0,0 +1,81 @@
+#include "InterruptCallback.h"
+#include "Utility.h"
+
+//////////////////////////////////////
+// This is an hardware-independent abstraction layer over
+// whatever timer is used for the hardware being run
+//////////////////////////////////////
+
+// NOTE: ESP8266 support is not complete and does not work. This code is never called.
+#ifdef ESP8266
+  #include "Timers/ESP8266TimerInterrupt.h"
+#elif defined __AVR_ATmega328P__ || defined __AVR_ATmega2560__   // Arduino Uno or Mega
+  #define USE_TIMER_1     true
+  #define USE_TIMER_2     true
+  #define USE_TIMER_3     false
+  #define USE_TIMER_4     false
+  #define USE_TIMER_5     false
+  #include "Timers/TimerInterrupt.h"
+#else
+  // Need to add support for ESP32 boards here
+
+  #error Only Arduino Uno, Mega and ESP8266 boards currently supported.
+#endif
+
+#ifdef ESP8266
+ESP8266Timer interruptHandler;
+
+void* actualPayload = NULL;
+volatile interrupt_callback_p actualCallback = NULL;
+
+// This timer only supports a callback with no payload
+void ICACHE_RAM_ATTR esp8266callback(void)
+{
+  if (actualCallback != NULL) {
+    (*actualCallback)(actualPayload);
+  }
+}
+
+bool InterruptCallback::setInterval(float intervalMs, interrupt_callback_p callback, void* payload)
+{
+  // Since this timer only supports a callback with no payload, we store the requested callback and payload
+  // in static variables and install an intermediate callback for the interrupt to call. The intermerdiate
+  // The calls the actual requested callback with the payload.
+  actualPayload = payload;
+  actualCallback = callback;
+
+  // This timer library requires microsecond interval definitions
+  interruptHandler.setInterval(1000.0f * intervalMs, esp8266callback);
+}
+
+void InterruptCallback::start()
+{
+}
+
+void InterruptCallback::stop()
+{
+}
+
+#else
+
+
+bool InterruptCallback::setInterval(float intervalMs, interrupt_callback_p callback, void* payload)
+{
+  // We have requested to use Timer2 (see above)
+  ITimer2.init();
+
+  // This timer supports the callback with payload
+  return ITimer2.attachInterruptInterval<void*>(intervalMs, callback, payload, 0UL);
+}
+
+void InterruptCallback::stop()
+{
+  ITimer2.stopTimer();
+}
+
+void InterruptCallback::start()
+{
+  ITimer2.restartTimer();
+}
+
+#endif

Software/Arduino code/OpenAstroTracker/InterruptCallback.h

@@ -0,0 +1,26 @@
+#pragma once
+#include "Globals.h"
+
+//////////////////////////////////////
+// This is an hardware-independent abstraction layer over 
+// whatever timer is used for the hardware being run.
+//////////////////////////////////////
+
+// The callback function signature
+typedef void (*interrupt_callback_p)(void*);
+
+// The static class managing the callbacks.
+class InterruptCallback
+{
+public:
+  // Requests the hardware to call the given callback with the given payload at the given interval in milliseconds.
+  // The interrupts should be started before returning.
+  bool static setInterval(float intervalMs, interrupt_callback_p callback, void* payload);
+
+  // Starts the timer interrupts (currently not called/used)
+  void static start();
+
+  // Stops the timer interrupts (currently not called/used)
+  void static stop();
+};
+

Software/Arduino code/OpenAstroTracker/Mount.cpp

@@ -1,5 +1,7 @@
 #include <EEPROM.h>
 
+#include "InterruptCallback.h"
+
 #include "LcdMenu.hpp"
 #include "Mount.hpp"
 #include "Utility.h"
@@ -52,6 +54,15 @@ char* formatStringsRA[] = {
   "%02d%02d%02d",           // Compact
 };
 
+/////////////////////////////////
+// This is the callback function for the timer interrupt. It does very minimal work,
+// only stepping the stepper motors as needed.
+/////////////////////////////////
+void mountLoop(void* payload) {
+  Mount* mount = reinterpret_cast<Mount*>(payload);
+  mount->interruptLoop();
+}
+
 const float siderealDegreesInHour = 14.95902778;
 /////////////////////////////////
 //
@@ -77,6 +88,25 @@ Mount::Mount(int stepsPerRADegree, int stepsPerDECDegree, LcdMenu* lcdMenu) {
   readPersistentData();
 }
 
+/////////////////////////////////
+//
+// startTimerInterrupts
+//
+/////////////////////////////////
+void Mount::startTimerInterrupts()
+{
+#ifndef ESP8266
+  // 2 kHz updates
+  if (!InterruptCallback::setInterval(0.5f, mountLoop, this))
+  {
+#ifdef DEBUG_MODE
+    logv("CANNOT set Timer!");
+#endif
+  }
+#endif // !ESP8266
+}
+
+
 /////////////////////////////////
 //
 // readPersistentData
@@ -1079,33 +1109,17 @@ void Mount::delay(int ms) {
 
 /////////////////////////////////
 //
-// loop
+// interruptLoop()
 //
-// Process any stepper movement. Must be called frequently
 /////////////////////////////////
-void Mount::loop() {
-  bool raStillRunning = false;
-  bool decStillRunning = false;
-
-  unsigned long now = millis();
-#if defined DEBUG_MODE && defined SEND_PERIODIC_UPDATES
-  if (now - _lastMountPrint > 2000) {
-    Serial.println(getStatusString());
-    _lastMountPrint = now;
-  }
-#endif
-  if (isGuiding()) {
-    if (millis() > _guideEndTime) {
-      stopGuiding();
+void Mount::interruptLoop()
+{
+  if (_mountStatus & STATUS_GUIDE_PULSE) {
+    if (_mountStatus & STATUS_GUIDE_PULSE_RA) {
+      _stepperTRK->runSpeed();
     }
-    else
-    {
-      if (_mountStatus & STATUS_GUIDE_PULSE_RA) {
-        _stepperTRK->runSpeed();
-      }
-      if (_mountStatus & STATUS_GUIDE_PULSE_DEC) {
-        _stepperDEC->runSpeed();
-      }
+    if (_mountStatus & STATUS_GUIDE_PULSE_DEC) {
+      _stepperDEC->runSpeed();
     }
     return;
   }
@@ -1124,6 +1138,37 @@ void Mount::loop() {
       _stepperRA->run();
     }
   }
+}
+
+/////////////////////////////////
+//
+// loop
+//
+// Process any stepper change in movement. 
+/////////////////////////////////
+void Mount::loop() {
+  bool raStillRunning = false;
+  bool decStillRunning = false;
+
+// Since the ESP8266 cannot process timer interrupts at the required 
+  // speed, we'll just stick to deterministic calls here.
+#ifdef ESP8266
+  interruptLoop();
+#endif
+
+  unsigned long now = millis();
+#if defined DEBUG_MODE && defined SEND_PERIODIC_UPDATES
+  if (now - _lastMountPrint > 2000) {
+    Serial.println(getStatusString());
+    _lastMountPrint = now;
+  }
+#endif
+  if (isGuiding()) {
+    if (millis() > _guideEndTime) {
+      stopGuiding();
+    }
+    return;
+  }
 
   if (_stepperDEC->isRunning()) {
     decStillRunning = true;

Software/Arduino code/OpenAstroTracker/Mount.hpp

@@ -128,9 +128,12 @@ class Mount {
   // Gets the position in one of eight directions or tracking
   long getCurrentStepperPosition(int direction);
 
-  // Process any stepper movement. Must be called frequently
+  // Process any stepper movement. 
   void loop();
 
+  // Low-leve process any stepper movement on interrupt callback.
+  void interruptLoop();
+
   // Set RA and DEC to the home position
   void setTargetToHome();
 
@@ -178,6 +181,9 @@ class Mount {
 
   // Get the number of steps to use for backlash correction
   int getBacklashCorrection();
+  
+  // Called when startup is complete and the mount needs to start updating steppers.
+  void  startTimerInterrupts();
 
 private:
 
@@ -238,7 +244,7 @@ class Mount {
   float _trackingSpeed;
   float _trackingSpeedCalibration;
   unsigned long _lastDisplayUpdate;
-  int _mountStatus;
+  volatile int _mountStatus;
   char scratchBuffer[24];
   bool _stepperWasRunning;
   bool _correctForBacklash;

Software/Arduino code/OpenAstroTracker/OpenAstroTracker.ino

@@ -16,7 +16,7 @@
 */
 #include "Globals.h"
 
-String version = "V1.7.01";
+String version = "V1.7.02";
 
 ///////////////////////////////////////////////////////////////////////////
 // Please see the Globals.h file for configuration of the firmware.

Software/Arduino code/OpenAstroTracker/OpenAstroTracker.vcxproj

@@ -57,6 +57,21 @@
     <ClInclude Include="Globals.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="InterruptCallback.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Timers\ESP8266TimerInterrupt.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Timers\ESP8266_ISR_Timer-Impl.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Timers\ESP8266_ISR_Timer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Timers\TimerInterrupt.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="DayTime.cpp">
@@ -80,5 +95,11 @@
     <ClCompile Include="MeadeCommandProcessor.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="InterruptCallback.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Timers\TimerInterrupt.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

Software/Arduino code/OpenAstroTracker/OpenAstroTracker.vcxproj.filters

@@ -29,12 +29,11 @@ void setup() {
 #endif
 
   //debug_init();
-  //Serial.begin(38400);
   Serial.begin(57600);
   //BT.begin(9600);
 
 #ifdef DEBUG_MODE
-  Serial.println("Hello");
+  Serial.println("Hello, universe!");
 #endif
 
   // Show a splash screen
@@ -83,6 +82,9 @@ void setup() {
   // For LCD screen, it's better to initialize the target to where we are (RA)
   mount.targetRA() = mount.currentRA();
 
+  // Hook into the timers for periodic interrupts to run the steppers. 
+  mount.startTimerInterrupts();
+
   // Start the tracker.
   mount.startSlewing(TRACKING);
 
@@ -123,7 +125,7 @@ void setup() {
 #endif // HEADLESS_CLIENT
 
 #ifdef DEBUG_MODE
-  Serial.println("SetupDone");
+  Serial.println("Setup done!");
 #endif
 
 }

Software/Arduino code/OpenAstroTracker/b_setup.ino

@@ -23,13 +23,15 @@ PointOfInterest pointOfInterest[] = {
   { ">M101 Pinwheel",   14,  3, 56,   54, 15,  0 },
   // Add new items above here, not below.
   { ">Home"           ,  0,  0,  0,   90,  0,  0 },
+  { ">Unpark"         ,  0,  0,  0,   90,  0,  0 },
   { ">Park"           ,  0,  0,  0,   90,  0,  0 },
   // And definitely don't add here.
 };
 
 int currentPOI = 0;
 int parkPOI = sizeof(pointOfInterest) / sizeof(pointOfInterest[0]) - 1;
-byte homePOI = sizeof(pointOfInterest) / sizeof(pointOfInterest[0]) - 2;
+int unparkPOI = sizeof(pointOfInterest) / sizeof(pointOfInterest[0]) - 2;
+byte homePOI = sizeof(pointOfInterest) / sizeof(pointOfInterest[0]) - 3;
 
 bool processPOIKeys() {
   byte key;
@@ -45,6 +47,9 @@ bool processPOIKeys() {
         else if (currentPOI == parkPOI) {
           mount.park();
         }
+        else if (currentPOI == unparkPOI) {
+          mount.startSlewing(TRACKING);
+        }
         else {
           PointOfInterest* poi = &pointOfInterest[currentPOI];
           mount.targetRA().set(poi->hourRA, poi->minRA, poi->secRA);