kstars/kstars/indi/celestrongps.cpp

   1 #if 0
   2     Celestron GPS
   3     Copyright (C) 2003 Jasem Mutlaq (mutlaqja@ikarustech.com)
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Lesser General Public
   7     License as published by the Free Software Foundation; either
   8     version 2.1 of the License, or (at your option) any later version.
   9
  10     This library is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13     Lesser General Public License for more details.
  14
  15     You should have received a copy of the GNU Lesser General Public
  16     License along with this library; if not, write to the Free Software
  17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18
  19 #endif
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <stdarg.h>
  25 #include <math.h>
  26 #include <unistd.h>
  27 #include <time.h>
  28
  29 #include "celestronprotocol.h"
  30 #include "celestrongps.h"
  31
  32 #define RA_THRESHOLD    0.01
  33 #define DEC_THRESHOLD   0.05
  34 #define mydev           "Celestron GPS"
  35
  36 CelestronGPS *telescope = NULL;
  37
  38
  39 /* There is _one_ binary for all LX200 drivers, but each binary is renamed
  40 ** to its device name (i.e. lx200gps, lx200_16..etc). The main function will
  41 ** fetch from std args the binary name and ISInit will create the apporpiate
  42 ** device afterwards. If the binary name does not match any known devices,
  43 ** we simply create a generic device
  44 */
  45 extern char* me;
  46
  47 #define COMM_GROUP      "Communication"
  48 #define BASIC_GROUP     "Main Control"
  49 #define MOVE_GROUP      "Movement Control"
  50
  51 static void ISPoll(void *);
  52
  53 /*INDI controls */
  54 static ISwitch PowerS[]          = {{"CONNECT" , "Connect" , ISS_OFF, 0, 0},{"DISCONNECT", "Disconnect", ISS_ON, 0, 0}};
  55 static ISwitch SlewModeS[]       = {{"Slew", "", ISS_ON, 0, 0}, {"Find", "", ISS_OFF, 0, 0}, {"Centering", "", ISS_OFF, 0, 0}, {"Guide", "", ISS_OFF, 0, 0}};
  56 static ISwitch OnCoordSetS[]     = {{"SLEW", "Slew", ISS_ON, 0 , 0}, {"TRACK", "Track", ISS_OFF, 0, 0}, {"SYNC", "Sync", ISS_OFF, 0, 0}};
  57 static ISwitch abortSlewS[]      = {{"ABORT", "Abort", ISS_OFF, 0, 0}};
  58
  59 static ISwitch MovementS[]       = {{"N", "North", ISS_OFF, 0, 0}, {"W", "West", ISS_OFF, 0, 0}, {"E", "East", ISS_OFF, 0, 0}, {"S", "South", ISS_OFF, 0, 0}};
  60
  61 /* equatorial position */
  62 static INumber eq[] = {
  63     {"RA",  "RA  H:M:S", "%10.6m",  0., 24., 0., 0., 0, 0, 0},
  64     {"DEC", "Dec D:M:S", "%10.6m", -90., 90., 0., 0., 0, 0, 0},
  65 };
  66 //TODO decide appropiate TIME_OUT
  67 static INumberVectorProperty eqNum = {
  68     mydev, "EQUATORIAL_EOD_COORD", "Equatorial JNow", BASIC_GROUP, IP_RW, 0, IPS_IDLE,
  69     eq, NARRAY(eq), "", 0};
  70
  71 /* Fundamental group */
  72 static ISwitchVectorProperty PowerSw    = { mydev, "CONNECTION" , "Connection", COMM_GROUP, IP_RW, ISR_1OFMANY, 0, IPS_IDLE, PowerS, NARRAY(PowerS), "", 0};
  73 static IText PortT[]                    = {{"PORT", "Port", 0, 0, 0, 0}};
  74 static ITextVectorProperty Port         = { mydev, "DEVICE_PORT", "Ports", COMM_GROUP, IP_RW, 0, IPS_IDLE, PortT, NARRAY(PortT), "", 0};
  75
  76 /* Movement group */
  77 static ISwitchVectorProperty OnCoordSetSw    = { mydev, "ON_COORD_SET", "On Set", BASIC_GROUP, IP_RW, ISR_1OFMANY, 0, IPS_IDLE, OnCoordSetS, NARRAY(OnCoordSetS), "", 0};
  78 static ISwitchVectorProperty abortSlewSw     = { mydev, "ABORT_MOTION", "Abort Slew/Track", BASIC_GROUP, IP_RW, ISR_1OFMANY, 0, IPS_IDLE, abortSlewS, NARRAY(abortSlewS), "", 0};
  79 static ISwitchVectorProperty SlewModeSw      = { mydev, "Slew rate", "", MOVE_GROUP, IP_RW, ISR_1OFMANY, 0, IPS_IDLE, SlewModeS, NARRAY(SlewModeS), "", 0};
  80
  81 static ISwitchVectorProperty MovementSw      = { mydev, "MOVEMENT", "Move toward", MOVE_GROUP, IP_RW, ISR_1OFMANY, 0, IPS_IDLE, MovementS, NARRAY(MovementS), "", 0};
  82
  83
  84 /* send client definitions of all properties */
  85 void ISInit()
  86 {
  87   static int isInit=0;
  88
  89  if (isInit)
  90   return;
  91
  92  isInit = 1;
  93
  94   PortT[0].text = strcpy(new char[32], "/dev/ttyS0");
  95
  96   telescope = new CelestronGPS();
  97
  98   IEAddTimer (POLLMS, ISPoll, NULL);
  99 }
 100
 101 void ISGetProperties (const char *dev)
 102 { ISInit(); telescope->ISGetProperties(dev);}
 103 void ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n)
 104 { ISInit(); telescope->ISNewSwitch(dev, name, states, names, n);}
 105 void ISNewText (const char *dev, const char *name, char *texts[], char *names[], int n)
 106 { ISInit(); telescope->ISNewText(dev, name, texts, names, n);}
 107 void ISNewNumber (const char *dev, const char *name, double values[], char *names[], int n)
 108 { ISInit(); telescope->ISNewNumber(dev, name, values, names, n);}
 109 void ISPoll (void *p) { telescope->ISPoll(); IEAddTimer (POLLMS, ISPoll, NULL); p=p;}
 110 void ISNewBLOB (const char */*dev*/, const char */*name*/, int */*sizes[]*/, char **/*blobs[]*/, char **/*formats[]*/, char **/*names[]*/, int /*n*/)
 111 {}
 112
 113 /**************************************************
 114 *** LX200 Generic Implementation
 115 ***************************************************/
 116
 117 CelestronGPS::CelestronGPS()
 118 {
 119
 120    targetRA  = lastRA = 0;
 121    targetDEC = lastDEC = 0;
 122    currentSet   = 0;
 123    lastSet      = -1;
 124    lastMove[0] = lastMove[1] = lastMove[2] = lastMove[3] = 0;
 125
 126    JD = 0;
 127
 128    // Children call parent routines, this is the default
 129    IDLog("initilizaing from Celeston GPS device...\n");
 130
 131 }
 132
 133 void CelestronGPS::ISGetProperties(const char *dev)
 134 {
 135
 136  if (dev && strcmp (mydev, dev))
 137     return;
 138
 139   // COMM_GROUP
 140   IDDefSwitch (&PowerSw, NULL);
 141   IDDefText   (&Port, NULL);
 142
 143   // BASIC_GROUP
 144   IDDefNumber (&eqNum, NULL);
 145   IDDefSwitch (&OnCoordSetSw, NULL);
 146   IDDefSwitch (&abortSlewSw, NULL);
 147   IDDefSwitch (&SlewModeSw, NULL);
 148
 149   // Movement group
 150   IDDefSwitch (&MovementSw, NULL);
 151
 152   /* Send the basic data to the new client if the previous client(s) are already connected. */
 153   if (PowerSw.s == IPS_OK)
 154         getBasicData();
 155
 156 }
 157
 158 void CelestronGPS::ISNewText (const char *dev, const char *name, char *texts[], char *names[], int n)
 159 {
 160         IText *tp;
 161
 162         // suppress warning
 163         n=n;
 164         // ignore if not ours //
 165         if (strcmp (dev, mydev))
 166             return;
 167
 168         if (!strcmp(name, Port.name) )
 169         {
 170           Port.s = IPS_OK;
 171
 172           tp = IUFindText( &Port, names[0] );
 173           if (!tp)
 174            return;
 175
 176           tp->text = new char[strlen(texts[0])+1];
 177           strcpy(tp->text, texts[0]);
 178           IDSetText (&Port, NULL);
 179           return;
 180         }
 181 }
 182
 183 int CelestronGPS::handleCoordSet()
 184 {
 185
 186   int i=0;
 187   char RAStr[32], DecStr[32];
 188
 189   switch (currentSet)
 190   {
 191
 192     // Slew
 193     case 0:
 194           lastSet = 0;
 195           if (eqNum.s == IPS_BUSY)
 196           {
 197              StopNSEW();
 198              // sleep for 500 mseconds
 199              usleep(500000);
 200           }
 201
 202           if ((i = SlewToCoords(targetRA, targetDEC)))
 203           {
 204             slewError(i);
 205             return (-1);
 206           }
 207
 208           eqNum.s = IPS_BUSY;
 209           fs_sexa(RAStr, targetRA, 2, 3600);
 210           fs_sexa(DecStr, targetDEC, 2, 3600);
 211           IDSetNumber(&eqNum, "Slewing to JNOW RA %s - DEC %s", RAStr, DecStr);
 212           IDLog("Slewing to JNOW RA %s - DEC %s", RAStr, DecStr);
 213           break;
 214
 215
 216   // Track
 217   case 1:
 218           if (eqNum.s == IPS_BUSY)
 219           {
 220               StopNSEW();
 221              // sleep for 500 mseconds
 222              usleep(500000);
 223           }
 224
 225           if ( (fabs ( targetRA - currentRA ) >= TRACKING_THRESHOLD) ||
 226                (fabs (targetDEC - currentDEC) >= TRACKING_THRESHOLD))
 227           {
 228
 229                 IDLog("Exceeded Tracking threshold, will attempt to slew to the new target.\n");
 230                 IDLog("targetRA is %g, currentRA is %g\n", targetRA, currentRA);
 231                 IDLog("targetDEC is %g, currentDEC is %g\n*************************\n", targetDEC, currentDEC);
 232
 233                 if (( i =  SlewToCoords(targetRA, targetDEC)))
 234                 {
 235                         slewError(i);
 236                         return (-1);
 237                 }
 238
 239                 fs_sexa(RAStr, targetRA, 2, 3600);
 240                 fs_sexa(DecStr, targetDEC, 2, 3600);
 241                 eqNum.s = IPS_BUSY;
 242                 IDSetNumber(&eqNum, "Slewing to JNow RA %s - DEC %s", RAStr, DecStr);
 243                 IDLog("Slewing to JNOW RA %s - DEC %s", RAStr, DecStr);
 244           }
 245           else
 246           {
 247             IDLog("Tracking called, but tracking threshold not reached yet.\n");
 248             eqNum.s = IPS_OK;
 249             eqNum.np[0].value = currentRA;
 250             eqNum.np[1].value = currentDEC;
 251             if (lastSet != 1)
 252               IDSetNumber(&eqNum, "Tracking...");
 253             else
 254               IDSetNumber(&eqNum, NULL);
 255           }
 256           lastSet = 1;
 257       break;
 258
 259     // Sync
 260     case 2:
 261           lastSet = 2;
 262           OnCoordSetSw.s = IPS_OK;
 263           SyncToCoords(targetRA, targetDEC);
 264           eqNum.s = IPS_OK;
 265           IDSetNumber(&eqNum, "Synchronization successful.");
 266           break;
 267    }
 268
 269    return (0);
 270
 271 }
 272
 273 void CelestronGPS::ISNewNumber (const char *dev, const char *name, double values[], char *names[], int n)
 274 {
 275         double newRA=0, newDEC=0;
 276
 277         // ignore if not ours //
 278         if (strcmp (dev, mydev))
 279             return;
 280
 281         struct tm *tp;
 282         time_t t;
 283
 284         time (&t);
 285         tp = gmtime (&t);
 286
 287         if (!strcmp (name, eqNum.name))
 288         {
 289           int i=0, nset=0;
 290
 291           if (checkPower(&eqNum))
 292            return;
 293
 294             for (nset = i = 0; i < n; i++)
 295             {
 296                 INumber *eqp = IUFindNumber (&eqNum, names[i]);
 297                 if (eqp == &eq[0])
 298                 {
 299                     newRA = values[i];
 300                     nset += newRA >= 0 && newRA <= 24.0;
 301                 } else if (eqp == &eq[1])
 302                 {
 303                     newDEC = values[i];
 304                     nset += newDEC >= -90.0 && newDEC <= 90.0;
 305                 }
 306             }
 307
 308           if (nset == 2)
 309           {
 310            //eqNum.s = IPS_BUSY;
 311
 312            tp->tm_mon   += 1;
 313            tp->tm_year  += 1900;
 314
 315            // update JD
 316            JD = UTtoJD(tp);
 317
 318            IDLog("We recevined JNOW RA %f - DEC %f\n", newRA, newDEC);;
 319            /*apparentCoord( (double) J2000, JD, &newRA, &newDEC);
 320            IDLog("Processed to RA %f - DEC %f\n", newRA, newDEC);*/
 321
 322                //eqNum.np[0].value = values[0];
 323                //eqNum.np[1].value = values[1];
 324                targetRA  = newRA;
 325                targetDEC = newDEC;
 326
 327                if (MovementSw.s == IPS_BUSY)
 328                {
 329                 for (int i=0; i < 4; i++)
 330                 {
 331                         lastMove[i] = 0;
 332                         MovementS[i].s = ISS_OFF;
 333                 }
 334
 335                 MovementSw.s = IPS_IDLE;
 336                 IDSetSwitch(&MovementSw, NULL);
 337                }
 338
 339                if (handleCoordSet())
 340                {
 341                 eqNum.s = IPS_IDLE;
 342                 IDSetNumber(&eqNum, NULL);
 343                }
 344             }
 345             else
 346             {
 347                 eqNum.s = IPS_IDLE;
 348                 IDSetNumber(&eqNum, "RA or Dec missing or invalid.");
 349             }
 350
 351             return;
 352          }
 353 }
 354
 355 void CelestronGPS::ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n)
 356 {
 357
 358         int index;
 359         ISwitch *swp;
 360
 361         // Suppress warning
 362         names = names;
 363
 364         //IDLog("in new Switch with Device= %s and Property= %s and #%d items\n", dev, name,n);
 365         //IDLog("SolarSw name is %s\n", SolarSw.name);
 366
 367         // ignore if not ours //
 368         if (strcmp (dev, mydev))
 369             return;
 370
 371         // FIRST Switch ALWAYS for power
 372         if (!strcmp (name, PowerSw.name))
 373         {
 374          IUResetSwitches(&PowerSw);
 375          IUUpdateSwitches(&PowerSw, states, names, n);
 376          powerTelescope();
 377          return;
 378         }
 379
 380         if (!strcmp(name, OnCoordSetSw.name))
 381         {
 382           if (checkPower(&OnCoordSetSw))
 383            return;
 384
 385           IUResetSwitches(&OnCoordSetSw);
 386           IUUpdateSwitches(&OnCoordSetSw, states, names, n);
 387           currentSet = getOnSwitch(&OnCoordSetSw);
 388         }
 389
 390         // Abort Slew
 391         if (!strcmp (name, abortSlewSw.name))
 392         {
 393           if (checkPower(&abortSlewSw))
 394           {
 395             abortSlewSw.s = IPS_IDLE;
 396             IDSetSwitch(&abortSlewSw, NULL);
 397             return;
 398           }
 399
 400           IUResetSwitches(&abortSlewSw);
 401           StopNSEW();
 402
 403             if (eqNum.s == IPS_BUSY)
 404             {
 405                 abortSlewSw.s = IPS_OK;
 406                 eqNum.s       = IPS_IDLE;
 407                 IDSetSwitch(&abortSlewSw, "Slew aborted.");
 408                 IDSetNumber(&eqNum, NULL);
 409             }
 410             else if (MovementSw.s == IPS_BUSY)
 411             {
 412
 413                 for (int i=0; i < 4; i++)
 414                   lastMove[i] = 0;
 415
 416                 MovementSw.s  = IPS_IDLE;
 417                 abortSlewSw.s = IPS_OK;
 418                 eqNum.s       = IPS_IDLE;
 419                 IUResetSwitches(&MovementSw);
 420                 IUResetSwitches(&abortSlewSw);
 421                 IDSetSwitch(&abortSlewSw, "Slew aborted.");
 422                 IDSetSwitch(&MovementSw, NULL);
 423                 IDSetNumber(&eqNum, NULL);
 424             }
 425             else
 426             {
 427                 IUResetSwitches(&MovementSw);
 428                 abortSlewSw.s = IPS_IDLE;
 429                 IDSetSwitch(&abortSlewSw, NULL);
 430             }
 431
 432             return;
 433         }
 434
 435         // Slew mode
 436         if (!strcmp (name, SlewModeSw.name))
 437         {
 438           if (checkPower(&SlewModeSw))
 439            return;
 440
 441           IUResetSwitches(&SlewModeSw);
 442           IUUpdateSwitches(&SlewModeSw, states, names, n);
 443           index = getOnSwitch(&SlewModeSw);
 444           SetRate(index);
 445
 446           SlewModeSw.s = IPS_OK;
 447           IDSetSwitch(&SlewModeSw, NULL);
 448           return;
 449         }
 450
 451         // Movement
 452         if (!strcmp (name, MovementSw.name))
 453         {
 454           if (checkPower(&MovementSw))
 455            return;
 456
 457          index = -1;
 458          IUUpdateSwitches(&MovementSw, states, names, n);
 459          swp = IUFindSwitch(&MovementSw, names[0]);
 460
 461          if (!swp)
 462          {
 463             StopNSEW();
 464             IUResetSwitches(&MovementSw);
 465             MovementSw.s = IPS_IDLE;
 466             IDSetSwitch(&MovementSw, NULL);
 467          }
 468
 469          if (swp == &MovementS[0]) index = 0;
 470          else if (swp == &MovementS[1]) index = 1;
 471          else if (swp == &MovementS[2]) index = 2;
 472          else index = 3;
 473
 474          lastMove[index] = lastMove[index] == 0 ? 1 : 0;
 475          if (lastMove[index] == 0)
 476            MovementS[index].s = ISS_OFF;
 477
 478            // North/South movement is illegal
 479            if (lastMove[NORTH] && lastMove[SOUTH])
 480            {
 481              StopNSEW();
 482               for (int i=0; i < 4; i++)
 483                 lastMove[i] = 0;
 484
 485               IUResetSwitches(&MovementSw);
 486               MovementSw.s       = IPS_IDLE;
 487               IDSetSwitch(&MovementSw, "Slew aborted.");
 488               return;
 489            }
 490
 491            // East/West movement is illegal
 492            if (lastMove[EAST] && lastMove[WEST])
 493            {
 494               StopNSEW();
 495               for (int i=0; i < 4; i++)
 496                     lastMove[i] = 0;
 497
 498               IUResetSwitches(&MovementSw);
 499               MovementSw.s       = IPS_IDLE;
 500               IDSetSwitch(&MovementSw, "Slew aborted.");
 501               return;
 502            }
 503
 504           //IDLog("We have switch %d \n ", index);
 505           //IDLog("NORTH: %d -- WEST: %d -- EAST: %d -- SOUTH %d\n", lastMove[0], lastMove[1], lastMove[2], lastMove[3]);
 506
 507           if (lastMove[index] == 1)
 508             StartSlew(index);
 509           else
 510             StopSlew(index);
 511
 512           if (!lastMove[0] && !lastMove[1] && !lastMove[2] && !lastMove[3])
 513              MovementSw.s = IPS_IDLE;
 514
 515           if (lastMove[index] == 0)
 516              IDSetSwitch(&MovementSw, "Moving toward %s aborted.", Direction[index]);
 517           else
 518           {
 519              MovementSw.s = IPS_BUSY;
 520              IDSetSwitch(&MovementSw, "Moving %s...", Direction[index]);
 521           }
 522           return;
 523         }
 524
 525 }
 526
 527
 528 int CelestronGPS::getOnSwitch(ISwitchVectorProperty *sp)
 529 {
 530  for (int i=0; i < sp->nsp ; i++)
 531      if (sp->sp[i].s == ISS_ON)
 532       return i;
 533
 534  return -1;
 535 }
 536
 537
 538 int CelestronGPS::checkPower(ISwitchVectorProperty *sp)
 539 {
 540   if (PowerSw.s != IPS_OK)
 541   {
 542     if (!strcmp(sp->label, ""))
 543        IDMessage (mydev, "Cannot change property %s while the telescope is offline.", sp->name);
 544     else
 545        IDMessage (mydev, "Cannot change property %s while the telescope is offline.", sp->label);
 546
 547     sp->s = IPS_IDLE;
 548     IDSetSwitch(sp, NULL);
 549     return -1;
 550   }
 551
 552   return 0;
 553 }
 554
 555 int CelestronGPS::checkPower(INumberVectorProperty *np)
 556 {
 557   if (PowerSw.s != IPS_OK)
 558   {
 559     if (!strcmp(np->label, ""))
 560        IDMessage (mydev, "Cannot change property %s while the telescope is offline.", np->name);
 561     else
 562        IDMessage (mydev, "Cannot change property %s while the telescope is offline.", np->label);
 563
 564     np->s = IPS_IDLE;
 565     IDSetNumber(np, NULL);
 566     return -1;
 567   }
 568   return 0;
 569 }
 570
 571 int CelestronGPS::checkPower(ITextVectorProperty *tp)
 572 {
 573
 574   if (PowerSw.s != IPS_OK)
 575   {
 576     if (!strcmp(tp->label, ""))
 577        IDMessage (mydev, "Cannot change property %s while the telescope is offline.", tp->name);
 578     else
 579        IDMessage (mydev, "Cannot change property %s while the telescope is offline.", tp->label);
 580
 581     tp->s = IPS_IDLE;
 582     IDSetText(tp, NULL);
 583     return -1;
 584   }
 585
 586   return 0;
 587
 588 }
 589
 590 void CelestronGPS::ISPoll()
 591 {
 592        double dx, dy;
 593        double currentRA, currentDEC;
 594        int status;
 595
 596         switch (eqNum.s)
 597         {
 598         case IPS_IDLE:
 599         if (PowerSw.s != IPS_OK)
 600          break;
 601         currentRA = GetRA();
 602         currentDEC = GetDec();
 603
 604         if ( fabs (currentRA - lastRA) > 0.01 || fabs (currentDEC - lastDEC) > 0.01)
 605         {
 606                 eqNum.np[0].value = currentRA;
 607                 eqNum.np[1].value = currentDEC;
 608                 lastRA  = currentRA;
 609                 lastDEC = currentDEC;
 610                 IDSetNumber (&eqNum, NULL);
 611
 612         }
 613         break;
 614
 615         case IPS_BUSY:
 616             currentRA = GetRA();
 617             currentDEC = GetDec();
 618             dx = targetRA - currentRA;
 619             dy = targetDEC - currentDEC;
 620
 621             IDLog("targetRA is %f, currentRA is %f\n", (float) targetRA, (float) currentRA);
 622             IDLog("targetDEC is %f, currentDEC is %f\n****************************\n", (float) targetDEC, (float) currentDEC);
 623
 624             eqNum.np[0].value = currentRA;
 625             eqNum.np[1].value = currentDEC;
 626
 627             status = CheckCoords(targetRA, targetDEC);
 628
 629             // Wait until acknowledged or within 3.6', change as desired.
 630             switch (status)
 631             {
 632             case 0:             /* goto in progress */
 633                 IDSetNumber (&eqNum, NULL);
 634                 break;
 635             case 1:             /* goto complete within tolerance */
 636             case 2:             /* goto complete but outside tolerance */
 637                 currentRA = targetRA;
 638                 currentDEC = targetDEC;
 639
 640                 /*apparentCoord( JD, (double) J2000, &currentRA, &currentDEC);*/
 641
 642                 eqNum.np[0].value = currentRA;
 643                 eqNum.np[1].value = currentDEC;
 644
 645                 eqNum.s = IPS_OK;
 646
 647                 if (currentSet == 0)
 648                 {
 649                   IUResetSwitches(&OnCoordSetSw);
 650                   OnCoordSetSw.sp[0].s = ISS_ON;
 651                   IDSetNumber (&eqNum, "Slew is complete");
 652                 }
 653                 else
 654                 {
 655                   IUResetSwitches(&OnCoordSetSw);
 656                   OnCoordSetSw.sp[1].s = ISS_ON;
 657                   IDSetNumber (&eqNum, "Slew is complete. Tracking...");
 658                 }
 659
 660                 IDSetSwitch (&OnCoordSetSw, NULL);
 661                 break;
 662             }
 663             break;
 664
 665         case IPS_OK:
 666         if (PowerSw.s != IPS_OK)
 667          break;
 668         currentRA = GetRA();
 669         currentDEC = GetDec();
 670
 671         if ( fabs (currentRA - lastRA) > 0.01 || fabs (currentDEC - lastDEC) > 0.01)
 672         {
 673
 674                 eqNum.np[0].value = currentRA;
 675                 eqNum.np[1].value = currentDEC;
 676                 lastRA  = currentRA;
 677                 lastDEC = currentDEC;
 678                 IDSetNumber (&eqNum, NULL);
 679
 680         }
 681         break;
 682
 683
 684         case IPS_ALERT:
 685             break;
 686         }
 687
 688         switch (MovementSw.s)
 689         {
 690           case IPS_IDLE:
 691            break;
 692          case IPS_BUSY:
 693              currentRA = GetRA();
 694              currentDEC = GetDec();
 695
 696              /*apparentCoord( JD, (double) J2000, &currentRA, &currentDEC);*/
 697
 698
 699              eqNum.np[0].value = currentRA;
 700              eqNum.np[1].value = currentDEC;
 701
 702              IDSetNumber (&eqNum, NULL);
 703
 704              break;
 705          case IPS_OK:
 706            break;
 707          case IPS_ALERT:
 708            break;
 709          }
 710
 711 }
 712
 713 void CelestronGPS::getBasicData()
 714 {
 715
 716   targetRA = GetRA();
 717   targetDEC = GetDec();
 718
 719   eqNum.np[0].value = targetRA;
 720   eqNum.np[1].value = targetDEC;
 721
 722   IDSetNumber(&eqNum, NULL);
 723
 724 }
 725
 726 void CelestronGPS::powerTelescope()
 727 {
 728
 729      switch (PowerSw.sp[0].s)
 730      {
 731       case ISS_ON:
 732
 733          if (ConnectTel(Port.tp[0].text) < 0)
 734          {
 735            PowerS[0].s = ISS_OFF;
 736            PowerS[1].s = ISS_ON;
 737            IDSetSwitch (&PowerSw, "Error connecting to port %s", Port.tp[0].text);
 738            return;
 739          }
 740
 741         PowerSw.s = IPS_OK;
 742         IDSetSwitch (&PowerSw, "Telescope is online. Retrieving basic data...");
 743         getBasicData();
 744         break;
 745
 746      case ISS_OFF:
 747          IDSetSwitch (&PowerSw, "Telescope is offline.");
 748          IDLog("Telescope is offline.");
 749          DisconnectTel();
 750          break;
 751
 752     }
 753 }
 754
 755 void CelestronGPS::slewError(int slewCode)
 756 {
 757     eqNum.s = IPS_IDLE;
 758
 759     switch (slewCode)
 760     {
 761       case 1:
 762        IDSetNumber (&eqNum, "Invalid newDec in SlewToCoords");
 763        break;
 764       case 2:
 765        IDSetNumber (&eqNum, "RA count overflow in SlewToCoords");
 766        break;
 767       case 3:
 768        IDSetNumber (&eqNum, "Dec count overflow in SlewToCoords");
 769        break;
 770       case 4:
 771        IDSetNumber (&eqNum, "No acknowledgement from telescope after SlewToCoords");
 772        break;
 773       default:
 774        IDSetNumber (&eqNum, "Unknown error");
 775        break;
 776     }
 777
 778 }