API tools faq
paste
Advertisement
Stella_209

Medium1 goto

Stella_209
Jul 22nd, 2018
592
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 42.16 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  *  ArdEQ MEDIUM TELESCOPE CONTROL
  3.  *  Stepper motor control by Timer interrupt
  4.  *  by Agócs László
  5.  *  2018-07-29
  6.  *  __________________________________________________________________________
  7.  *  Ez a teszt a motorvezérlés ellenőrzésére szolgál az alapvető GOTO funkciók
  8.  *  nagy részének felhasználásával.
  9.  *  
  10.  *  SAJÁT PARANCSOK:
  11.  *  
  12.  *  IN    : Mechanika inicializálása
  13.  *  S     : START, csak óramű megy; Inicializálja a mechanikát
  14.  *  O     : STOP, mindkét motor áll;
  15.  *  IRnnn : RA motor "/lépés beállítása
  16.  *  IDnnn : DE motor "/lépés beállítása
  17.  *  SRn   : RATE beállítása: R0..9;
  18.  *  C     : Koordináták kiírása soros monitorra;
  19.  *  LGn   : Léptető motor pozíció lekérdezése (1=Ra,2=De)
  20.  *  L0n   : Léptető motor pozíció nullázása
  21.  *  LFnnn,nnn : Lépj ennyi fokot RA,DE:
  22.  *          pl. LF-15.45,+56.33 Ra-ban K-i irányba 15.45 fokot, De-ben É-ra 56.33 fokot
  23.  *  EW    : EEPROM-ba írás
  24.  *  EG    : EEPROM olvasása
  25.  *  EL    ? EEPROM listázása
  26.  *  ______________________________________________________________________________
  27.  *  Minden szög fokokban; Minden idő: órában; RTC időmérő UT-ben.
  28.  *  Az AccelStepper lépései jelzik a HA óraszöget. Induláskor ha meridiánból indulunk (default),
  29.  *  akkor a currentPosition-t 0-ra állítjuk. A DE prdig 90 fok, mert a távcső párhuzamos az RA tengellyel.
  30.  *  Az óraszög NY-ra pozitív, K-re negatív;
  31.  *  Ha szinkronizálunk, akkor kiszámítjuk a csillag óraszögét és átszámítjuk a meridiántól
  32.  *  való lépés számmá. Ugyan így járunk el parkolás utáni ébresztéskor.
  33.  *  Az aktuális RA,DE koordinátákat az LMST helyi csillagidőből és az óraszögből számítjuk:
  34.  *  RA = LMST - RA_SECSTEP*RAMot.currentPosition()/3600;
  35.  *  DE = DE_SECSTEP*DEMot.currentPosition()/3600;
  36.  */
  37.  
  38. #include <AccelStepper.h>
  39. #include <TimerOne.h>
  40. #include "DS3231.h"
  41. #include "EEPROM.h"
  42.  
  43. boolean debug = false;
  44.  
  45. // Válassz meghajtót: EASYDRIVER, CNC_V4
  46. #define CNC_V4 ;
  47.  
  48. // PIN DEFINITIONS
  49.  
  50. #if defined(CNC_V4)
  51.   //Stepper 1
  52.   #define RA_dirPin 2
  53.   #define RA_stepPin 5
  54.   #define RA_enablePin 8
  55.  
  56.   //Stepper 2
  57.   #define DE_dirPin 3
  58.   #define DE_stepPin 6
  59.   #define DE_enablePin 8
  60.  
  61.   #define RTC_SDA 4
  62.   #define RTC_SCL 5
  63. #endif
  64.  
  65. /*
  66. #if defined(EASYDRIVER)
  67.   //Stepper 1
  68.   #define RA_dirPin 9
  69.   #define RA_stepPin 10
  70.   #define RA_enablePin 2
  71.   //#define RA_MicroStep1Pin 3
  72.   //#define RA_MicroStep2Pin 4
  73.   //#define RA_MicroStep3Pin 3
  74.  
  75.   //Stepper 2
  76.   #define DE_dirPin 11
  77.   #define DE_stepPin 12
  78.   #define DE_enablePin 13
  79.   //#define DE_MicroStep1Pin 5
  80.   //#define DE_MicroStep2Pin 6
  81.   //#define DE_MicroStep3Pin 7
  82.  
  83. //  #define RTC_SDA A5
  84. //  #define RTC_SCL A4
  85. #endif
  86. */
  87. // Define a stepper and the pins it will use
  88. AccelStepper RAMot(AccelStepper::DRIVER, RA_stepPin, RA_dirPin);
  89. AccelStepper DEMot(AccelStepper::DRIVER, DE_stepPin, DE_dirPin);
  90.  
  91. // Init the DS3231 using the hardware interface
  92. DS3231  rtc(SDA, SCL);
  93.  
  94. #define Rad 57.29577951
  95.  
  96. // RATES : Ennyiszeres csillagsebesség : 0..9 értékekre
  97. double RATES[10] = { 0.5, 1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0, 256.0 };
  98.  
  99. // Távcső aktuális státusza: áll, óramű, pozícionál, kézi mozgatás, home, parkolt
  100. enum TStatus { none, tracking, moving, sleewing, guiding, parking, homed, parked };
  101. TStatus Status = tracking;
  102.  
  103. enum TDirect { dNone, dN, dS, dE, dW };   // a kézi mozgatás iránya: É,D,K,Ny
  104. TDirect Direct;
  105. byte DirectByte = 0;            // alsó 4 bit jelzi az irányokat: NSEW pl. 1001 = North és West
  106.  
  107. // A követés sebessége
  108. enum TTrackingMode {tmSideral, tmLunar, tmSolar, tmKing};
  109. TTrackingMode TrackingMode = tmSideral;
  110. double TrackingMul[4] = { 1.0, 0.979, 1.0, 1.00246 };  // Sebesség szorzók (1=Sideral)
  111.  
  112. // =========== VARIABLES ======================================
  113.  
  114. const byte numChars = 40;
  115. char charBuffer[numChars]; // an array to store the received data
  116. boolean newData = false;
  117.  
  118. double RA_SECSTEP = 24.80; // "/LÉPÉS (- előjel jelzi az ellentétes forgást a követéshez NY-i irányba)
  119. double DE_SECSTEP = 49.60; // "/LÉPÉS (- előjel jelzi az ellentétes forgást, hogy a De növekedjen)
  120. double RA_START   = 6.5;        // 6h30m  start pozíció (óra)
  121. double DE_START   = 8.5;        // 8.5 fok
  122. double RA_POS     = 30.0;       // 30.0 fok = 2h0m  aktuális pozíció (a lépésekből kalkulálva) (fok)
  123. double DE_POS     = 90.0;       // 45.5 fok
  124. double RA_TARGET  = 120.0;      // Ra cél : 8h0m
  125. double DE_TARGET  = 22.0;       // De cél : 22 fok
  126.  
  127. int    RA_MOVERATE = 8;               // 16x-os csillag sebesség
  128. int    DE_MOVERATE = 8;               // 16x-os csillag sebesség
  129. int    RA_SLEERATE = 8;               // 256x-os csillag sebesség
  130. int    DE_SLEERATE = 8;               // 256x-os csillag sebesség
  131. double RA_BASESPEED = 15.04/RA_SECSTEP;   // 1 sec alatt az égbolt 15"-et forsul -> 8.3... lépés/sec RA-ban a követéshez
  132. double DE_BASESPEED = 15.04/DE_SECSTEP;   // -> 3.5... lépés/sec DE-ben, a RA-val azonos sebességhez
  133. double RA_DEFSPEED  = RA_BASESPEED;   // Mentjük az óramű sebességet
  134. double RA_SPEED;                      // RA aktuális sebessége lépés/sec
  135. double DE_SPEED;                      // DE aktuális sebessége lépés/sec
  136. double GUIDING_RATE = 1.5;            // 1.5X-es csillagsebességű guiding
  137. double HOME_AZ      = 0;
  138. double HOME_ALT     = 0;
  139. long PARK_AZ        = 0;
  140. long PARK_ALT       = 0;
  141. boolean PARKED      = false;
  142.  
  143. Time   START_TIME;             // Induláskor megjegyezzük az időt
  144. Time   CURRENT_TIME;           // aktuális idő
  145. byte   BOUDRATE = 6;           // 9600 baud
  146.  
  147. String FIRMWARE_NAME  = "ArdEQ MEDIUM";
  148. byte   FIRMWARE_VER   = 1;
  149. String FIRMWARE_DATE  = "05/20/18";
  150. String FIRMWARE_TIME  = "12:00:00";
  151.  
  152. byte   TELESCOPE_TYPE = 1;    // Euatorial mount
  153. double LON = 20.2919304371;   // Your position to the Earth (West value - sign. My current position in the example, if you not have GPS receiver, Google Maps tell your cordinate's.)
  154. double LAT = 48.2167524154;   // Geographic latitude
  155. int    ZONE_OFFSET    = 1;    // UTC offset; UT = Zónaidő - ZONE_OFFSET;
  156. int    SUMMER_TIME    = 1;    // Nyári időszámításnál -1 óra;
  157. byte   DATAFORM       = 0;    // 0=fok; 1=radian
  158.  
  159. double GMST;                  // Greenwitch Mean Sidereal Time (Greenwitch-i helyi csillagidő) [óra]
  160. double LMST;                  // Local Sidereal Time = Helyi csillagidő (óra)
  161. double LHA;                   // A távcső óraszöge (fok). A meridiántól NY-ra +, K-re -;
  162.  
  163. String ch;
  164. String Command;
  165. String Parameter;
  166. long   interval = 200;        // 100 mikrosec = 0.0001 sec
  167. boolean highprecision=true;   // high precision
  168. boolean trackEnable = true;  // Óramű engedélyezése
  169.  
  170. double cosLat = cos(LAT/Rad);
  171. double sinLat = sin(LAT/Rad);  
  172.  
  173. // Config : adatok az EEPROM-ba
  174. struct CONFIG {
  175.               double  longitude;
  176.               double  latitude;
  177.               int     utcOffset;
  178.               double  ra_secperstep;
  179.               double  de_secperstep;
  180.               } config;
  181.  
  182.  
  183. #define EE_BOUDRATE         100      // byte       : Set baud rate: 1=56.7K, 2=38.4K, 3=28.8K, 4=19.2K, 5=14.4K, 6=9600, 7=4800, 8=2400, 9=1200
  184. #define EE_DATAFORM         101      // byte       : Adat formátum  : 0=fok, 1=Radián
  185. #define EE_TELESCOPE_TYPE   102      // byte       : Tipus : 0=Nem definiált, 1=Ekvatoriális, 2=Horizontális, 3=Villás
  186. #define EE_CLOCK_SPEED      103      // double     : Óraműves követés sebessége
  187. #define EE_HOME_AZ          110      // double     : Home pozíció AZIMUT
  188. #define EE_HOME_ALT         114      // double     : Home pozíció ALTITUDE
  189. #define EE_PARK_AZ          120      // double     : Home pozíció AZIMUT
  190. #define EE_PARK_ALT         124      // double     : Home pozíció ALTITUDE
  191. #define EE_PARKED           128      // byte       : Parkolás: 0=Nem, 1=Igen (Le volt parkolva Home pozícióba)
  192. #define EE_SLEEW_RATE       130      // byte       : Sleewing rate
  193.  
  194.   boolean gRa = false;
  195.   boolean gDe = false;
  196.  
  197. // _____________________________________________________________________
  198.  
  199. void setup()
  200. {
  201.   Serial.begin(9600);
  202.   rtc.begin();
  203.   // Pin 13 has an LED : jelzi az óramű léptetéseket
  204.   pinMode( 13, OUTPUT );
  205.  
  206. //  initEEPROMTable();
  207.  
  208.   initMount();
  209. }
  210.  
  211. void loop() {
  212.  
  213.   // SERIAL INPUT
  214.   if (readSerial()) {
  215.  
  216.      String remainString = "";
  217.      for (int i=0; i<30; i++) {
  218.         if (charBuffer[i]==0)
  219.             { break; }
  220.         else {
  221.             remainString += String(charBuffer[i]);
  222.         }
  223.      }
  224.  
  225.       remainString.trim();
  226.       boolean stringComplete = false;
  227.      
  228.       // This cycle is able to separate the sripped commands (LX200 style)
  229.       // Eg.: #:GR01:12:23#:GD12:23:34#:GR01:12:23#:GD12:23:34#
  230.  
  231.       while (!stringComplete)
  232.       {
  233.         if (String(remainString[0]) == "#") { remainString = remainString.substring(1,100); }
  234.         int n = remainString.indexOf("#");
  235.         Command = remainString.substring(1,3);
  236.         Parameter = remainString.substring(3,n);
  237.         remainString = remainString.substring(n+1,100);
  238.         remainString.trim();
  239.  
  240.         if (!doCommand(Command,Parameter) || (String(remainString[0]) != ":"))
  241.         {
  242.           stringComplete = true;
  243.         }
  244.          
  245.       } // while
  246.   }
  247.  
  248.   // Pozicion├íl├ís rutin
  249.   if ((Status==moving) || (Status==parking)) {
  250.     if (gRa) RAMot.runSpeedToPosition();
  251.     else RAMot.runSpeed();
  252.     if (gDe) DEMot.runSpeedToPosition();
  253.     else DEMot.runSpeed();
  254.  
  255.     if (gRa && (RAMot.distanceToGo() == 0) )
  256.     {
  257.       RA_SPEED = RA_BASESPEED;
  258.       RAMot.setSpeed(RA_SPEED);
  259.       gRa = false;
  260.     }
  261.     if ( gDe && (DEMot.isRunning() == false) )
  262.     {
  263.         gDe = false;
  264.         if (gRa==false) {
  265.           if (Status==parking) {
  266.             Status = parked;
  267.             PARKED = true;
  268.             byte p=1;
  269.             EEPROM.put(EE_PARKED,p);
  270.             trackEnable=false;
  271.           }
  272.           else {
  273.             Status = tracking;
  274.             RA_SPEED = RA_BASESPEED;
  275.             RAMot.setSpeed(RA_SPEED);
  276.           }
  277.         }
  278.     }
  279.  
  280.   }  
  281. }  // End Loop
  282.  
  283. boolean readSerial() {
  284.   static byte index;
  285.  
  286.   while (Serial.available() > 0) {     // Does serial1 have characters available?
  287.     char rc = Serial.read();           // Read a character
  288.    
  289.     if (rc == '\n') {                  // Is it newline?
  290.       charBuffer[index] = 0;           // Yes, so terminate char array with 0
  291.       index = 0;                       // Reset array index
  292.       newData = true;
  293.       return true;                     // Return true (we have a full line)
  294.     }
  295.     else {
  296.       charBuffer[index++] = rc;        // Yes, so store it and increment index
  297.       if (index > numChars) {          // Have we filled the buffer?
  298.         index--;                       // Yes, so decrement index
  299.       }
  300.     }
  301.   }
  302.   return false;                        // Return false (we don't have a full line)
  303. }
  304.  
  305. // Alapról inditja a mechanikát
  306. // Ha volt parkolás, akkor onnan, ha nem akkor alapbeálltással indexektől
  307. // -----------------------------
  308. void initMount() {
  309.   getEEPROMTable();
  310.  
  311.   START_TIME = rtc.getTime();
  312.   LMST = calculateLST();
  313.   RA_SPEED = RA_BASESPEED;
  314.   RA_DEFSPEED = RA_SPEED;
  315.  
  316.   // Alappontól indul a mechanika
  317.   if (!PARKED) {
  318.     RA_POS = -90.0;
  319.     RAMot.setCurrentPosition(RA_POS*3600/RA_SECSTEP);
  320.     LHA = 0;
  321.     DE_SPEED = 0;
  322.     DE_POS = 90.0;
  323.     DEMot.setCurrentPosition(DE_POS*3600/DE_SECSTEP);
  324.     Status = tracking;
  325.     trackEnable = true;
  326.   }
  327.   else { // Parkolásban van
  328.     Status = parked;
  329.     trackEnable = false;
  330.     aliveFromPark();
  331.   }
  332.  
  333.   RAMot.setMaxSpeed(1000.0);
  334.   DEMot.setMaxSpeed(1000.0);
  335.   RAMot.setSpeed(RA_SPEED);       // Óramű sebesség
  336.   DEMot.setSpeed(DE_SPEED);
  337.  
  338.   Timer1.initialize(interval);        // set a timer of length 100 microseconds (or 0.0001 sec - or 10 KHz
  339.   Timer1.attachInterrupt( timerIsr ); // attach the service routine here
  340. }
  341.  
  342.  
  343. /// -----------------------------------------------------------------
  344. /// ISR Timer Routine  > MOTOROK HAJTÁSA 1/10 000 sec-onként meghívva
  345. /// -----------------------------------------------------------------
  346. void timerIsr()
  347. {
  348.   switch (Status) {
  349.   case none: break;
  350.   case tracking: {
  351.     if (trackEnable) RAMot.runSpeed();
  352.     break;
  353.   }
  354.  
  355.   case moving:
  356.   {
  357. /*
  358.     Timer1.stop();
  359.     if (gRa) {
  360.         RAMot.runToPosition();
  361.         gRa = RAMot.isRunning();
  362.     }
  363.     else {
  364.       RA_SPEED = RA_BASESPEED;
  365.       RAMot.setSpeed(RA_SPEED);
  366.       RAMot.runSpeed();
  367.     }
  368.    
  369.     if (gDe) {
  370.       DEMot.runToPosition();
  371.       gDe = DEMot.isRunning();
  372.     }
  373.     else {
  374.       DE_SPEED = 0;
  375.       RAMot.setSpeed(DE_SPEED);
  376.       DEMot.runSpeed();
  377.     }
  378.  
  379.     if (!gRa && !gDe) Status=tracking;
  380.  
  381.     Timer1.resume();
  382.     break;
  383.   }
  384. */
  385. /*
  386.     if ((gRa) && (!gDe)) {
  387.       Timer1.stop();
  388.       Status = tracking;
  389.       Timer1.resume();
  390.     }
  391. */
  392. /*      
  393.           if (Status==parking) {
  394.             PARKED = true;
  395.             byte p=1;
  396.             EEPROM.put(EE_PARKED,p);
  397.             trackEnable=false;
  398.             Status = parked;
  399.             Serial.println("PARKED");
  400.           }
  401.           else Status = tracking;
  402.     }
  403. */
  404. /*
  405.     if (gRa && (RAMot.distanceToGo() == 0) )
  406.     {
  407.       RA_SPEED = RA_BASESPEED;
  408.       RAMot.setSpeed(RA_SPEED);
  409.       gRa = false;
  410.     }
  411.     if ( gDe && (DEMot.isRunning() == false) )
  412.     {
  413.         gDe = false;
  414.         if (gRa==false) {
  415.           RA_SPEED = RA_BASESPEED;
  416.           RAMot.setSpeed(RA_SPEED);
  417.           Status = tracking;
  418.         }
  419.     }
  420. */
  421.   break;
  422.   }
  423.  
  424.   case sleewing:
  425.   {
  426.     RAMot.runSpeed();
  427.     DEMot.runSpeed();
  428.     break;
  429.   }
  430.   case guiding:
  431.   {
  432.     if (abs(RAMot.distanceToGo())>0)
  433.       RAMot.run();
  434.     break;
  435.   }
  436.   default:
  437.   {
  438.   }
  439.   }
  440. }
  441.  
  442. // ========= LX200 =================================================================================
  443.  
  444. bool doCommand(String Comm, String Par)
  445. {
  446.   #define label kiki;
  447.   String replay;
  448.   char fmt;
  449.   char c;
  450.  
  451.   if (Comm[0]=='G')
  452.   {
  453.    
  454.     if (Comm == "GC") {
  455.         // Get Date
  456.         replay = rtc.getDateStr(FORMAT_SHORT,FORMAT_MIDDLEENDIAN,'/');
  457.         Serial.println(replay+"#");
  458.         goto kiki;
  459.     }
  460.     if (Comm == "GL") {
  461.         // Get Time
  462.         Time t;
  463.         t = rtc.getTime();
  464.         print_SC_GC_TIME(t);
  465.         goto kiki;
  466.     }
  467.     if (Comm == "GS") {
  468.         // Get Sideral Time
  469.         LMST = calculateLST();
  470.         Serial.println(RaToStr(LMST*15)+"#");
  471.         goto kiki;
  472.     }
  473.     if (Comm == "Gg") {
  474.         // Get longitude
  475.         Serial.println(DeToStr(LON)+"#");
  476.         goto kiki;
  477.     }
  478.     if (Comm == "Gt")  {
  479.         // Get latitude
  480.         Serial.println(DeToStr(LAT)+"#");
  481.         goto kiki;
  482.     }
  483.     if (Comm == "Gr") {
  484.         // Get target RA
  485.         Serial.println(RaToStr(RA_TARGET)+"#");
  486.         goto kiki;
  487.     }
  488.     if (Comm == "Gd") {
  489.         // Get target De
  490.         Serial.println(DeToStr(DE_TARGET)+"#");
  491.         goto kiki;
  492.     }
  493.     if (Comm == "GR") {
  494.         // Get telescope RA
  495.         getRA();
  496.         Serial.println(RaToStr(RA_POS)+"#");
  497.         goto kiki;
  498.     }
  499.     if (Comm == "GD") {
  500.         // Get telescope DE
  501.         double de_ = getDE();
  502.         Serial.println(DeToStr(de_)+"#");
  503.         goto kiki;
  504.     }
  505.     if (Comm == "GT") {
  506.         // Get sidereal rate RA
  507.         goto kiki;
  508.     }
  509.     // *********** FIRMWARE ************
  510.     if (Comm == "GV") {
  511.         if (Par == "P"){
  512.             // Get firmware name
  513.             Serial.println(FIRMWARE_NAME+String("#")); }
  514.         if (Par == "N") {
  515.             // Get firmware ID
  516.             Serial.println(String(FIRMWARE_VER)+String("#")); }
  517.         if (Par == "D") {
  518.             // Get firmware Date
  519.             Serial.println(FIRMWARE_DATE+String("#"));  }
  520.         if (Par == "T") {
  521.             // Get firmware Time
  522.             Serial.println(String(FIRMWARE_TIME)+String("#"));  }
  523.         goto kiki;
  524.     }
  525.  
  526.   } // if G
  527.  
  528.  
  529.   if (Comm[0]=='S') {
  530.    
  531.     if (Comm == "SC") {
  532.         // Set Date
  533.         Time t;
  534.         t = strToDate( Par );
  535.         rtc.setDate( t.date, t.mon, t.year );
  536.         command_ok(true);
  537.         goto kiki;
  538.     }
  539.    
  540.     if (Comm == "SL") {
  541.         // Set Time
  542.         Time t;
  543.         t = strToTime( Par );
  544.         rtc.setTime( t.hour, t.min, t.sec );
  545.         command_ok(true);
  546.         goto kiki;
  547.     }
  548.    
  549.     if (Comm == "Sg") {
  550.         // * Set longitude
  551.         LON = StrToDe(Par);
  552.         command_ok(true);
  553. //        Par.toCharArray(rep,Par.length()+1);
  554. //        command_ok( dmsToDouble(&LON,rep,true) );
  555.         goto kiki;
  556.     }
  557.    
  558.     if (Comm == "St") {
  559.         // *Set latitude
  560.         LAT = StrToDe(Par);
  561.         command_ok(true);
  562.         goto kiki;
  563.     }
  564.      
  565.     // ********* Telescope control **********
  566.  
  567.     if (Comm == "Sr") {
  568.         // Set target RA
  569.         RA_TARGET = StrToRa(Par);
  570.         command_ok( true );
  571.         goto kiki;
  572.     }
  573.  
  574.     if (Comm == "Sd") {
  575.         // Set target De
  576.         DE_TARGET = StrToDe(Par);
  577.         command_ok( true );
  578.         goto kiki;
  579.     }
  580.  
  581.   } // If S
  582.  
  583.     if (Comm == "MS") {
  584.         // Move telescope (to current Equ target)
  585.         command_ok( gotoTarget() );
  586.         goto kiki;
  587.     }
  588.  
  589.     if (Comm == "Q")  {
  590.         // Stop telescope
  591.         Status = none;
  592.         goto kiki;
  593.     }
  594.  
  595.     // ******** Slew commands *********
  596.    
  597.        if (Comm[0] == 'M')
  598.        {
  599.             c = Comm[1];
  600.             if (c == 'n') Direct = dN;
  601.             if (c == 's') Direct = dS;
  602.             if (c == 'e') Direct = dE;
  603.             if (c == 'w') Direct = dW;
  604.             sleewControl( Direct, true );
  605.             goto kiki;
  606.        }
  607.  
  608.        if (Comm[0] == 'Q')
  609.        {
  610.             c = Comm[1];
  611.             if (c == 'n') Direct = dN;
  612.             if (c == 's') Direct = dS;
  613.             if (c == 'e') Direct = dE;
  614.             if (c == 'w') Direct = dW;
  615.             if (c == 'o') Direct = dNone;
  616.             sleewControl( Direct, false );
  617.             goto kiki;
  618.        }
  619.  
  620.     // ******** TRACKING **********
  621.    
  622.     if (Comm == "ST") {
  623.         // Set sidereal rate RA
  624.         RA_BASESPEED = Par.toFloat();
  625.         goto kiki;
  626.     }
  627.     if (Comm == "TR") {
  628.         // Track sidereal rate RA (default)
  629.         RA_BASESPEED = TrackingMul[0]*RA_DEFSPEED;
  630.         goto kiki;
  631.     }
  632.     if (Comm == "TQ") {
  633.         // Track sidereal rate reset
  634.         RA_BASESPEED = RA_DEFSPEED;
  635.         goto kiki;
  636.     }
  637.     if (Comm == "TL") {
  638.         // Track LUNAR rate RA
  639.         RA_BASESPEED = TrackingMul[1]*RA_DEFSPEED;
  640.         goto kiki;
  641.     }
  642.     if (Comm == "TS") {
  643.         // Track SOLAR rate RA
  644.         RA_BASESPEED = TrackingMul[2]*RA_DEFSPEED;
  645.         goto kiki;
  646.     }
  647.     if (Comm == "TK") {
  648.         // Track KING rate RA
  649.         RA_BASESPEED = TrackingMul[3]*RA_DEFSPEED;
  650.         goto kiki;
  651.     }
  652.  
  653.     if (Comm == "T+")  {
  654.         // Track rate increase 0.02Hz
  655.             if (RA_BASESPEED>0)
  656.               RA_BASESPEED += 0.01;
  657.             else
  658.               RA_BASESPEED -= 0.01;
  659.             RA_SECSTEP = 15.04 / RA_BASESPEED;
  660.             Serial.println(RA_BASESPEED,4);
  661.             goto kiki;
  662.     }
  663.     if (Comm == "T-") {
  664.         // Track rate decrease 0.02Hz
  665.             if (RA_BASESPEED>0)
  666.               RA_BASESPEED -= 0.01;
  667.             else
  668.               RA_BASESPEED += 0.01;
  669.             RA_SECSTEP = 15.04 / RA_BASESPEED;
  670.             Serial.println(RA_BASESPEED,4);
  671.             goto kiki;
  672.     }
  673.  
  674.     if (Comm == "Te") {
  675.         // Tracking enable
  676.         trackEnable = true;
  677.         goto kiki;
  678.     }
  679.     if (Comm == "Td") {
  680.         // Tracking disable
  681.         trackEnable = false;
  682.         goto kiki;
  683.     }
  684.  
  685.     // ******** Sync. command **********
  686.  
  687.     if (Comm == "CS") {
  688.         // Sync. with current target RA/Dec
  689.         synctoTarget();
  690.         goto kiki;
  691.     }
  692.     if (Comm == "CM") {
  693.         // Sync. with current target RA/Dec
  694.         synctoTarget();
  695.         Serial.println("N/A");
  696.         goto kiki;
  697.     }
  698.  
  699.     // Park Commands ----------------------------------------------
  700.    
  701.     if (Comm == "hQ") {
  702.         // Set park position
  703.         // A motor poziciókat mentjük
  704.         PARK_AZ = RAMot.currentPosition();
  705.         PARK_ALT = DEMot.currentPosition();
  706.         EEPROM.put(EE_PARK_AZ,(long)PARK_AZ);
  707.         EEPROM.put(EE_PARK_ALT,(long)PARK_ALT);
  708.         command_ok(true);
  709.         goto kiki;
  710.     }
  711.     if (Comm == "hP") {
  712.         // Move to park position
  713.         EEPROM.get(EE_PARK_AZ,PARK_AZ);
  714.         EEPROM.get(EE_PARK_ALT,PARK_ALT);
  715.        
  716.         long d1 = RAMot.currentPosition() - PARK_AZ;
  717.         long d2 = DEMot.currentPosition() - PARK_ALT;
  718.         stepTo(d1,d2,parking);
  719.         Status = parking;
  720.         trackEnable = false;
  721.         command_ok(true);
  722.         goto kiki;
  723.     }
  724.     if (Comm == "hR") {
  725.         // Restore parked telescope to operation
  726.         aliveFromPark();
  727.     }
  728.    
  729. // * SAJÁT PARANCSOK ( * karakterrel kezdődnek pl. *SR8 ) ***************************************
  730.  
  731.        if ((Comm == "S") || (Comm == "s"))
  732.        {    // távcső indítás
  733.             trackEnable = true;
  734.             Status = tracking;
  735.             Timer1.resume();
  736.             digitalWrite( 13, HIGH );
  737.             goto kiki;
  738.        }
  739.        
  740.        if ((Comm == "O") || (Comm == "o"))
  741.        {    // Távcső stop
  742.             Status = none;
  743.             trackEnable = false;
  744.             digitalWrite( 13, LOW );
  745.             goto kiki;
  746.        }
  747.  
  748.        if ((Comm == "IN") || (Comm == "in")) {
  749.             // Távcső inicializálás alaphelyzetből
  750.             initMount();
  751.             goto kiki;
  752.        }
  753.  
  754.        if ((Comm == "IR") || (Comm == "ir")) {
  755.             // RA "/lépés megadása
  756.             if (Par != "")
  757.             RA_SECSTEP = Par.toFloat();
  758.             RA_BASESPEED = 15.04/RA_SECSTEP;
  759.             goto kiki;
  760.        }
  761.        if ((Comm == "ID") || (Comm == "id")) {
  762.            // DE "/lépés megadása
  763.            if (Par != "")
  764.             DE_SECSTEP = Par.toFloat();
  765.             goto kiki;
  766.        }
  767.  
  768.        if ((Comm == "SR") || (Comm == "sr")) {
  769.             // Sleew rate beállítás
  770.             if (Par != "") {
  771.               int rate = Par.toInt();
  772.               if (rate>9) rate=9;
  773.               RA_SLEERATE = rate;
  774.               DE_SLEERATE = rate;
  775.             }
  776.             goto kiki;
  777.        }
  778.  
  779.        if ((Comm == "LG") || (Comm == "lg")) {
  780.           // Léptető motor pozíció lekérdezése (:LG1#)
  781.           if (Par=="1")  Serial.println(RAMot.currentPosition());
  782.           if (Par=="2")  Serial.println(DEMot.currentPosition());
  783.           goto kiki;
  784.        }
  785.        
  786.        if ((Comm == "L0") || (Comm == "l0")) {
  787.           // Léptető motor pozíció nullázáds
  788.           if (Par=="1")  RAMot.setCurrentPosition(0);
  789.           if (Par=="2")  DEMot.setCurrentPosition(0);
  790.           goto kiki;
  791.        }
  792.        
  793.        if ((Comm == "LF") || (Comm == "lf")) {
  794.           // Lépj ennyi fokot RA,DE irányokba (:LF12.3,-4.5#)
  795.           double dRa_ = 0;
  796.           double dDe_ = 0;
  797.           String ct;          
  798.           int n = Par.indexOf(",");
  799.           if (n>-1) {
  800.               ct = Par.substring(0,n);
  801.               dRa_ = ct.toFloat();
  802.           }
  803.           if (n>-1) {
  804.               ct = Par.substring(n+1);
  805.               dDe_ = ct.toFloat();
  806.           }
  807.           moveDeg(dRa_,dDe_);
  808.           goto kiki;
  809.        }
  810.  
  811.        if ((Comm == "EW") || (Comm == "ew")) {
  812.           initEEPROMTable();
  813.        }
  814.        if ((Comm == "EG") || (Comm == "eg")) {
  815.           getEEPROMTable();
  816.        }
  817.        if ((Comm == "EL") || (Comm == "el")) {
  818.           listEEPROMTable();
  819.        }
  820.  
  821.        if (Comm == "C") {
  822.             // Koordináták lekérdezése
  823.             getCoords();
  824.             Serial.print( "RA: " );
  825.             Serial.print( RA_POS );
  826.             Serial.print( " DE: " );
  827.             Serial.println( DE_POS );
  828.             goto kiki;
  829.        }
  830.  
  831.        if (Comm == "PS") {
  832.             // Státusz kiírás
  833.             printStatus;
  834.             goto kiki;
  835.        }
  836.  
  837. kiki:
  838.     statusControl();
  839.     return true;
  840.  
  841. }
  842.  
  843.  
  844. // ************************************************************************
  845. //printf emulator
  846. void prf(char *fmt, ... ){
  847.          char tmp[128]; // resulting string limited to 128 chars
  848.          va_list args;
  849.          va_start (args, fmt );
  850.          vsnprintf(tmp, 128, fmt, args);
  851.          va_end (args);
  852.          Serial.print(tmp);
  853.  }
  854.  
  855.  
  856. void command_ok(boolean oke){
  857.   if (oke)
  858.      Serial.print("1");
  859.   else
  860.      Serial.print("0");
  861. }
  862.  
  863. void print_SC_GC_DATE(Time t) {
  864.      prf("%02d/%02d/%02d#",t.date, t.mon, t.year);
  865. }
  866.  
  867. void print_SC_GC_TIME(Time t) {
  868.      prf("%02d:%02d:%02d#",t.hour, t.min, t.sec);
  869. }
  870.  
  871. // --------------------------------------------------------------------------------
  872. // HELYI CSILLAGIDŐ KISZÁMÍTÁSA
  873. // RTC idő alapján
  874. // return LST [órában], 15-tel szorozni, ha fokokban akarjuk!
  875. // --------------------------------------------------------------------------------
  876. double calculateLST() // Calculate Local Sidereal Time
  877. {
  878.   Time now = rtc.getTime();
  879.   double LST = getLST(now);
  880.   return LST;     // Órában megadva
  881. }
  882.  
  883.  
  884. // HELYI CSILLAGIDŐ KISZÁMÍTÁSA
  885. // t idő alapján
  886. // return LST [órában], 15-tel szorozni, ha fokokban akarjuk!
  887. // --------------------------------------------------------------------------------
  888. double getLST( Time t ) {
  889.  
  890.   double M, Y, D, MN, H, S;
  891.   double A, B, C, E, F;
  892.  
  893.   M = (int)t.mon;
  894.   Y = (int)t.year;
  895.   D = (int)t.date;
  896.   MN = (int)t.min;
  897.   H = (int)t.hour;  //- (TIMEZONE + DST); // Hours must be GMT/UT. The RTC is UT!
  898.   S = (int)t.sec;
  899.  
  900.   if (M < 3) {
  901.     M += 12;
  902.     Y -= 1;
  903.   }
  904.  
  905.   A = (long)Y / 100;
  906.   B = (long)A / 4;
  907.   C = (long)2 - A + B;
  908.   E = (long)(365.25 * (Y + 4716));
  909.   F = (long)(30.6001 * (M + 1));
  910.  
  911.   double LastJDN = C + D + E + F - 1524.5; // Julian day last midnight UT
  912.   double Current_d = LastJDN - 2451545.0; //Days since Year 2000
  913.   long Current_T = Current_d / 36525; // Julian centuries since Year 2000
  914.   long NewJDN = LastJDN + H / 24; // Julian day today
  915.  
  916.   double Term1 = 6.697374558; // this line must be a double!
  917.   double Term2 = 0.06570982441908 * Current_d;
  918.  
  919.   H = H + ((double)MN / 60) + ((double)S / 3600);
  920.  
  921. //  float GMST;
  922.   float Term3;
  923.  
  924.   Term3 = 0.00273790935 * H;
  925.   Term3 += H;
  926.   GMST = Term1 + Term2 + Term3; // Terms are found at http://aa.usno.navy.mil/faq/docs/GAST.php
  927.  
  928.   //add on longitude divided by 15 to get LST
  929.  
  930.   double LST = GMST + (LON / 15); // longitude as hour angle.
  931.  
  932.  //reduce it to 24 format
  933.  
  934.   int LSTint;
  935.   LSTint = (int)LST;
  936.   LSTint /= 24;
  937.   LST = LST - (double)LSTint * 24;
  938.  
  939.   return LST;     // Órában megadva
  940. }
  941.  
  942. /*
  943. // Coordinate conversion
  944.  
  945. // --------------------------------------------------------------------------------
  946. // convert equatorial coordinates to horizon
  947. // this takes approx. 1.4mS on a 16MHz Mega2560
  948. // (minden fokokban)
  949.  
  950. void EquToHor(double HA, double Dec, double *Alt, double *Azm) {
  951.   while (HA<0.0)    HA=HA+360.0;
  952.   while (HA>=360.0) HA=HA-360.0;
  953.   HA =HA/Rad;
  954.   Dec=Dec/Rad;
  955.   double SinAlt = (sin(Dec) * sinLat) + (cos(Dec) * cosLat * cos(HA));  
  956.   *Alt   = asin(SinAlt);
  957.   double t1=sin(HA);
  958.   double t2=cos(HA)*sinLat-tan(Dec)*cosLat;
  959.   *Azm=atan2(t1,t2)*Rad;
  960.   *Azm=*Azm+180.0;
  961.   *Alt=*Alt*Rad;
  962. }
  963.  
  964.      
  965. // --------------------------------------------------------------------------------
  966. // convert horizon coordinates to equatorial
  967. // this takes approx. 1.4mS
  968. // (minden fokokban)
  969.  
  970. void HorToEqu(double Alt, double Azm, double *HA, double *Dec) {
  971.   while (Azm<0)      Azm=Azm+360.0;
  972.   while (Azm>=360.0) Azm=Azm-360.0;
  973.   Alt  = Alt/Rad;
  974.   Azm  = Azm/Rad;
  975.   double SinDec = (sin(Alt) * sinLat) + (cos(Alt) * cosLat * cos(Azm));  
  976.   *Dec = asin(SinDec);
  977.   double t1=sin(Azm);
  978.   double t2=cos(Azm)*sinLat-tan(Alt)*cosLat;
  979.   *HA=atan2(t1,t2)*Rad;
  980.   *HA=*HA+180.0;
  981.   *Dec=*Dec*Rad;
  982. }
  983. */
  984.  
  985.  
  986.  
  987. // String and Conversion routines
  988. // A MM/DD/YY formátumú dátumot szétszedi numerikus értékekre
  989. Time strToDate( String dString ) {
  990.   Time t;
  991.   String s;
  992.   s = dString.substring(0,2);
  993.   t.mon = s.toInt();
  994.   s = dString.substring(3,5);
  995.   t.date = s.toInt();
  996.   s = dString.substring(6,8);
  997.   t.year = s.toInt();
  998.   if (t.year < 2000) t.year += 2000;
  999.   return t;
  1000. }
  1001.  
  1002. // strToTime ( Time )
  1003. // A MM/DD/YY formátumú dátumot ad vissza
  1004. String dateToStr( Time t) {
  1005.  String s,ds;
  1006.  s = String(t.year);
  1007.  ds = String(t.mon)+"/"+String(t.date)+"/"+s.substring(2,4);
  1008.  return ds;
  1009. }
  1010.  
  1011.  
  1012. Time strToTime(String dString ) {
  1013.   Time t;
  1014.   String s;
  1015.   s = dString.substring(0,2);
  1016.   t.hour = s.toInt();
  1017.   s = dString.substring(3,5);
  1018.   t.min = s.toInt();
  1019.   s = dString.substring(6,8);
  1020.   t.sec = s.toInt();
  1021.   return t;
  1022. }
  1023.  
  1024. // Adatok formattálása : fmtStr("%03d:%02d:%02d",h,abs(m),abs(s));
  1025. // --------------------------------------------------------------------------------
  1026. String fmtStr(char *fmt, ... ) {
  1027.   char tmp[128]; // resulting string limited to 128 chars
  1028.   String s="";
  1029.   va_list args;
  1030.   va_start (args, fmt );
  1031.   vsnprintf(tmp, 128, fmt, args);
  1032.   va_end (args);
  1033.   for (int i=0; i<30; i++) {
  1034.         if (tmp[i]==0)  break;
  1035.         else s += String(tmp[i]);
  1036.   }
  1037.   return s;
  1038. }
  1039.  
  1040. // Fokokban adott Ra-ból HH:MM:SS stringet képez
  1041. // --------------------------------------------------------------------------------
  1042. String RaToStr(float Ra)
  1043. {
  1044.   double Ra_ = timeRange(Ra/15);
  1045.   int h = (int)Ra_;
  1046.   int m = ((Ra_ - h) * 60);
  1047.   int s = (((Ra_ - h) * 60) - m) * 60;
  1048.   return fmtStr("%02d:%02d:%02d",h,m,abs(s));
  1049. }
  1050.  
  1051. // Fokokban adott De-ból HH:MM:SS stringet képez
  1052. // --------------------------------------------------------------------------------
  1053. String DeToStr(float De)
  1054. {
  1055.   String sign="+";
  1056.   if (De<0) sign="-";
  1057.   int angle = (int)De;
  1058.   int h = (int)De;
  1059.   int m = ((De - h) * 60);
  1060.   int s = (((De - h) * 60) - m) * 60;
  1061.   return sign+fmtStr("%02d*%02d:%02d",h,abs(m),abs(s));
  1062. }
  1063.  
  1064. // hh:mm:ss formájú RA-ból fok
  1065. // --------------------------------------------------------------------------------
  1066. double StrToRa(String sRa)
  1067. {
  1068.   String c;
  1069.   c = sRa.substring(0,2);
  1070.   int h = c.toInt();
  1071.   c = sRa.substring(3,5);
  1072.   double m = c.toFloat();
  1073.   c = sRa.substring(6);
  1074.   c.trim();
  1075.   double s = c.toFloat();
  1076.   double d = double(h + (m/60) + (s/3600))*15.0;
  1077.   return d;
  1078. }
  1079.  
  1080. // -ff:mm:ss formájú DE-ből fok
  1081. // --------------------------------------------------------------------------------
  1082. double StrToDe(String sDe)
  1083. {
  1084.   String c;
  1085.   int sign=0;
  1086.   c = sDe.charAt(0);
  1087.   if ((c=="+") || (c=="-"))  sign = 1;
  1088.   c = sDe.substring(sign+0,sign+2);
  1089.   int h = c.toInt();
  1090.   c = sDe.substring(sign+3,sign+5);
  1091.   double m = c.toFloat();
  1092.   c = sDe.substring(sign+6,sign+8);
  1093.   double s = c.toFloat();
  1094.   double d = (h + abs(m/60) + abs(s/3600));
  1095.   c = sDe.charAt(0);
  1096.   if (c=="-") d = -d;
  1097.   Serial.println(d);
  1098.   return d;
  1099. }
  1100.  
  1101. // Date/Time routines
  1102. // ==============================================================================
  1103.  
  1104. void setRTCDate(String dString)
  1105. {
  1106.   Time t;
  1107.   t = strToDate( dString );
  1108.   rtc.setDate( t.date, t.mon, t.year);
  1109. }
  1110.  
  1111. void setRTCTime(String dString)
  1112. {
  1113.   Time t;
  1114.   t = strToTime( dString );
  1115.   rtc.setTime( t.hour, t.min, t.sec );
  1116. }
  1117.  
  1118. // -----------------------------------------------------------------------------------------------------------------------------
  1119. // Misc. numeric conversion
  1120.  
  1121. double timeRange(double t) {
  1122.   while (t>=24.0) t-=24.0;
  1123.   while (t<  0.0) t+=24.0;
  1124.   return t;
  1125. }
  1126.  
  1127. double haRange(double d) {
  1128.   while (d>=180.0) d-=360.0;
  1129.   while (d<-180.0) d+=360.0;
  1130.   return d;
  1131. }
  1132.  
  1133. double degRange(double d) {
  1134.   while (d>=360.0) d-=360.0;
  1135.   while (d<  0.0)  d+=360.0;
  1136.   return d;
  1137. }
  1138.  
  1139. double dist(double a, double b) {
  1140.   if (a>b) return a-b; else return b-a;
  1141. }
  1142.  
  1143. double angDist(double h, double d, double h1, double d1) {
  1144.   return acos(sin(d/Rad)*sin(d1/Rad)+cos(d/Rad)*cos(d1/Rad)*cos((h1-h)/Rad))*Rad;
  1145. }
  1146.  
  1147. // integer numeric conversion with error checking
  1148. boolean atoi2(char *a, int *i) {
  1149.   char *conv_end;
  1150.   long l=strtol(a,&conv_end,10);
  1151.  
  1152.   if ((l<-32767) || (l>32768) || (&a[0]==conv_end)) return false;
  1153.   *i=l;
  1154.   return true;
  1155. }
  1156.  
  1157. double frac(double v) {
  1158.   return v - ((long)v);
  1159. }
  1160.  
  1161. double cot(double n) {
  1162.   return 1.0/tan(n);
  1163. }
  1164.  
  1165.  
  1166. // ============ EEPROM routins ==================================================================
  1167.  
  1168. void EEPROM_WriteString(int address, String st)
  1169. {
  1170.   int n = st.length();
  1171.   for (int i=1; i<=n; i++)
  1172.   {
  1173.     EEPROM.put(address++,(char)st[i-1]);         // To store data
  1174.   }
  1175.   EEPROM.put(address++, (byte)0);                 // To store data
  1176. }
  1177.  
  1178. String EEPROM_ReadString(int address)
  1179. {
  1180.   String st = "";
  1181.   char ch;
  1182.   int i=0;
  1183.   do
  1184.   {
  1185.     EEPROM.get(address++, ch);                    // To store data
  1186.     if (ch != 0) {
  1187.         st += ch;
  1188.       }
  1189.   }  while (ch != 0);
  1190.   return st;
  1191. }
  1192.  
  1193. // Inicializálja az EEPROM adatait
  1194. void initEEPROMTable()
  1195. {
  1196.   config.longitude = LON;
  1197.   config.latitude = LAT;
  1198.   config.utcOffset = ZONE_OFFSET;
  1199.   config.ra_secperstep = RA_SECSTEP;
  1200.   config.de_secperstep = DE_SECSTEP;
  1201.   EEPROM.put(0,config);
  1202.   EEPROM.put(EE_BOUDRATE,(byte)BOUDRATE);
  1203.   EEPROM.put(EE_DATAFORM,(byte)0);
  1204.   EEPROM.put(EE_TELESCOPE_TYPE,(byte)0);
  1205.   EEPROM.put(EE_CLOCK_SPEED,(double)RA_BASESPEED);
  1206.   EEPROM.put(EE_HOME_AZ,(double)HOME_AZ);
  1207.   EEPROM.put(EE_HOME_ALT,(double)HOME_ALT);
  1208.   EEPROM.put(EE_PARK_AZ,(long)PARK_AZ);
  1209.   EEPROM.put(EE_PARK_ALT,(long)PARK_ALT);
  1210.   if (PARKED)
  1211.     EEPROM.put(EE_PARKED,(byte)1);
  1212.   else
  1213.     EEPROM.put(EE_PARKED,(byte)0);
  1214. }
  1215.  
  1216. // Kiolvassa az EEPROM adatait
  1217. void getEEPROMTable()
  1218. {
  1219.   Timer1.stop();
  1220.   EEPROM.get(0,config);
  1221.   LON = config.longitude;
  1222.   LAT = config.latitude;
  1223.   ZONE_OFFSET = config.utcOffset;
  1224.   RA_SECSTEP = config.ra_secperstep;
  1225.   DE_SECSTEP = config.de_secperstep;
  1226.   RA_BASESPEED = 15.04 / RA_SECSTEP;
  1227.   DE_BASESPEED = 15.04 / DE_SECSTEP;
  1228.   EEPROM.get(EE_BOUDRATE,     BOUDRATE);
  1229.   EEPROM.get(EE_DATAFORM,     DATAFORM);
  1230.   EEPROM.get(EE_TELESCOPE_TYPE, TELESCOPE_TYPE);
  1231.   EEPROM.get(EE_CLOCK_SPEED,  RA_BASESPEED);
  1232.   EEPROM.get(EE_HOME_AZ,      HOME_AZ);
  1233.   EEPROM.get(EE_HOME_ALT,     HOME_ALT);
  1234.   EEPROM.get(EE_PARK_AZ,      PARK_AZ);
  1235.   EEPROM.get(EE_PARK_ALT,     PARK_ALT);
  1236.   byte p=0;
  1237.   EEPROM.get(EE_PARKED,p);
  1238.   if (p==1) PARKED=true; else PARKED=false;
  1239.   Status = tracking;
  1240.   Timer1.resume();
  1241. }
  1242.  
  1243.  
  1244. void listEEPROMTable()
  1245. {
  1246.      getEEPROMTable();
  1247.      Serial.println("Product Name :"+FIRMWARE_NAME);
  1248.      Serial.println("Ver.: "+FIRMWARE_VER);
  1249.      Serial.println("Date: "+FIRMWARE_DATE);
  1250.      Serial.println("Time: "+FIRMWARE_TIME);
  1251.      Serial.print("Lon:  "); Serial.println(LON);
  1252.      Serial.print("Lat:  "); Serial.println(LAT);
  1253.      Serial.print("Zone: "); Serial.println(ZONE_OFFSET);
  1254.      Serial.print("Bous: "); Serial.println(BOUDRATE);
  1255.      Serial.print("Data: "); Serial.println(DATAFORM);
  1256.      Serial.print("STEP_RA    :"); Serial.println(RA_SECSTEP);
  1257.      Serial.print("STEP_DE    :"); Serial.println(DE_SECSTEP);
  1258.      Serial.print("CLOCK_SPEED:"); Serial.println(RA_BASESPEED);
  1259.      Serial.print("HOME_AZ    :"); Serial.println(HOME_AZ);
  1260.      Serial.print("HOME_ALT   :"); Serial.println(HOME_ALT);
  1261.      Serial.print("PARK_AZ    :"); Serial.println(PARK_AZ);
  1262.      Serial.print("PARK_ALT   :"); Serial.println(PARK_ALT);
  1263.      Serial.print("Parked     :");
  1264.      if (PARKED) Serial.println("YES");
  1265.      else Serial.println("NO");
  1266. }
  1267.  
  1268.  
  1269.  
  1270.  
  1271. // ------------ UTASÍTÁSOK ---------------------------------------------------------------
  1272.  
  1273. // Kézi mozgatás előkészítése, kontrolja
  1274. void sleewControl(TDirect dir, boolean Enable)
  1275. {
  1276.  
  1277.   if (Enable) {
  1278.     switch (dir) {
  1279.     case dN:
  1280.       {
  1281.               DirectByte |= 8;
  1282.               if ((DirectByte & 4)>0) DirectByte ^= 4;
  1283.               break;        
  1284.       }
  1285.     case dS:  
  1286.       {
  1287.               DirectByte |= 4;
  1288.               if ((DirectByte & 8)>0) DirectByte ^= 8;
  1289.               break;        
  1290.       }
  1291.     case dE:  
  1292.       {
  1293.               DirectByte |= 2;
  1294.               if ((DirectByte & 1)>0) DirectByte ^= 1;
  1295.               break;
  1296.       }
  1297.     case dW:
  1298.       {
  1299.               DirectByte |= 1;
  1300.               if ((DirectByte & 2)>0) DirectByte ^= 2;
  1301.               break;      
  1302.       }
  1303.     }
  1304.   }
  1305.   else {
  1306.     switch (dir) {
  1307.     case dNone:
  1308.       {
  1309.               DirectByte = 0;
  1310.               break;      
  1311.       }
  1312.     case dN:
  1313.       {
  1314.               if ((DirectByte & 8)>0) DirectByte ^= 8;
  1315.               break;      
  1316.       }
  1317.     case dS:  
  1318.       {
  1319.               if ((DirectByte & 4)>0) DirectByte ^= 4;
  1320.               break;      
  1321.       }
  1322.     case dE:  
  1323.       {
  1324.               if ((DirectByte & 2)>0) DirectByte ^= 2;
  1325.               break;      
  1326.       }
  1327.     case dW:
  1328.       {
  1329.               if ((DirectByte & 1)>0) DirectByte ^= 1;
  1330.               break;        
  1331.       }
  1332.     }
  1333.   }
  1334.  
  1335.     if (DirectByte>0) Status = sleewing;
  1336.        else Status = tracking;
  1337. }
  1338.  
  1339. void statusControl() {
  1340.  
  1341.        switch (Status) {
  1342.        case none:
  1343.        {
  1344.           DirectByte = 0;
  1345.           RA_SPEED = 0;
  1346.           DE_SPEED = 0;
  1347.           break;
  1348.        }
  1349.        case tracking:
  1350.        {
  1351.           DirectByte = 0;
  1352.           RA_SPEED = RA_BASESPEED;
  1353.           DE_SPEED = 0;
  1354.           break;
  1355.        }
  1356.        case moving:
  1357.        {
  1358. //          RA_SPEED =  0; // RATES[RA_MOVERATE] * RA_BASESPEED ;
  1359. //          DE_SPEED =  0; // RATES[DE_MOVERATE] * DE_BASESPEED ;
  1360.           break;
  1361.        }
  1362.        case sleewing:
  1363.        {
  1364.           // Kézi NY-ra
  1365.           if ((DirectByte & 1)==1) {
  1366.             RA_SPEED = RATES[RA_SLEERATE] * RA_BASESPEED;
  1367.           }
  1368.           // Kézi K-ra
  1369.           if ((DirectByte & 2)==2) {
  1370.             RA_SPEED = -RATES[RA_SLEERATE] * RA_BASESPEED;
  1371.           }
  1372.           // Kézi D-re
  1373.           if ((DirectByte & 4)==4) {
  1374.             DE_SPEED = -RATES[DE_SLEERATE] * DE_BASESPEED;
  1375.           }
  1376.           // Kézi É-ra
  1377.           if ((DirectByte & 8)==8) {
  1378.             DE_SPEED = RATES[DE_SLEERATE] * DE_BASESPEED;
  1379.           }
  1380.          
  1381.  
  1382.           // Ha nincs K-NY-i mozg+ás, akkor vissza óramű sebességre
  1383.           if ( (DirectByte & 3) == 0 ) RA_SPEED = RA_BASESPEED;
  1384.           else RA_SPEED = 10*RA_SPEED;
  1385.          
  1386.           // Ha nincs É-D-i mozgás, akkor a DE sebesség 0
  1387.           if ( (DirectByte & 12) == 0) DE_SPEED = 0;
  1388.           else DE_SPEED = 10*DE_SPEED*RA_SECSTEP/DE_SECSTEP;
  1389.          
  1390.        }
  1391.        } // End switch
  1392.  
  1393.        RAMot.setSpeed( RA_SPEED );
  1394.        DEMot.setSpeed( DE_SPEED );
  1395. }
  1396.  
  1397.  
  1398. double getRA()
  1399. {
  1400.   double fok;
  1401.   LMST = calculateLST();
  1402.   getDE();
  1403.   if (DE_POS > 90.0)
  1404.     fok = 15*LMST + RA_SECSTEP*RAMot.currentPosition()/3600;
  1405.   else
  1406.     fok = 15*LMST - RA_SECSTEP*RAMot.currentPosition()/3600;
  1407. //  if (DE_POS > 90.0) fok = fok + 180;
  1408.   if (fok>180)  fok = fok-360;
  1409.   if (fok<-180) fok = fok+360;
  1410.   RA_POS = fok;
  1411.   return RA_POS;
  1412. }
  1413.  
  1414. double getDE()
  1415. {
  1416.   DE_POS = DE_SECSTEP*DEMot.currentPosition()/3600;
  1417.   double de_ = DE_POS;
  1418.   if (DE_POS > 90.0) de_ = 90.0 - (DE_POS - 90.0);
  1419.   return de_;
  1420. }
  1421.  
  1422. void getCoords()
  1423. {
  1424.   CURRENT_TIME = rtc.getTime();
  1425.   RA_POS = getRA();
  1426.   DE_POS = getDE();
  1427. }
  1428.  
  1429. // MoveDeg: RA és DE irányokban lép ennyi fokot
  1430. void moveDeg(double dRa, double dDe)
  1431. {
  1432.   // Abszolut lépésekbe átszámtás
  1433.   Status = tracking;
  1434.   long d1 = dRa * 3600 / RA_SECSTEP;
  1435.   long d2 = dDe * 3600 / DE_SECSTEP;
  1436.   stepTo(d1,d2,moving);
  1437. }
  1438.  
  1439. // A Ra és De motorok ennyit lépjenek
  1440. void stepTo(long d1, long d2, TStatus sta) {
  1441.   Status = none;
  1442.   RA_SPEED = RA_BASESPEED;
  1443.   if (d1==0) gRa=false;
  1444.   else {
  1445.     gRa=true;
  1446.     RAMot.move(d1);
  1447.     RA_SPEED = 6*RATES[RA_MOVERATE] * RA_BASESPEED ;
  1448.   }
  1449.   if (d2==0) gDe=false;
  1450.   else {
  1451.     gDe=true;
  1452.     DEMot.move(d2);
  1453.     DE_SPEED = 6*RATES[DE_MOVERATE] * DE_BASESPEED ;
  1454.   }
  1455.   RAMot.setSpeed(RA_SPEED);
  1456.   DEMot.setSpeed(DE_SPEED);
  1457.   Status = sta;
  1458. }
  1459.  
  1460. // --------------------------------------------------------------------------------
  1461. // ÓRASZÖG KISZÁMÍTÁSA:
  1462. // --------------------------------------------------------------------------------
  1463. // lst: csillagidő fokokban; RA: csillag RA-ja fokokban
  1464. // Ha lst az 1. csillag, RA pedig a 2. csillag ra-ja fokokban, akkor a két csillag
  1465. //    ra külömbségét kapjuk NY-ra +, K-re - értékkel;
  1466. // lha: óraszög (fok). Ny-i irány pozítív.
  1467. // --------------------------------------------------------------------------------
  1468. double getLHA(double lst, double RA)
  1469. {
  1470.   double lha = lst - RA;
  1471.   double diff  = lha;
  1472.   if (abs(diff)>180)
  1473.     if (diff<-180) lha = 360 + diff;
  1474.     else lha = 360 - diff;
  1475.   return lha;
  1476. }
  1477. /*
  1478. boolean aboveHorizon(double ra_, double de_) {
  1479.   double AZ;
  1480.   double ALT;
  1481.   EquToHor( getLHA(LMST,ra_), de_, &AZ, &ALT );
  1482.   if (ALT>0) return true;
  1483.   return false;
  1484. }
  1485. */
  1486. // A cél koordinátákkal meghatározott pozícióba mozgás
  1487. boolean gotoTarget() {
  1488. //  if (aboveHorizon(RA_TARGET,DE_TARGET))
  1489. //  {
  1490.   getCoords();
  1491.   double L = getLHA(RA_POS,RA_TARGET);    // Óraszög eltérés
  1492.   double D = DE_TARGET - DE_POS;
  1493.   moveDeg(L,D);
  1494.   return true;
  1495. //  }
  1496. //  else
  1497. //  return false;
  1498. }
  1499.  
  1500. void synctoTarget() {
  1501.   getRA();
  1502.   double dRA = 3600 * (RA_POS - RA_TARGET) / RA_SECSTEP;   // lépés számmá alakítás
  1503.   double dDE = 3600 * (DE_TARGET) / DE_SECSTEP;
  1504.   RAMot.setCurrentPosition( long(RAMot.currentPosition() + dRA) );
  1505.   DEMot.setCurrentPosition( long( dDE) );
  1506.   RA_POS = RA_TARGET;        
  1507.   DE_POS = DE_TARGET;
  1508. }
  1509.  
  1510. // Ébresztés parkolásból
  1511. void aliveFromPark() {
  1512.   getEEPROMTable();
  1513.   if (PARKED) {
  1514.     RAMot.setCurrentPosition( PARK_AZ );
  1515.     DEMot.setCurrentPosition( PARK_ALT );
  1516.     getCoords();
  1517.     PARKED = false;
  1518.     byte p=0;
  1519.     EEPROM.put(EE_PARKED,p);
  1520.     RAMot.setSpeed(RA_BASESPEED);
  1521.     DEMot.setSpeed(0);
  1522.     Status = tracking;
  1523.   }
  1524. }
  1525.  
  1526. void printStatus() {
  1527. Serial.print("Status: ");
  1528.     switch (Status) {
  1529.     case none:      { Serial.println("None"); break;}
  1530.     case tracking:  { Serial.println("Tracking"); break;}
  1531.     case moving:    { Serial.println("Moving"); break;}
  1532.     case sleewing:  { Serial.println("Sleewing"); break;}
  1533.     case guiding:   { Serial.println("Guiding"); break;}
  1534.     default:        { Serial.println("Default"); break;}
  1535.     }
  1536. }
  1537.  
  1538. /*
  1539.  *
  1540.  *
  1541.  */
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!