kstars/kstars/indi/lx200_16.cpp

   1 /*
   2     LX200 16"
   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 */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <math.h>
  26
  27 #include "lx200_16.h"
  28 #include "lx200driver.h"
  29
  30 #define LX16GROUP       "GPS/16 inch Features"
  31
  32 extern LX200Generic *telescope;
  33 extern ITextVectorProperty Time;
  34 extern int MaxReticleFlashRate;
  35
  36
  37 //void turnFanOn();
  38    //void turnFanOff();
  39
  40    //void seekHomeAndSave();
  41   // void seekHomeAndSet();
  42
  43    /** Turns the field derotator On or Off. This command applies <b>only</b> to 16" LX200.
  44    @param turnOn if turnOn is true, the derotator is turned on, otherwise, it is turned off. */
  45  //  void fieldDeRotator(bool turnOn);
  46
  47
  48    /** Sets object Altitude. \n
  49    @returns true if object's altitude is successfully set. */
  50     //bool setObjAlt(int degrees, int minutes);
  51
  52    /** Sets object Azimuth. \n
  53    @returns true if object's azimuth is successfully set. */
  54 //    bool setObjAz(int degrees, int minutes);
  55
  56
  57 static ISwitch FanStatusS[]             = { {"On", "", ISS_OFF, 0, 0}, {"Off", "", ISS_OFF, 0, 0}};
  58 static ISwitch HomeSearchS[]            = { {"Save home", "", ISS_OFF, 0, 0} , {"Set home", "", ISS_OFF, 0, 0}};
  59 static ISwitch FieldDeRotatorS[]        = { {"On", "", ISS_OFF, 0, 0}, {"Off", "", ISS_OFF,0 ,0}};
  60 //static ISwitch SlewAltAzS[]           = { {"Slew To Alt/Az",  ISS_ON}};
  61
  62 #define MAXINDINAME     32
  63 #define MAXINDILABEL    32
  64 #define MAXINDIDEVICE   32
  65 #define MAXINDIGROUP    32
  66 #define MAXINDIFORMAT   32
  67
  68 static ISwitchVectorProperty FanStatusSw        = { mydev, "Fan", "", LX16GROUP, IP_RW, ISR_1OFMANY, 0, IPS_IDLE, FanStatusS, NARRAY(FanStatusS), "", 0};
  69
  70 static ISwitchVectorProperty HomeSearchSw       = { mydev, "Park", "", LX16GROUP, IP_RW, ISR_1OFMANY, 0, IPS_IDLE, HomeSearchS, NARRAY(HomeSearchS), "", 0};
  71
  72 static ISwitchVectorProperty FieldDeRotatorSw   = { mydev, "Field De-rotator", "", LX16GROUP, IP_RW, ISR_1OFMANY, 0, IPS_IDLE, FieldDeRotatorS, NARRAY(FieldDeRotatorS), "", 0};
  73
  74 //static ISwitches SlewAltAzSw          = { mydev, "AltAzSet", "On Alt/Az Set",  SlewAltAzS, NARRAY(SlewAltAzS), ILS_IDLE, 0, LX16Group};
  75
  76 /* horizontal position */
  77 static INumber hor[] = {
  78     {"ALT",  "Alt  D:M:S", "%10.6m",  -90., 90., 0., 0., 0, 0, 0},
  79     {"AZ", "Az D:M:S", "%10.6m", 0., 360., 0., 0., 0, 0, 0}};
  80
  81 static INumberVectorProperty horNum = {
  82     mydev, "HORIZONTAL_COORD", "Horizontal Coords", LX16GROUP, IP_RW, 0, IPS_IDLE,
  83     hor, NARRAY(hor), "", 0};
  84
  85 void changeLX200_16DeviceName(const char * newName)
  86 {
  87   strcpy(horNum.device, newName);
  88   strcpy(FanStatusSw.device, newName);
  89   strcpy(HomeSearchSw.device, newName);
  90   strcpy(FieldDeRotatorSw.device,newName);
  91 }
  92
  93 LX200_16::LX200_16() : LX200Autostar()
  94 {
  95
  96 }
  97
  98 void LX200_16::ISGetProperties (const char *dev)
  99 {
 100
 101 if (dev && strcmp (thisDevice, dev))
 102     return;
 103
 104   // process parent first
 105   LX200Autostar::ISGetProperties(dev);
 106
 107   IDDefNumber (&horNum, NULL);
 108
 109   IDDefSwitch (&FanStatusSw, NULL);
 110   IDDefSwitch (&HomeSearchSw, NULL);
 111   IDDefSwitch (&FieldDeRotatorSw, NULL);
 112
 113 }
 114
 115 void LX200_16::ISNewText (const char *dev, const char *name, char *texts[], char *names[], int n)
 116 {
 117
 118         // ignore if not ours //
 119         if (strcmp (dev, thisDevice))
 120             return;
 121
 122         LX200Autostar::ISNewText (dev, name, texts, names,  n);
 123
 124 }
 125
 126 void LX200_16::ISNewNumber (const char *dev, const char *name, double values[], char *names[], int n)
 127 {
 128   double newAlt=0, newAz=0;
 129   char altStr[64], azStr[64];
 130   int err;
 131
 132   // ignore if not ours //
 133   if (strcmp (dev, thisDevice))
 134     return;
 135
 136   if ( !strcmp (name, horNum.name) )
 137   {
 138       int i=0, nset=0;
 139
 140       if (checkPower(&horNum))
 141            return;
 142
 143         for (nset = i = 0; i < n; i++)
 144             {
 145                 INumber *horp = IUFindNumber (&horNum, names[i]);
 146                 if (horp == &hor[0])
 147                 {
 148                     newAlt = values[i];
 149                     nset += newAlt >= -90. && newAlt <= 90.0;
 150                 } else if (horp == &hor[1])
 151                 {
 152                     newAz = values[i];
 153                     nset += newAz >= 0. && newAz <= 360.0;
 154                 }
 155             }
 156
 157           if (nset == 2)
 158           {
 159            if ( (err = setObjAz(newAz)) < 0 || (err = setObjAlt(newAlt)) < 0)
 160            {
 161              handleError(&horNum, err, "Setting Alt/Az");
 162              return;
 163            }
 164                 horNum.s = IPS_OK;
 165                //horNum.n[0].value = values[0];
 166                //horNum.n[1].value = values[1];
 167                targetAz  = newAz;
 168                targetAlt = newAlt;
 169
 170                fs_sexa(azStr, targetAz, 2, 3600);
 171                fs_sexa(altStr, targetAlt, 2, 3600);
 172
 173                IDSetNumber (&horNum, "Attempting to slew to Alt %s - Az %s", altStr, azStr);
 174                handleAltAzSlew();
 175           }
 176           else
 177           {
 178                 horNum.s = IPS_IDLE;
 179                 IDSetNumber(&horNum, "Altitude or Azimuth missing or invalid");
 180           }
 181
 182           return;
 183     }
 184
 185     LX200Autostar::ISNewNumber (dev, name, values, names, n);
 186 }
 187
 188
 189
 190
 191 void LX200_16::ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n)
 192 {
 193    int index;
 194    int err;
 195
 196   if (strcmp (dev, thisDevice))
 197     return;
 198
 199    if (!strcmp(name, FanStatusSw.name))
 200    {
 201       if (checkPower(&FanStatusSw))
 202        return;
 203
 204           IUResetSwitches(&FanStatusSw);
 205           IUUpdateSwitches(&FanStatusSw, states, names, n);
 206           index = getOnSwitch(&FanStatusSw);
 207
 208           if (index == 0)
 209           {
 210             if ( (err = turnFanOn()) < 0)
 211             {
 212               handleError(&FanStatusSw, err, "Changing fan status");
 213               return;
 214             }
 215           }
 216           else
 217           {
 218             if ( (err = turnFanOff()) < 0)
 219             {
 220               handleError(&FanStatusSw, err, "Changing fan status");
 221               return;
 222             }
 223           }
 224
 225           FanStatusSw.s = IPS_OK;
 226           IDSetSwitch (&FanStatusSw, index == 0 ? "Fan is ON" : "Fan is OFF");
 227           return;
 228    }
 229
 230    if (!strcmp(name, HomeSearchSw.name))
 231    {
 232       if (checkPower(&HomeSearchSw))
 233        return;
 234
 235           IUResetSwitches(&HomeSearchSw);
 236           IUUpdateSwitches(&HomeSearchSw, states, names, n);
 237           index = getOnSwitch(&HomeSearchSw);
 238
 239           index == 0 ? seekHomeAndSave() : seekHomeAndSet();
 240           HomeSearchSw.s = IPS_BUSY;
 241           IDSetSwitch (&HomeSearchSw, index == 0 ? "Seek Home and Save" : "Seek Home and Set");
 242           return;
 243    }
 244
 245    if (!strcmp(name, FieldDeRotatorSw.name))
 246    {
 247       if (checkPower(&FieldDeRotatorSw))
 248        return;
 249
 250           IUResetSwitches(&FieldDeRotatorSw);
 251           IUUpdateSwitches(&FieldDeRotatorSw, states, names, n);
 252           index = getOnSwitch(&FieldDeRotatorSw);
 253
 254           index == 0 ? seekHomeAndSave() : seekHomeAndSet();
 255           FieldDeRotatorSw.s = IPS_OK;
 256           IDSetSwitch (&FieldDeRotatorSw, index == 0 ? "Field deRotator is ON" : "Field deRotator is OFF");
 257           return;
 258    }
 259
 260     LX200Autostar::ISNewSwitch (dev, name, states, names, n);
 261
 262 }
 263
 264 void LX200_16::handleAltAzSlew()
 265 {
 266         int i=0;
 267         char altStr[64], azStr[64];
 268
 269           if (horNum.s == IPS_BUSY)
 270           {
 271              abortSlew();
 272
 273              // sleep for 100 mseconds
 274              usleep(100000);
 275           }
 276
 277           if ((i = slewToAltAz()))
 278           {
 279             horNum.s = IPS_IDLE;
 280             IDSetNumber(&horNum, "Slew not possible");
 281             return;
 282           }
 283
 284           horNum.s = IPS_BUSY;
 285           fs_sexa(azStr, targetAz, 2, 3600);
 286           fs_sexa(altStr, targetAlt, 2, 3600);
 287
 288           IDSetNumber(&horNum, "Slewing to Alt %s - Az %s", altStr, azStr);
 289           return;
 290 }
 291
 292  void LX200_16::ISPoll ()
 293  {
 294    int searchResult=0;
 295    double dx, dy;
 296    int err;
 297
 298    LX200Autostar::ISPoll();
 299
 300         switch (HomeSearchSw.s)
 301         {
 302         case IPS_IDLE:
 303              break;
 304
 305         case IPS_BUSY:
 306
 307             if ( (err = getHomeSearchStatus(&searchResult)) < 0)
 308             {
 309               handleError(&HomeSearchSw, err, "Home search");
 310               return;
 311             }
 312
 313             if (searchResult == 0)
 314             {
 315               HomeSearchSw.s = IPS_IDLE;
 316               IDSetSwitch(&HomeSearchSw, "Home search failed.");
 317             }
 318             else if (searchResult == 1)
 319             {
 320               HomeSearchSw.s = IPS_OK;
 321               IDSetSwitch(&HomeSearchSw, "Home search successful.");
 322             }
 323             else if (searchResult == 2)
 324               IDSetSwitch(&HomeSearchSw, "Home search in progress...");
 325             else
 326             {
 327               HomeSearchSw.s = IPS_IDLE;
 328               IDSetSwitch(&HomeSearchSw, "Home search error.");
 329             }
 330             break;
 331
 332          case IPS_OK:
 333            break;
 334          case IPS_ALERT:
 335           break;
 336         }
 337
 338         switch (horNum.s)
 339         {
 340         case IPS_IDLE:
 341              break;
 342
 343         case IPS_BUSY:
 344
 345             if ( (err = getLX200Az(&currentAz)) < 0 || (err = getLX200Alt(&currentAlt)) < 0)
 346             {
 347               IDSetNumber(&horNum, NULL);
 348               handleError(&horNum, err, "Get Alt/Az");
 349               return;
 350             }
 351
 352             dx = targetAz - currentAz;
 353             dy = targetAlt - currentAlt;
 354
 355             horNum.np[0].value = currentAlt;
 356             horNum.np[1].value = currentAz;
 357
 358             IDLog("targetAz is %g, currentAz is %g\n", targetAz, currentAz);
 359             IDLog("targetAlt is %g, currentAlt is %g\n**********************\n", targetAlt,  currentAlt);
 360
 361
 362             // accuracy threshhold (3'), can be changed as desired.
 363             if ( fabs(dx) <= 0.05 && fabs(dy) <= 0.05)
 364             {
 365
 366                 horNum.s = IPS_OK;
 367                 currentAz = targetAz;
 368                 currentAlt = targetAlt;
 369                 IDSetNumber (&horNum, "Slew is complete");
 370             } else
 371                 IDSetNumber (&horNum, NULL);
 372             break;
 373
 374         case IPS_OK:
 375             break;
 376
 377         case IPS_ALERT:
 378             break;
 379         }
 380
 381  }
 382
 383  void LX200_16::getBasicData()
 384  {
 385
 386    getLX200Az(&targetAz);
 387    getLX200Alt(&targetAlt);
 388
 389    horNum.np[0].value = targetAlt;
 390    horNum.np[1].value = targetAz;
 391
 392    IDSetNumber (&horNum, NULL);
 393
 394    LX200Autostar::getBasicData();
 395
 396  }