kstars/kstars/indi/temmadriver.c

   1 #if 0
   2         Temma INDI driver
   3         Copyright (C) 2004 Francois Meyer (dulle @ free.fr)
   4         Remi Petitdemange for the temma protocol
   5   Reference site is http://dulle.free.fr/alidade/indi.php
   6
   7         This library is free software; you can redistribute it and/or
   8         modify it under the terms of the GNU Lesser General Public
   9         License as published by the Free Software Foundation; either
  10         version 2.1 of the License, or (at your option) any later version.
  11
  12         This library is distributed in the hope that it will be useful,
  13         but WITHOUT ANY WARRANTY; without even the implied warranty of
  14         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15         Lesser General Public License for more details.
  16
  17         You should have received a copy of the GNU Lesser General Public
  18         License along with this library; if not, write to the Free Software
  19         Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20
  21 #endif
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <stdarg.h>
  27 #include <math.h>
  28 #include <sys/time.h>
  29 #include <unistd.h>
  30 #include <fcntl.h>
  31 #include <termios.h>
  32 #include <time.h>
  33
  34 #include "indicom.h"
  35 #include "indidevapi.h"
  36 #include "eventloop.h"
  37 #include "indicom.h"
  38 #include "temmadriver.h"
  39
  40
  41         char errormes[][128]={
  42                 "I/O Timeout",
  43                 "Error reading from io port",
  44                 "Error writing to io port",
  45                 "Unrecognized message"
  46         };
  47
  48 char answer[32];
  49 int fd;
  50 int read_ret, write_ret;
  51 unsigned char buffer[256];
  52 unsigned char buffer2[256];
  53
  54
  55 #if 1
  56 /* Initlization routine */
  57 static void mountInit()
  58 {
  59         static int inited;              /* set once mountInit is called */
  60
  61         if (inited)
  62                 return;
  63
  64         /* setting default comm port */
  65         PortT->text = realloc(PortT->text, 10);
  66         TemmaNoteT[0].text = realloc( TemmaNoteT[0].text, 64);
  67         TemmaNoteT[1].text = realloc( TemmaNoteT[1].text, 64);
  68
  69         if (!PortT->text || !TemmaNoteT[0].text || !TemmaNoteT[1].text){
  70                 fprintf(stderr,"Memory allocation error");
  71                 return;
  72         }
  73         strcpy(PortT->text, "/dev/ttyS0");
  74         strcpy(TemmaNoteT[0].text, "Experimental Driver");
  75         strcpy(TemmaNoteT[1].text, "http://dulle.free.fr/alidade/indi.php");
  76
  77         inited = 1;
  78 }
  79 #endif
  80
  81 void ISGetProperties (const char *dev) {
  82         if (dev && strcmp (mydev, dev))
  83                 return;
  84
  85         mountInit();
  86
  87         IDDefSwitch (&powSw, NULL);
  88         IDDefNumber (&eqTemma, NULL);
  89         IDDefNumber (&eqNum, NULL);
  90         IDDefSwitch (&OnCoordSetSw, NULL);
  91         IDDefSwitch (&abortSlewSw, NULL);
  92         IDDefText   (&TemmaNoteTP, NULL);
  93         IDDefSwitch (&RAmotorSw, NULL);
  94         IDDefSwitch (&trackmodeSw, NULL);
  95         IDDefText (&Port, NULL);
  96         IDDefText (&TemmaVersion, NULL);
  97         IDDefNumber (&Time, NULL);
  98         IDDefNumber (&SDTime, NULL);
  99         IDDefNumber (&cometNum, NULL);
 100         IDDefNumber (&geoNum, NULL);
 101 }
 102
 103 void ISNewBLOB (const char *dev, const char *name, int sizes[], char *blobs[], char *formats[], char *names[], int n)
 104 {
 105  dev=dev;name=name;sizes=sizes;blobs=blobs;formats=formats;names=names;n=n;
 106 }
 107
 108 void ISNewText (const char *dev, const char *name, char *texts[], char *names[], int n) {
 109         /*IText *tp;*/
 110
 111         if (strcmp (dev, mydev))
 112                 return;
 113
 114         if (!strcmp (name, Port.name)) {
 115                 IUSaveText(PortT, texts[0]);
 116                 Port.s = IPS_OK;
 117                 IDSetText (&Port, NULL);
 118         }
 119         return;
 120 }
 121
 122 /* client is sending us a new value for a Numeric vector property */
 123 void ISNewNumber (const char *dev, const char *name, double values[], char *names[], int n) {
 124         /* ignore if not ours */
 125         if (strcmp (dev, mydev))
 126                 return;
 127
 128         if (!strcmp (name, eqNum.name)) {
 129                 /* new equatorial target coords */
 130                 /*double newra = 0, newdec = 0;*/
 131                 int i, nset;
 132
 133                 /* Check power, if it is off, then return */
 134                 if (power[0].s != ISS_ON)
 135                 {
 136                         eqNum.s = IPS_IDLE;
 137                         IDSetNumber(&eqNum, "Power is off");
 138                         return;
 139                 }
 140
 141                 for (nset = i = 0; i < n; i++) {
 142                         /* Find numbers with the passed names in the eqNum property */
 143                         INumber *eqp = IUFindNumber (&eqNum, names[i]);
 144
 145                         /* If the number found is Right ascension (eq[0]) then process it */
 146                         if (eqp == &eq[0])
 147                         {
 148                                 currentRA = (values[i]);
 149                                 nset += currentRA >= 0 && currentRA <= 24;
 150                         }
 151                         /* Otherwise, if the number found is Declination (eq[1]) then process it */
 152                         else if (eqp == &eq[1]) {
 153                                 currentDec = (values[i]);
 154                                 nset += currentDec >= -90 && currentDec <= 90;
 155                         }
 156                 } /* end for */
 157
 158                 /* Did we process the two numbers? */
 159                 if (nset == 2) {
 160                         /*char r[32], d[32];*/
 161
 162                         /* Set the mount state to BUSY */
 163                         eqNum.s = IPS_BUSY;
 164
 165                         if (SLEWSW==ISS_ON || TRACKSW==ISS_ON){
 166                                 IDSetNumber(&eqNum, "Moving to RA Dec %f %f", currentRA,
 167                                                 currentDec);
 168                                 do_TemmaGOTO();
 169                         }
 170
 171                         if (SYNCSW==ISS_ON){
 172                                 IDSetNumber(&eqNum, "Syncing to RA Dec %f %f", currentRA, currentDec);
 173                                 set_TemmaCurrentpos();
 174                         }
 175                         eqNum.s = IPS_OK;
 176                         IDSetNumber(&eqNum, "Synced");
 177                 }
 178                 /* We didn't process the two number correctly, report an error */
 179                 else {
 180                         /* Set property state to idle */
 181                         eqNum.s = IPS_IDLE;
 182
 183                         IDSetNumber(&eqNum, "RA or Dec absent or bogus.");
 184                 }
 185         return;
 186         }
 187 }
 188
 189 /* client is sending us a new value for a Switch property */
 190 void ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n)
 191 {
 192         ISwitch *sp;
 193
 194         /* ignore if not ours */
 195         if (strcmp (dev, mydev))
 196                 return;
 197
 198         if (!strcmp (name, powSw.name)) {
 199                 sp = IUFindSwitch (&powSw, names[0]);
 200                 if (!sp)
 201                         return;
 202
 203                 fprintf(stderr,"new state %s\n",names[0]);
 204
 205                 sp->s = states[0];
 206                 if (!strcmp(names[0],"CONNECT")) {
 207                         connectMount();
 208                 }
 209                 if (!strcmp(names[0],"DISCONNECT")) {
 210                         disconnectMount();
 211                 }
 212         }
 213
 214         if (!strcmp (name, abortSlewSw.name)) {
 215                 if (POWSW){
 216                         TemmaabortSlew();
 217                         IDSetSwitch (&abortSlewSw, "Abort slew");
 218                 }
 219                 else {
 220                         IDSetSwitch (&abortSlewSw, "Power is off");
 221                 }
 222         }
 223
 224         if (!strcmp (name, RAmotorSw.name)) {
 225                 if (POWSW){
 226                         sp = IUFindSwitch (&RAmotorSw, names[0]);
 227                         if (!sp)
 228                                 return;
 229
 230                         fprintf(stderr,"new state %s\n",names[0]);
 231
 232                         sp->s = states[0];
 233
 234                         RAmotorSw.s = IPS_BUSY;
 235                         if (!strcmp(names[0],"RUN")) {
 236                                 set_TemmaStandbyState(0);
 237                         }
 238
 239                         if (!strcmp(names[0],"STOP")) {
 240                                 set_TemmaStandbyState(1);
 241                         }
 242
 243                         if(get_TemmaStandbyState(buffer)){
 244                                 RAmotorSw.s = IPS_IDLE;
 245                                 IDSetSwitch (&RAmotorSw, "Error writing to port");
 246                                 return;
 247                         }
 248                 }
 249                 else {
 250                         IDSetSwitch (&RAmotorSw, "Power is off");
 251                 }
 252         }
 253
 254         if (!strcmp (name, OnCoordSetSw.name)) {
 255                 if (POWSW){
 256                         IUResetSwitches(&OnCoordSetSw);
 257                         sp = IUFindSwitch (&OnCoordSetSw, names[0]);
 258                         if (!sp)
 259                                 return;
 260
 261                         fprintf(stderr,"new state %s\n",names[0]);
 262
 263                         sp->s = states[0];
 264
 265                         IUResetSwitches(&OnCoordSetSw);
 266                         IUUpdateSwitches(&OnCoordSetSw, states, names, n);
 267                         /*                          currentSet = getOnSwitch(&OnCoordSetSw); */
 268                         OnCoordSetSw.s = IPS_OK;
 269                         IDSetSwitch(&OnCoordSetSw, NULL);
 270                 }
 271                 else {
 272                         IDSetSwitch (&OnCoordSetSw, "Power is off");
 273                 }
 274         }
 275 }
 276
 277 double calcLST(char *strlst){
 278         time_t computertime;
 279         struct tm gmt;
 280         double jd, gmst;
 281         double lst;
 282         /*int a,b;*/
 283
 284         time(&computertime);
 285         gmtime_r(&computertime, &gmt);
 286         gmt.tm_mon+=1;
 287         gmt.tm_year+=1900;
 288         currentUTC=(double)gmt.tm_hour+(double)gmt.tm_min/60+(double)gmt.tm_sec/3600;
 289
 290         jd=UTtoJD(&gmt);
 291         gmst=JDtoGMST(jd);
 292
 293         lst=(gmst-longitude)/15;
 294
 295         lst=(lst/24-(int)(lst/24))*24;
 296
 297         if(lst>=24)
 298                 lst-=24;
 299         sprintf(strlst,"%.2d%.2d%.2d", (int)lst,
 300                         ((int)(lst*60))%60,
 301                         ((int)(lst*3600))%60);
 302         currentLST=lst;
 303         IDSetNumber (&SDTime, NULL);
 304         IDSetNumber (&Time, NULL);
 305
 306         return 0;
 307 }
 308
 309 #if 1
 310 /* update the mount over time */
 311 void readMountcurrentpos (void *p)
 312 {
 313         char result[32];
 314
 315         if(POWSW){
 316                 get_TemmaCurrentpos(result);
 317                 calcLST(result);
 318
 319                 /* This is a temporary workaround to allow
 320                    clients with only one eq property to work */
 321                 currentRA=temmaRA;
 322                 currentDec=temmaDec;
 323
 324                 /* again */
 325                 IEAddTimer (POLLMS, readMountcurrentpos, NULL);
 326         }
 327 }
 328 #endif
 329
 330 static void connectMount () {
 331         fprintf(stderr,"opening mount port %s\n",PortT->text);
 332         if (power[0].s == ISS_ON){
 333                 if (Port.s != IPS_OK){
 334                         powSw.s = IPS_IDLE;
 335                         power[0].s = ISS_OFF;
 336
 337                         IDSetSwitch (&powSw, "Port not set.");
 338                         return;
 339                 }
 340                 else {
 341                         if (TemmaConnect(PortT->text)==0){
 342                                 IDSetText (&Port, "Port is opened.");
 343                                 if( !get_TemmaVERSION(buffer)){
 344                                         powSw.s = IPS_OK;
 345                                         power[0].s = ISS_ON;
 346                                         power[1].s = ISS_OFF;
 347                                         snprintf(buffer2,sizeof( buffer2 ),"%s",buffer+4);
 348
 349                                         IDSetText(&TemmaVersion , "Temma version set");
 350                                         TemmaVersionT->text = realloc(TemmaVersionT->text, strlen(buffer2)+1);
 351                                         if (!TemmaVersionT->text){
 352                                                 fprintf(stderr,"Memory allocation error");
 353                                                 return;
 354                                         }
 355                                         IDSetSwitch (&powSw, "Mount is ready");
 356                                         IDSetSwitch (&powSw, VERSION);
 357
 358                                         strcpy(TemmaVersionT->text, buffer2);
 359                                         TemmaVersion.s = IPS_OK;
 360                                         IDSetText (&TemmaVersion, NULL);
 361                                         IDLog("%s", buffer2);
 362                                         /* start timer to read mount coords */
 363                                         IEAddTimer (POLLMS, readMountcurrentpos, NULL);
 364                                 }
 365                                 else {
 366                                         powSw.s = IPS_IDLE;
 367                                         power[0].s = ISS_OFF;
 368                                         power[1].s = ISS_ON;
 369                                         IDSetText(&Port , "Com error");
 370                                         IDSetSwitch (&powSw, "Port not set.");
 371                                 }
 372
 373                                 if(get_TemmaStandbyState(answer)){
 374                                         IDSetSwitch (&RAmotorSw, "Error writing to port");
 375                                         return;
 376                                 }
 377                         }
 378                         else {
 379                                 powSw.s = IPS_IDLE;
 380                                 power[0].s = ISS_OFF;
 381                                 power[1].s = ISS_ON;
 382
 383                                 IDSetSwitch (&powSw, "Failed to open port.");
 384                         }
 385                 }
 386         }
 387 }
 388
 389 static void disconnectMount () {
 390         fprintf(stderr,"closing mount port %s\n",PortT->text);
 391         if (power[1].s == ISS_ON){
 392                 if (Port.s != IPS_OK){
 393                         powSw.s = IPS_IDLE;
 394                         power[0].s = ISS_OFF;
 395
 396                         IDSetSwitch (&powSw, "Port not set.");
 397                         return;
 398                 }
 399                 else {
 400                         TemmaDisconnect();
 401                         powSw.s = IPS_IDLE;
 402                         power[0].s = ISS_OFF;
 403
 404                         IDSetSwitch (&powSw, "Port is closed.");
 405                 }
 406         }
 407         else {
 408                 fprintf(stderr, "Already disconnected \n");
 409         }
 410 }
 411
 412 int TemmaConnect(const char *device) {
 413         fprintf(stderr, "Connecting to device %s\n", device);
 414
 415         if (openPort(device) < 0){
 416                 fprintf(stderr, "Error connecting to device %s\n", device);
 417                 return -1;
 418         }
 419         else{
 420                 return 0;
 421         }
 422 }
 423
 424 int TemmaDisconnect() {
 425         fprintf(stderr, "Disconnected.\n");
 426         close(fd);
 427
 428         return 0;
 429 }
 430
 431 int set_CometTracking(int RArate, int DECrate){
 432 #if 0
 433         Set Comet Tracking
 434         LM+/-99999,+/-9999
 435         RA : Adjust Sidereal time by seconds per Day
 436
 437         DEC : Adjust DEC tracking by Minutes Per Day
 438         valeur DEC min=-600 /max=+600 (+/-10 deg / jour)
 439
 440         Example:
 441         LM+120,+30 would slow the RA speed by 86164/86284 and
 442         the Dec would track at 30 Minutes a day.
 443         To stop tracking either send a LM0,0 (or a PS
 444         sauf erreur on constate en faite l inverse en RA
 445         retour Vsideral => LM0,0 ou LM+0,+0
 446 #endif
 447         char local_buffer[16];
 448
 449         if (RArate<-21541){
 450         RArate=-21541;
 451         }
 452
 453         if (RArate>21541){
 454         RArate=21541;
 455         }
 456
 457         if (DECrate<-600){
 458         DECrate=-600;
 459         }
 460
 461         if (DECrate>600){
 462         DECrate=600;
 463         }
 464
 465         snprintf(local_buffer, sizeof( local_buffer ), "%+6d,%+5d", RArate, DECrate);
 466         set_TemmaCometTracking(local_buffer);
 467
 468         return 0;
 469 }
 470
 471 int TemmaabortSlew() {
 472         if (portWrite("PS") < 0)
 473                 return -1;
 474
 475         return 0;
 476 }
 477
 478 int do_TemmaGOTO() {
 479         /* Temma Sync */
 480         char command[16];
 481         char sign;
 482         double dec;
 483
 484         calcLST(buffer);
 485         set_TemmaLST(buffer);
 486
 487         dec=fabs(currentDec);
 488         if (currentDec>0){
 489                 sign='+';
 490         }
 491         else {
 492                 sign='-';
 493         }
 494
 495         snprintf(buffer, sizeof(buffer),"%.2d%.2d%.2d%c%.2d%.2d%.1d",
 496                         (int)currentRA,(int)(currentRA*(double)60)%60,((int)(currentRA*(double)6000))%100,sign,
 497                         (int)dec,(int)(dec*(double)60)%60,((int)(dec*(double)600))%10);
 498         fprintf(stderr,"Goto %s\n", buffer);
 499
 500         snprintf(command,14,"P%s",buffer);
 501         buffer[14]=0;
 502         fprintf(stderr,"Goto command:%s\n", command);
 503         portWrite(command);
 504
 505         portRead(buffer,-1,TEMMA_TIMEOUT);
 506         if(command[0]=='R'){
 507                 return 0;
 508         }
 509         else
 510                 return -1;
 511 }
 512
 513 int extractRA(char *buf){
 514         int r,h,m,s;
 515         /*double dra;*/
 516
 517         r=atoi(buf);
 518         h=r/10000;
 519         m=r/100-100*h;
 520         s=(r%100)*.6;
 521         temmaRA=((double)h+((double)m + (double)s/60)/60);
 522         IDSetNumber (&eqTemma, NULL);
 523         /*      fprintf(stderr,"extractRA: %s %d %d %d %d %lf\n",buf,r,h,m,s,dra);*/
 524         return 0;
 525 }
 526
 527 int extractDEC(char *buf){
 528         int dec,d,m,s;
 529         /*double ddec;*/
 530
 531         dec=atoi(buf+1);
 532         d=dec/1000;
 533         m=dec/10-100*d;
 534         s=(dec%10)*6;
 535         temmaDec=((double)d+((double)m + (double)s/60)/60);
 536         if (*buf=='-')
 537                 temmaDec*=-1;
 538
 539         IDSetNumber (&eqTemma, NULL);
 540
 541
 542         /*      fprintf(stderr,"extractDEC: %s %d %d %d %d %lf\n",buf,dec,d,m,s,ddec);*/
 543         return 0;
 544 }
 545
 546
 547 int get_TemmaCurrentpos(char *local_buffer){
 548         char buf[16];
 549
 550         if (portWrite("E") < 0)
 551                 return -1;
 552
 553         if(portRead(local_buffer,-1,TEMMA_TIMEOUT)==SUCCESS){
 554                 if(strstr(local_buffer, "E")==local_buffer){
 555                         strncpy(buf,local_buffer+1,6);
 556                         buf[6]=0;
 557                         extractRA(buf);
 558
 559                         strncpy(buf,local_buffer+7,6);
 560                         buf[6]=0;
 561                         extractDEC(buf);
 562                         return 0;
 563                 }
 564                 else {
 565                         return -1;
 566                 }
 567         }
 568
 569         return 0;
 570 }
 571
 572 int set_TemmaCurrentpos(void) {
 573         /* Temma Sync */
 574         char buf[16], sign;
 575         double dec;
 576
 577         calcLST(buf);
 578         set_TemmaLST(buf);
 579         portWrite("Z");
 580         calcLST(buf);
 581         set_TemmaLST(buf);
 582
 583         dec=fabs(currentDec);
 584         if (currentDec>0){
 585                 sign='+';
 586         }
 587         else {
 588                 sign='-';
 589         }
 590
 591         sprintf(buffer,"%.2d%.2d%.2d%c%.2d%.2d%.1d",
 592                         (int)currentRA,(int)(currentRA*(double)60)%60,((int)(currentRA*(double)6000))%100,sign,
 593                         (int)dec,(int)(dec*(double)60)%60,((int)(dec*(double)600))%10);
 594         fprintf(stderr,"sync to %s %f %f\n", buffer,currentRA,dec);
 595
 596         snprintf(buf, sizeof(buf), "D%s",buffer);
 597         buf[13]=0;
 598         portWrite(buf);
 599         *buffer=0;
 600
 601         portRead(buffer,-1,TEMMA_TIMEOUT);
 602         if(buffer[0]=='R'){
 603                 return 0;
 604         }
 605         else{
 606                 return -1;
 607         }
 608 }
 609
 610 int do_TemmaSLEW(char mode){
 611         /*char command[16];*/
 612
 613         sprintf(buffer,"M%c",mode); /* see bit definition in Temmadriver.h */
 614
 615         if (portWrite(buffer) < 0)
 616                 return -1;
 617
 618         return 0;
 619 }
 620
 621 int get_TemmaVERSION(char *local_buffer){
 622         int err;
 623
 624         if ((err=portWrite("v")) < 0){
 625                 return err;
 626         }
 627
 628         portRead(local_buffer,-1,TEMMA_TIMEOUT);
 629         if(strstr(local_buffer, "ver")==local_buffer){
 630                 return 0;
 631         }
 632         else
 633                 return EREAD;
 634 }
 635
 636 int get_TemmaGOTOstatus(char *local_buffer){
 637         /*
 638            0 no ongoing goto
 639            1 ongoing Goto
 640            -1 error
 641          */
 642         if (portWrite("s") < 0)
 643                 return -1;
 644
 645         portRead(local_buffer,-1,TEMMA_TIMEOUT);
 646         if(strstr(local_buffer, "s")==local_buffer){
 647                 return 0;
 648         }
 649         else
 650                 return -1;
 651 }
 652
 653 int get_TemmaBOTHcorrspeed(char *local_buffer){
 654         if (portWrite("lg") < 0)
 655                 return -1;
 656         portRead(local_buffer,-1,TEMMA_TIMEOUT);
 657         if(strstr(local_buffer, "lg")==local_buffer){
 658                 return 0;
 659         }
 660         else
 661                 return -1;
 662 }
 663
 664 int get_TemmaDECcorrspeed(char *local_buffer){
 665         if (portWrite("lb") < 0)
 666                 return -1;
 667         portRead(local_buffer,-1,TEMMA_TIMEOUT);
 668         if(strstr(local_buffer, "lb")==local_buffer){
 669                 return 0;
 670         }
 671         else
 672                 return -1;
 673 }
 674
 675 int set_TemmaDECcorrspeed(char *local_buffer){
 676         char command[16];
 677
 678         snprintf(command, 4, "LB%s",local_buffer);
 679
 680         if (portWrite(command) < 0)
 681                 return -1;
 682         return 0;
 683 }
 684
 685 int get_TemmaRAcorrspeed(char *local_buffer){
 686         if (portWrite("la") < 0)
 687                 return -1;
 688
 689         portRead(local_buffer,-1,TEMMA_TIMEOUT);
 690         if(strstr(local_buffer, "la")==local_buffer){
 691                 return 0;
 692         }
 693         else
 694                 return -1;
 695 }
 696
 697 int set_TemmaRAcorrspeed(char *local_buffer){
 698         char command[16];
 699
 700         snprintf(command, 4,"LA%s",local_buffer);
 701
 702         if (portWrite(command) < 0)
 703                 return -1;
 704         return 0;
 705 }
 706
 707 int get_TemmaLatitude(char *local_buffer){
 708         if (portWrite("i") < 0)
 709                 return -1;
 710         portRead(local_buffer,-1,TEMMA_TIMEOUT);
 711         if(local_buffer[0]=='i'){
 712                 return 0;
 713         }
 714         else
 715                 return -1;
 716 }
 717
 718 int set_TemmaLatitude(char *local_buffer){
 719         char command[16];
 720         double lat;
 721         char sign;
 722
 723         lat=fabs(latitude);
 724         if (latitude>0){
 725                 sign='+';
 726         }
 727         else {
 728                 sign='-';
 729         }
 730
 731         sprintf(command,"I%c%.2d%.2d%.1d", sign,
 732                         (int)lat,
 733                         (int)(lat*(double)60)%60,
 734                         ((int)(lat*(double)600))%10);
 735
 736         if (portWrite(command) < 0)
 737                 return -1;
 738         return 0;
 739 }
 740
 741 int get_TemmaLST(char *local_buffer){
 742         if (portWrite("g") < 0)
 743                 return -1;
 744
 745         portRead(local_buffer,-1,TEMMA_TIMEOUT);
 746         if(local_buffer[0]=='g'){
 747                 return 0;
 748         }
 749         else
 750                 return -1;
 751 }
 752
 753
 754 int set_TemmaLST(char *local_buffer){
 755         char command[16];
 756         snprintf(command,7,"T%s",local_buffer);
 757
 758         if (portWrite(command) < 0)
 759                 return -1;
 760         return 0;
 761 }
 762
 763
 764 int get_TemmaCometTracking(char *local_buffer){
 765         if (portWrite("lm") < 0)
 766                 return -1;
 767         portRead(local_buffer,-1,TEMMA_TIMEOUT);
 768         if(strstr(local_buffer, "lm")==local_buffer){
 769                 return 0;
 770         }
 771         else
 772                 return -1;
 773 }
 774
 775 int set_TemmaStandbyState(int on){
 776         if (on){
 777                 return portWrite("STN-ON");
 778         }
 779         else{
 780                 return portWrite("STN-OFF");
 781         }
 782         return 0;
 783 }
 784
 785 int get_TemmaStandbyState(unsigned char *local_buffer){
 786         int nb;
 787         int status;
 788
 789         if ((nb=portWrite("STN-COD")) < 0){
 790                 IDSetSwitch (&RAmotorSw, "I/O error when asking RAmotor status");
 791                 return -1;
 792         }
 793
 794         if((status=portRead(local_buffer,-1,TEMMA_TIMEOUT)==SUCCESS)){
 795                 if(strstr(local_buffer, "stn")==local_buffer){
 796                         local_buffer[7]=0;
 797                         if (strstr(local_buffer,"on")){ /* stanby on */
 798                                 RAmotorSw.s = IPS_OK;
 799                                 RAmotor[0].s = ISS_OFF;
 800                                 RAmotor[1].s = ISS_ON;
 801                                 IDSetSwitch (&RAmotorSw, "RA motor is off.");
 802                         }
 803                         else{
 804                                 if (strstr(local_buffer,"off")){ /* stanby off */
 805                                         RAmotorSw.s = IPS_OK;
 806                                         RAmotor[0].s = ISS_ON;
 807                                         RAmotor[1].s = ISS_OFF;
 808                                         IDSetSwitch (&RAmotorSw, "RA motor is on.");
 809                                 }
 810                                 else {
 811                                         RAmotorSw.s = IPS_OK;
 812                                         IDSetSwitch (&RAmotorSw, "I/O error when getting RAmotor status");
 813                                 }
 814                         }
 815                 }
 816                 return 0;
 817         }
 818         if (status<=ETIMEOUT && status >=ECOMMAND){
 819                 IDSetSwitch(&RAmotorSw, "%s", errormes[ETIMEOUT - status]);
 820         }
 821
 822         return -1;
 823 }
 824
 825 int set_TemmaCometTracking(char *local_buffer){
 826         char command[16];
 827
 828         snprintf(command,15,"LM%s",local_buffer);
 829         if (portWrite(command) < 0)
 830                 return -1;
 831         return 0;
 832 }
 833
 834 int set_TemmaSolarRate(void){
 835         if (portWrite("LK") < 0)
 836                 return -1;
 837         return 0;
 838 }
 839
 840 int set_TemmaStellarRate(void){
 841         if (portWrite("LL") < 0)
 842                 return -1;
 843         return 0;
 844 }
 845
 846
 847 int switch_Temmamountside(void){
 848         if (portWrite("PT") < 0)
 849                 return -1;
 850         return 0;
 851 }
 852
 853 /**********************************************************************
 854  * Comm
 855  **********************************************************************/
 856
 857 int openPort(const char *portID) {
 858         struct termios ttyOptions;
 859
 860         if ( (fd = open(portID, O_RDWR)) == -1)
 861                 return -1;
 862         memset(&ttyOptions, 0, sizeof(ttyOptions));
 863         tcgetattr(fd, &ttyOptions);
 864
 865         /* 8 bit, enable read */
 866         ttyOptions.c_cflag |= CS8;
 867         /* parity */
 868         ttyOptions.c_cflag |= PARENB;
 869         ttyOptions.c_cflag &= ~PARODD;
 870         ttyOptions.c_cflag &= ~CSTOPB;
 871         ttyOptions.c_cflag |= CRTSCTS;
 872
 873         /* set baud rate */
 874         cfsetispeed(&ttyOptions, B19200);
 875         cfsetospeed(&ttyOptions, B19200);
 876
 877         /* set input/output flags */
 878         ttyOptions.c_iflag = IGNBRK;
 879
 880         /* Read at least one byte */
 881         ttyOptions.c_cc[VMIN] = 1;
 882         ttyOptions.c_cc[VTIME] = 5;
 883
 884         /* Misc. */
 885         ttyOptions.c_lflag = 0;
 886         ttyOptions.c_oflag = 0;
 887
 888         /* set attributes */
 889         tcsetattr(fd, TCSANOW, &ttyOptions);
 890
 891         /* flush the channel */
 892         tcflush(fd, TCIOFLUSH);
 893         return (fd);
 894 }
 895
 896 int portWrite(char * buf) {
 897   int nbytes=strlen(buf); /*, totalBytesWritten;*/
 898         int bytesWritten = 0;
 899         /*int retry=10;*/
 900
 901         bytesWritten = write(fd, buf, nbytes);
 902         bytesWritten += write(fd, "\r\n", 2);
 903         /*fprintf(stderr,"portwrite :%d octets %s\n", bytesWritten, buf);*/
 904
 905         if (bytesWritten!=nbytes+2){
 906                 perror("write error: ");
 907                 IDLog("Error writing to port");
 908                 return EWRITE;
 909         }
 910         return (bytesWritten);
 911 }
 912
 913 int portRead(char *buf, int nbytes, int timeout) {
 914         /*
 915            A very basic finite state machine monitors
 916            the bytes read ;
 917            state 0 : read regular bytes
 918            state 1 : just read a \n, waiting for a \r
 919            state 2 : read a \n and a \r, command is over.
 920
 921            Not sure it is useful here but I use a more
 922            sophisticated version of this with a GPS receiver
 923            and it is robust and reliable
 924
 925            We return a null terminated string.
 926          */
 927
 928   int bytesRead = 0, state=0, /*i=0,*/ current=0;
 929   /*int totalBytesRead = 0;*/
 930         int err;
 931
 932         if ( (err = TemmareadOut(timeout)) ){
 933                 switch (err){
 934                         case ETIMEOUT:
 935                                 IDLog("Error: timeout while reading");
 936                                 return err;
 937                 }
 938         }
 939
 940         while (read(fd,buf+bytesRead,1)==1){
 941                 /*              fprintf(stderr,"%c",buf[bytesRead]); */
 942                 fflush(NULL);
 943                 switch (state) {
 944                         case 0:
 945                                 if(buf[bytesRead]==13)
 946                                         state=1;
 947                                 break;
 948
 949                         case 1:
 950                                 if(buf[bytesRead]==10)
 951                                         state=2;
 952                                 else
 953                                         if(buf[bytesRead]==13)
 954                                                 state=1;
 955                                         else
 956                                                 state=0;
 957                                 break;
 958                 }
 959
 960                 ++current;
 961
 962                 if (state==2){
 963                         /*process(buf);*/
 964                         buf[bytesRead+1]=0;
 965                         state=current=0;
 966                         return SUCCESS;
 967                 }
 968
 969                 bytesRead=current;
 970         }
 971         return state;
 972 }
 973
 974 int TemmareadOut(int timeout) {
 975         struct timeval tv;
 976         fd_set readout;
 977         int retval;
 978
 979         FD_ZERO(&readout);
 980         FD_SET(fd, &readout);
 981
 982         /* wait for 'timeout' seconds */
 983         tv.tv_sec = timeout;
 984         tv.tv_usec = 0;
 985
 986         /* Wait till we have a change in the fd status */
 987         retval = select (fd+1, &readout, NULL, NULL, &tv);
 988
 989         /* Return 0 on successful fd change */
 990         if (retval > 0)
 991                 return 0;
 992         /* Return -1 due to an error */
 993         else if (retval == EREAD)
 994                 return retval;
 995         /* Return -2 if time expires before anything interesting happens */
 996         else {
 997                 return ETIMEOUT;
 998         }
 999 }
1000