V1.6.26 - Updates

- Added Guiding support.

Author: ClutchplateDude

Software/Arduino code/OpenAstroTracker/Globals.h

@@ -43,7 +43,7 @@ extern bool inSerialControl;
 // #define SUPPORT_HEATING
 
 // Uncomment to support Guided Startup 
-#define SUPPORT_GUIDED_STARTUP
+//#define SUPPORT_GUIDED_STARTUP
 
 // Uncomment to support full GO (was POI) menu. 
 // If this is commented out you still have a GO menu that has Home and Park.
@@ -53,9 +53,9 @@ extern bool inSerialControl;
 #define SUPPORT_MANUAL_CONTROL
 
 // Uncomment to support INFO menu that displays various pieces of information about the mount. 
-#define SUPPORT_INFO_DISPLAY
+//#define SUPPORT_INFO_DISPLAY
 
 // Uncomment to support Serial Meade LX200 protocol support
-// #define SUPPORT_SERIAL_CONTROL
+#define SUPPORT_SERIAL_CONTROL
 
 #endif

Software/Arduino code/OpenAstroTracker/Mount.cpp

@@ -8,6 +8,11 @@
 #define STATUS_SLEWING_FREE        B00000010
 #define STATUS_TRACKING            B00001000
 #define STATUS_PARKING             B00010000
+#define STATUS_GUIDE_PULSE         B10000000
+#define STATUS_GUIDE_PULSE_DIR     B01100000
+#define STATUS_GUIDE_PULSE_RA      B01000000
+#define STATUS_GUIDE_PULSE_DEC     B00100000
+#define STATUS_GUIDE_PULSE_MASK    B11100000
 
 // slewingStatus()
 #define SLEWING_DEC                B00000010
@@ -69,6 +74,8 @@ void Mount::configureRAStepper(byte stepMode, byte pin1, byte pin2, byte pin3, b
   _stepperRA = new AccelStepper(stepMode, pin1, pin2, pin3, pin4);
   _stepperRA->setMaxSpeed(maxSpeed);
   _stepperRA->setAcceleration(maxAcceleration);
+//  _maxRASpeed = maxSpeed;
+//  _maxRAAcceleration = maxAcceleration;
 
   // Use another AccelStepper to run the RA motor as well. This instance tracks earths rotation.
   _stepperTRK = new AccelStepper(HALFSTEP, pin1, pin2, pin3, pin4);
@@ -86,6 +93,8 @@ void Mount::configureDECStepper(byte stepMode, byte pin1, byte pin2, byte pin3,
   _stepperDEC = new AccelStepper(stepMode, pin4, pin3, pin2, pin1);
   _stepperDEC->setMaxSpeed(maxSpeed);
   _stepperDEC->setAcceleration(maxAcceleration);
+  _maxDECSpeed = maxSpeed;
+  _maxDECAcceleration = maxAcceleration;
 }
 
 float Mount::getSpeedCalibration() {
@@ -254,6 +263,25 @@ void Mount::syncDEC(int degree, int minute, int second) {
   _stepperDEC->setCurrentPosition(targetDEC);
 }
 
+/////////////////////////////////
+//
+// stopGuiding
+//
+/////////////////////////////////
+void Mount::stopGuiding() {
+  _stepperDEC->stop();
+  while (_stepperDEC->isRunning()) {
+    _stepperDEC->run();
+  }
+  _stepperDEC->setMaxSpeed(_maxDECSpeed);
+  _stepperDEC->setAcceleration(_maxDECAcceleration);
+  _stepperTRK->setMaxSpeed(10);
+  _stepperTRK->setAcceleration(2500);
+  _stepperTRK->setSpeed(_trackingSpeed);
+  _stepperTRK->runSpeed();
+  _mountStatus &= ~STATUS_GUIDE_PULSE_MASK;
+}
+
 /////////////////////////////////
 //
 // startSlewingToTarget
@@ -262,6 +290,10 @@ void Mount::syncDEC(int degree, int minute, int second) {
 // Calculates movement parameters and program steppers to move
 // there. Must call loop() frequently to actually move.
 void Mount::startSlewingToTarget() {
+  if (isGuiding()) {
+    stopGuiding();
+  }
+
   // Calculate new RA stepper target (and DEC)
   _currentDECStepperPosition = _stepperDEC->currentPosition();
   _currentRAStepperPosition = _stepperRA->currentPosition();
@@ -274,15 +306,66 @@ void Mount::startSlewingToTarget() {
   _totalRAMove = 1.0f * _stepperRA->distanceToGo();
 }
 
+/////////////////////////////////
+//
+// guidePulse
+//
+/////////////////////////////////
+void Mount::guidePulse(byte direction, int duration) {
+  // How many steps moves the RA ring one sidereal hour along. One sidereal hour moves just shy of 15 degrees
+  // NOTE: May need to adjust with _trackingSpeedCalibration
+  float decStepsPerSiderealHour = _stepsPerDECDegree * siderealDegreesInHour;
+  float decStepsForDuration = decStepsPerSiderealHour * duration / 3600000;
+  float raStepsPerSiderealHour = _stepsPerRADegree * siderealDegreesInHour;
+  float raStepsForDuration = raStepsPerSiderealHour * duration / 3600000;
+
+  float decTrackingSpeed = _stepsPerDECDegree * siderealDegreesInHour / 3600.0f;
+  float raTrackingSpeed = _stepsPerRADegree * siderealDegreesInHour / 3600.0f;
+
+  long raPos = _stepperRA->currentPosition();
+  long decPos = _stepperDEC->currentPosition();
+
+  switch (direction) {
+    case NORTH:
+      _stepperDEC->setMaxSpeed(decTrackingSpeed * 1.2);
+      _stepperDEC->setSpeed(decTrackingSpeed);
+      _stepperDEC->moveTo(decPos + decStepsForDuration);
+      _mountStatus |= STATUS_GUIDE_PULSE | STATUS_GUIDE_PULSE_DEC ;
+      break;
+
+    case SOUTH:
+      _stepperDEC->setMaxSpeed(decTrackingSpeed * 1.2);
+      _stepperDEC->setSpeed(decTrackingSpeed);
+      _stepperDEC->moveTo(decPos - decStepsForDuration);
+      _mountStatus |= STATUS_GUIDE_PULSE | STATUS_GUIDE_PULSE_DEC ;
+      break;
+
+    case WEST:
+      _stepperTRK->setMaxSpeed(raTrackingSpeed * 2.2);
+      _stepperTRK->setSpeed(raTrackingSpeed * 2);
+      _stepperTRK->moveTo(raPos + raStepsForDuration);
+      _mountStatus |= STATUS_GUIDE_PULSE | STATUS_GUIDE_PULSE_RA;
+      break;
+
+    case EAST:
+      _stepperTRK->setMaxSpeed(raTrackingSpeed * 2.2);
+      _stepperTRK->setSpeed(0);
+      _mountStatus |= STATUS_GUIDE_PULSE | STATUS_GUIDE_PULSE_RA;
+      break;
+  }
+
+  _guideEndTime = millis() + duration;
+}
+
 /////////////////////////////////
 //
 // park
 //
-// Targets the mount to move to the home position and 
+// Targets the mount to move to the home position and
 // turns off all motors once it gets there.
 /////////////////////////////////
-void Mount::park()
-{
+void Mount::park() {
+  stopGuiding();
   stopSlewing(ALL_DIRECTIONS | TRACKING);
   waitUntilStopped(ALL_DIRECTIONS);
   setTargetToHome();
@@ -294,11 +377,12 @@ void Mount::park()
 //
 // goHome
 //
-// Synchronously moves mount to home position and 
+// Synchronously moves mount to home position and
 // sets Tracking mode according to argument
 /////////////////////////////////
 void Mount::goHome(bool tracking)
 {
+  stopGuiding();
   stopSlewing(TRACKING);
   setTargetToHome();
   startSlewingToTarget();
@@ -332,6 +416,9 @@ String Mount::mountStatusString() {
   if (_mountStatus & STATUS_PARKING) {
     disp = "PARKNG ";
   }
+  else if (isGuiding()){
+     disp = "GUIDING ";
+  }
   else {
     if (_mountStatus & STATUS_TRACKING) disp += "TRK ";
     if (_mountStatus & STATUS_SLEWING) disp += "SLW ";
@@ -365,13 +452,26 @@ byte Mount::slewStatus() {
   if (_mountStatus == STATUS_PARKED) {
     return NOT_SLEWING;
   }
+  if (isGuiding()) {
+    return NOT_SLEWING;
+  }
   byte slewState = _stepperRA->isRunning() ? SLEWING_RA : NOT_SLEWING;
   slewState |= _stepperDEC->isRunning() ? SLEWING_DEC : NOT_SLEWING;
 
   slewState |= (_mountStatus & STATUS_TRACKING) ? SLEWING_TRACKING : NOT_SLEWING;
   return slewState;
 }
 
+/////////////////////////////////
+//
+// isGuiding
+//
+/////////////////////////////////
+bool Mount::isGuiding()
+{
+  return (_mountStatus & STATUS_GUIDE_PULSE);
+}
+
 /////////////////////////////////
 //
 // isSlewingDEC
@@ -449,6 +549,10 @@ bool Mount::isParking() {
 void Mount::startSlewing(int direction) {
   if (!isParking())
   {
+    if (isGuiding()) {
+      stopGuiding();
+    }
+
     if (direction & TRACKING) {
       _stepperTRK->setSpeed(_trackingSpeed);
 
@@ -561,6 +665,22 @@ void Mount::loop() {
     _lastMountPrint = now;
   }
 #endif
+  if (isGuiding()) {
+    if (millis() > _guideEndTime) {
+      stopGuiding();
+    }
+    else
+    {
+      if (_mountStatus & STATUS_GUIDE_PULSE_RA) {
+        _stepperTRK->runSpeed();
+      }
+      if (_mountStatus & STATUS_GUIDE_PULSE_DEC) {
+        _stepperDEC->runSpeed();
+      }
+    }
+    return;
+  }
+
   if (_mountStatus & STATUS_TRACKING) {
     _stepperTRK->runSpeed();
   }

Software/Arduino code/OpenAstroTracker/Mount.hpp

@@ -80,6 +80,7 @@ class Mount {
     bool isSlewingTRK();
     bool isParked();
     bool isParking();
+    bool isGuiding();
 
     // Starts manual slewing in one of eight directions or tracking
     void startSlewing(int direction);
@@ -111,6 +112,11 @@ class Mount {
     // Asynchronously parks the mount. Moves to the home position and stops all motors. 
     void park();
 
+    // Runs the RA motor at twice the speed (or stops it), or the DEC motor at tracking speed for the given duration in ms.
+    void guidePulse(byte direction, int duration);
+
+    // Stops any guide operation in progress.
+    void stopGuiding();
 
     // Return a string of DEC in the given format. For LCDSTRING, active determines where the cursor is
     String DECString(byte type, byte active = 0);
@@ -144,6 +150,11 @@ class Mount {
     LcdMenu* _lcdMenu;
     int  _stepsPerRADegree;
     int _stepsPerDECDegree;
+    //int _maxRASpeed;
+    int _maxDECSpeed;
+    //int _maxRAAcceleration;
+    int _maxDECAcceleration;
+    
     long _lastHASet;
     DayTime _HAAdjust;
 
@@ -163,6 +174,7 @@ class Mount {
     AccelStepper* _stepperDEC;
     AccelStepper* _stepperTRK;
 
+    unsigned long _guideEndTime;
     unsigned long _lastMountPrint = 0;
     DayTime _HATime;
     DayTime _HACorrection;

Software/Arduino code/OpenAstroTracker/OpenAstroTracker.ino

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

Software/Arduino code/OpenAstroTracker/f_serial.ino

@@ -59,6 +59,10 @@
 //      Get Tracking
 //      Returns: 1 if tracking is on. 0 if not.
 //
+// :GIG#
+//      Get Guiding
+//      Returns: 1 if currently guiding. 0 if not.
+//
 //------------------------------------------------------------------
 // SET FAMILY
 //
@@ -97,6 +101,12 @@
 //
 // -- MOVEMENT Extensions --
 //
+// :MGdnnnn#
+//      Run a Guide pulse
+//      This runs the motors for a short period of time.
+//      Where d is one of 'N', 'E', 'W', or 'S' and nnnn is the duration in ms.
+//      Returns: nothing
+//
 // :MTs#
 //      Set Tracking mode
 //      This turns the scopes tracking mode on or off.
@@ -188,6 +198,9 @@ void handleMeadeGetInfo(String inCmd) {
         else if (cmdTwo == 'T') {
           Serial.print(mount.isSlewingTRK() ? "1" : "0");
         }
+        else if (cmdTwo == 'G') {
+          Serial.print(mount.isGuiding() ? "1" : "0");
+        }
         Serial.print("#");
       }
       break;
@@ -279,6 +292,20 @@ void handleMeadeMovement(String inCmd) {
       Serial.print("0");
     }
   }
+  else if (inCmd[0] == 'G') {
+    // Guide pulse
+    //   012345678901
+    // :MGd0403
+    if (inCmd.length() == 6) {
+      byte direction = EAST;
+      if (inCmd[1] == 'N') direction = NORTH;
+      else if (inCmd[1] == 'S') direction = SOUTH;
+      else if (inCmd[1] == 'E') direction = EAST;
+      else if (inCmd[1] == 'W') direction = WEST;
+      int duration = (inCmd[2] - '0') * 1000 + (inCmd[3] - '0') * 100 + (inCmd[4] - '0') * 10 + (inCmd[5] - '0');
+      mount.guidePulse(direction, duration);
+    }
+  }
 }
 
 /////////////////////////////