Instrument Neutral Distributed Interface INDI  1.9.5
scopesim_helper.cpp
Go to the documentation of this file.
1 /*
2  * scopesim_helper.cpp
3  *
4  * Copyright 2020 Chris Rowland <chris.rowland@cherryfield.me.uk>
5  *
6  * implementation of telescope simulator helper classes Angle, Axis and Alignment
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
21  * MA 02110-1301, USA.
22  */
23 
24 #include "scopesim_helper.h"
25 
26 #include "indilogger.h"
27 
29 
30 // Angle implementation
31 
33 {
34  switch(type)
35  {
36  case DEGREES:
37  angle = range(value);
38  break;
39  case HOURS:
40  angle = range(value * 15.0);
41  break;
42  case RADIANS:
43  angle = range(value * 180.0 / M_PI);
44  break;
45  }
46 }
47 
48 double Angle::radians() { return this->angle * M_PI / 180.0; }
49 
50 bool Angle::operator== (const Angle& a)
51 {
52  return std::abs(difference(a)) < 10E-6;
53 }
54 
55 bool Angle::operator!= (const Angle& a)
56 {
57  return std::abs(difference(a)) >= 10E-6;
58 }
59 
61 
62 // Axis Implementation
63 
64 void Axis::setDegrees(double degrees)
65 {
66  this->position = degrees;
67  this->target = degrees;
68 }
69 
70 void Axis::setHours(double hours)
71 {
72  this->position = hours * 15.0;
73  this->target = hours * 15.0;
74 }
75 
77 {
78  LOGF_DEBUG("%s StartSlew to %f", axisName, angle.Degrees());
79  target = angle;
80  isSlewing = true;
81 }
82 
83 void Axis::Tracking(bool enabled)
84 {
85  tracking = enabled;
86  LOGF_EXTRA1("%s Teacking enabled %s", axisName, enabled ? "true" : "false");
87 }
88 
90 {
91  trackingRate = rate;
92  switch (trackingRate)
93  {
96  break;
97  case AXIS_TRACK_RATE::SIDEREAL:
98  TrackingRateDegSec = siderealRate;
99  break;
100  case AXIS_TRACK_RATE::SOLAR:
101  TrackingRateDegSec = solarRate;
102  break;
103  case AXIS_TRACK_RATE::LUNAR:
104  TrackingRateDegSec = lunarRate;
105  break;
106  }
107  LOGF_EXTRA1("%s: TrackRate %i, trackingRateDegSec %f arcsec", axisName, trackingRate, TrackingRateDegSec.Degrees() * 3600);
108 }
109 
111 {
112  return trackingRate;
113 }
114 
115 void Axis::StartGuide(double rate, uint32_t durationMs)
116 {
117  // rate is fraction of sidereal, signed to give the direction
118 
119  guideRateDegSec = (360.0 / 86400) * rate;
120  guideDuration = durationMs / 1000.0;
121  LOGF_DEBUG("%s StartGuide rate %f=>%f, dur %d =>%f", axisName, rate, guideRateDegSec.Degrees(), durationMs, guideDuration);
122 }
123 
124 void Axis::update() // called about once a second to update the position and mode
125 {
126  struct timeval currentTime { 0, 0 };
127 
128  /* update elapsed time since last poll, don't presume exactly POLLMS */
129  gettimeofday(&currentTime, nullptr);
130 
131  if (lastTime.tv_sec == 0 && lastTime.tv_usec == 0)
132  lastTime = currentTime;
133 
134  // Time diff in seconds
135  double interval = currentTime.tv_sec - lastTime.tv_sec + (currentTime.tv_usec - lastTime.tv_usec) / 1e6;
136  lastTime = currentTime;
137  double change = 0;
138 
139  //LOGF_DEBUG("%s: position %f, target %f, interval %f", axisName, position.Degrees(), target.Degrees(), interval);
140 
141  // tracking
142  if (isTracking())
143  {
144  position += TrackingRateDegSec * interval;
145  target += TrackingRateDegSec * interval;
146  //LOGF_EXTRA1("%s: tracking, rate %f, position %f, target %f", axisName, TrackingRateDegSec.Degrees(), position.Degrees(), target.Degrees());
147  }
148 
149  // handle the slew
150  if (isSlewing)
151  {
152  // get positions relative to the rotate centre
153  Angle trc = target - rotateCentre;
154  Angle prc = position - rotateCentre;
155  // get the change, don't use Angle so the change goes through the rotate centre
156  double delta = trc.Degrees() - prc.Degrees();
157  double fastChange = mcRates[4].Degrees() * interval;
158  double slowChange = fastChange / 5;
159  //LOGF_DEBUG("slew: trc %f prc %f, delta %f", trc.Degrees(), prc.Degrees(), delta);
160  // apply the change to the relative position
161  const char * b;
162  if (delta < -fastChange)
163  {
164  change = -fastChange;
165  b = "--";
166  }
167  else if (delta < -slowChange)
168  {
169  change = -slowChange;
170  b = "-";
171  }
172  else if (delta > fastChange)
173  {
174  change = fastChange;
175  b = "++";
176  }
177  else if (delta > slowChange)
178  {
179  change = slowChange;
180  b = "+";
181  }
182  else
183  {
184  position = target;
185  isSlewing = false;
186  //OnMoveFinished();
187  b = "=";
188  }
189  position += change;
190  //LOGF_DEBUG("move %s: change %f, position %f", b, change, position.Degrees());
191  }
192 
193  // handle the motion control
194  if (mcRate < 0)
195  {
196  change = -mcRates[-mcRate].Degrees() * interval;
197  //LOGF_DEBUG("mcRate %d, rate %f, change %f", mcRate, mcRates[-mcRate].Degrees(), change);
198  position += change;
199  }
200  else if (mcRate > 0)
201  {
202  change = mcRates[mcRate].Degrees() * interval;
203  //LOGF_DEBUG("mcRate %d, rate %f, change %f", mcRate, mcRates[mcRate].Degrees(), change);
204  position += change;
205  }
206 
207  // handle guiding
208  if (guideDuration > 0)
209  {
210  change = guideRateDegSec.Degrees() * (guideDuration > interval ? interval : guideDuration);
211  guideDuration -= interval;
212  //LOGF_DEBUG("guide rate %f, remaining duration %f, change %f", guideRateDegSec.Degrees(), guideDuration, change);
213  position += change;
214  }
215 }
216 
218 
219 // Alignment methods
220 
222 {
224 }
225 
226 void Alignment::mountToApparentHaDec(Angle primary, Angle secondary, Angle * apparentHa, Angle* apparentDec)
227 {
228  Angle prio, seco;
229  // get instrument place
230  switch (mountType)
231  {
232  case MOUNT_TYPE::ALTAZ:
233  case MOUNT_TYPE::EQ_FORK:
234  seco = (latitude >= 0) ? secondary : -secondary;
235  prio = primary;
236  break;
237  case MOUNT_TYPE::EQ_GEM:
238  seco = (latitude >= 0) ? secondary : -secondary;
239  prio = primary;
240  if (seco > 90 || seco < -90)
241  {
242  // pointing state inverted
243  seco = Angle(180.0 - seco.Degrees());
244  prio += 180.0;
245  }
246  break;
247  }
248  // instrument to observed, ignore apparent
249  instrumentToObserved(prio, seco, apparentHa, apparentDec);
250  // finally rotate an AltAzm mount to the Ha/Dec coordinates
251  if (mountType == MOUNT_TYPE::ALTAZ)
252  {
253  Angle rot = latitude - Angle(90);
254  Vector haDec = Vector(prio, seco).rotateY(rot);
255  *apparentHa = haDec.primary();
256  *apparentDec = haDec.secondary();
257  LOGF_EXTRA1("m2a Azm Alt %f, %f Ha Dec %f, %f rot %f", prio.Degrees(), seco.Degrees(), apparentHa->Degrees(), apparentDec->Degrees(), rot.Degrees());
258  }
259 }
260 
261 void Alignment::mountToApparentRaDec(Angle primary, Angle secondary, Angle * apparentRa, Angle* apparentDec)
262 {
263  Angle ha;
264  mountToApparentHaDec(primary, secondary, &ha, apparentDec);
265  *apparentRa = lst() - ha;
266  LOGF_EXTRA1("mountToApparentRaDec %f, %f to ha %f, ra %f, %f", primary.Degrees(), secondary.Degrees(), ha.Degrees(), apparentRa->Degrees(), apparentDec->Degrees());
267 }
268 
269 void Alignment::apparentHaDecToMount(Angle apparentHa, Angle apparentDec, Angle* primary, Angle* secondary)
270 {
271  // convert to Alt Azm first
272  if (mountType == MOUNT_TYPE::ALTAZ)
273  {
274  // rotate the apparent HaDec vector to the vertical
275  // TODO sort out Southern Hemisphere
276  Vector altAzm = Vector(apparentHa, apparentDec).rotateY(Angle(90) - latitude);
277  // for now we are making no mount corrections
278  // this all leaves me wondering if the GEM corrections should be done before the mount model
279  *primary = altAzm.primary();
280  *secondary = altAzm.secondary();
281  LOGF_EXTRA1("a2M haDec %f, %f Azm Alt %f, %f", apparentHa.Degrees(), apparentDec.Degrees(), primary->Degrees(), secondary->Degrees() );
282  }
283  // ignore diurnal abberations and refractions to get observed ha, dec
284  // apply telescope pointing to get instrument
285  Angle instrumentHa, instrumentDec;
286  observedToInstrument(apparentHa, apparentDec, &instrumentHa, &instrumentDec);
287 
288  switch (mountType)
289  {
290  case MOUNT_TYPE::ALTAZ:
291  break;
292  case MOUNT_TYPE::EQ_FORK:
293  *secondary = (latitude >= 0) ? instrumentDec : -instrumentDec;
294  *primary = instrumentHa;
295  break;
296  case MOUNT_TYPE::EQ_GEM:
297  *secondary = instrumentDec;
298  *primary = instrumentHa;
299  // use the instrument Ha to select the pointing state
300  if (instrumentHa < flipHourAngle)
301  {
302  // pointing state inverted
303  *primary += Angle(180);
304  *secondary = Angle(180) - instrumentDec;
305  }
306  if (latitude < 0)
307  *secondary = -*secondary;
308  break;
309  }
310 }
311 
312 void Alignment::apparentRaDecToMount(Angle apparentRa, Angle apparentDec, Angle* primary, Angle* secondary)
313 {
314  Angle ha = lst() - apparentRa;
315  apparentHaDecToMount(ha, apparentDec, primary, secondary);
316  LOGF_EXTRA1("apparentRaDecToMount ra %f, ha %f, %f to %f, %f", apparentRa.Degrees(), ha.Degrees(), apparentDec.Degrees(), primary->Degrees(), secondary->Degrees());
317 }
318 
319 #define NEW
320 
321 void Alignment::instrumentToObserved(Angle instrumentHa, Angle instrumentDec, Angle * observedHa, Angle* observedDec)
322 {
323  static Angle maxDec = Angle(89);
324 
325  // do the corrections consecutively
326  // apply Ha and Dec zero offsets
327  *observedHa = instrumentHa + IH;
328  *observedDec = instrumentDec + ID;
329 
330  // apply collimation (cone) error, limited to CH * 10
331  double cosDec = *observedDec < maxDec ? std::cos(observedDec->radians()) : std::cos(maxDec.radians());
332  double tanDec = *observedDec < maxDec ? std::tan(observedDec->radians()) : std::tan(maxDec.radians());
333 
334  *observedHa += (CH / cosDec);
335  // apply Ha and Dec axis non perpendiculary, limited to NP * 10
336  *observedHa += (NP * tanDec);
337 
338  // Use rotations so the corrections work at the pole
339  // apply polar axis Azimuth error using rotation in the East, West, Pole plane (X)
340  Vector vMa = Vector(*observedHa, *observedDec).rotateX(MA);
341 
342  // apply polar axis elevation error using rotation in the North, South, Pole plane (Y)
343  Vector vMe = vMa.rotateY(Angle(ME));
344 
345  *observedHa = vMe.primary();
346  *observedDec = vMe.secondary();
347 }
348 
349 void Alignment::observedToInstrument(Angle observedHa, Angle observedDec, Angle * instrumentHa, Angle *instrumentDec)
350 {
351 #ifdef NEW
352 
353  // avoid errors near dec 90 by limiting sec and tan dec to 57
354  static Angle maxDec = Angle(89);
355 
356  // do the corrections consecutively
357  // use vector rotations for MA and ME so they work close to the pole
358  // rotate about the EW axis (Y)
359  Vector vMe = Vector(observedHa, observedDec).rotateY(Angle(-ME));
360 
361  // apply polar axis Azimuth error
362  Vector vMa = vMe.rotateX(-MA);
363 
364  *instrumentHa = vMa.primary();
365  *instrumentDec = vMa.secondary();
366 
367  // apply Ha and Dec axis non perpendiculary, limited to maxDec
368  double tanDec = *instrumentDec < maxDec ? std::tan(instrumentDec->radians()) : std::tan(maxDec.radians());
369  *instrumentHa -= (NP * tanDec);
370  // apply collimation (cone) error, limited to maxDec
371  double cosDec = *instrumentDec < maxDec ? std::cos(instrumentDec->radians()) : std::cos(maxDec.radians());
372  *instrumentHa -= (CH / cosDec);
373 
374  // apply Ha and Dec zero offsets
375  *instrumentHa -= IH;
376  *instrumentDec -= ID;
377 
378 #else
379 
380 
381  Angle correctionHa, correctionDec;
382  correction(observedHa, observedDec, &correctionHa, &correctionDec);
383  // subtract the correction to get a first pass at the instrument
384  *instrumentHa = observedHa - correctionHa;
385  *instrumentDec = observedDec - correctionDec;
386 
387  static const Angle minDelta(1.0/3600.0); // 1.0 arc seconds
388  Angle dHa(180);
389  Angle dDec(180);
390  int num = 0;
391  while ( num < 10)
392  {
393  // use the previously calculated instrument to get a new position
394  Angle newHa, newDec;
395  correction(*instrumentHa, *instrumentDec, &correctionHa, &correctionDec);
396  newHa = *instrumentHa + correctionHa;
397  newDec = *instrumentDec + correctionDec;
398  // get the deltas
399  dHa = observedHa - newHa;
400  dDec = observedDec - newDec;
401 // LOGF_DEBUG("observedToInstrument %i: observed %f, %f, new %f, %f, delta %f, %f", num,
402 // observedHa.Degrees(), observedDec.Degrees(),
403 // newHa.Degrees(), newDec.Degrees(), dHa.Degrees(), dDec.Degrees());
404  if (Angle(fabs(dHa.Degrees())) < minDelta && Angle(fabs(dDec.Degrees())) < minDelta)
405  {
406  return;
407  }
408  // apply the delta
409  *instrumentHa += dHa;
410  *instrumentDec += dDec;
411  num++;
412  }
413  LOGF_DEBUG("mountToObserved iterations %i, delta %f, %f", num, dHa.Degrees(), dDec.Degrees());
414 #endif
415 }
416 
417 // corrections based on the instrument position, add to instrument to get observed
418 // see Patrick Wallace's white paper for details
419 void Alignment::correction(Angle instrumentHa, Angle instrumentDec, Angle * correctionHa, Angle * correctionDec)
420 {
421  // apply Ha and Dec zero offsets
422  *correctionHa = IH;
423  *correctionDec = ID;
424 
425  // avoid errors near dec 90 by limiting sec and tan dec to 100
426  static const double minCos = 0.01;
427  static const double maxTan = 100.0;
428 
429  double cosDec = std::cos(instrumentDec.radians());
430  if (cosDec >= 0 && cosDec < minCos) cosDec = minCos;
431  else if (cosDec <= 0 && cosDec > -minCos) cosDec = -minCos;
432 
433  double tanDec = std::tan(instrumentDec.radians());
434  if (tanDec > maxTan) tanDec = maxTan;
435  if (tanDec < -maxTan) tanDec = -maxTan;
436 
437  double cosHa = std::cos(instrumentHa.radians());
438  double sinHa = std::sin(instrumentHa.radians());
439 
440  // apply collimation (cone) error, limited to CH * 10
441  *correctionHa += (CH / cosDec);
442  // apply Ha and Dec axis non perpendiculary, limited to NP * 10
443  *correctionHa += (NP * tanDec);
444 
445  // apply polar axis Azimuth error
446  *correctionHa += (-MA * cosHa * tanDec);
447  *correctionDec += (MA * sinHa);
448 
449  // apply polar axis elevation error
450  *correctionHa += (ME * sinHa * tanDec);
451  *correctionDec += (ME * cosHa);
452 
453  LOGF_EXTRA1("correction %f, %f", correctionHa->Degrees(), correctionDec->Degrees());
454 }
455 
456 #ifdef FALSE
458 {
459  // rotate by IH and ID
460  Vector vIh = HaDec.rotateZ(Angle(IH));
461  Vector vId = vIh.rotateX(Angle(ID));
462 }
463 #endif
464 
465 void Alignment::setCorrections(double ih, double id, double ch, double np, double ma, double me)
466 {
467  IH = ih;
468  ID = id;
469  CH = ch;
470  NP = np;
471  MA = ma;
472  ME = me;
473  LOGF_DEBUG("setCorrections IH %f, ID %f, CH %f, NP %f, MA %f, ME %f", IH, ID, CH, NP, MA, ME);
474 }
475 
477 
478 // Vector methods
479 
480 Vector::Vector(double x, double y, double z)
481 {
482  double len = std::sqrt(x * x + y * y + z * z);
483  L = x / len;
484  M = y / len;
485  N = z / len;
486 }
487 
488 Vector::Vector(Angle primary, Angle secondary)
489 {
490  double sp = std::sin(primary.radians());
491  double cp = std::cos(primary.radians());
492  double ss = std::sin(secondary.radians());
493  double cs = std::cos(secondary.radians());
494 
495  L = cs * cp;
496  M = cs * sp;
497  N = ss;
498 }
499 
501 {
502  double len = length();
503  L /= len;
504  M /= len;
505  N /= len;
506 }
507 
509 {
510  Angle a = Angle(atan2(M, L), Angle::RADIANS);
511  //IDLog("primary %f", a.Degrees());
512  return a;
513 }
514 
516 {
517  Angle a = Angle(std::asin(N), Angle::RADIANS);
518  //IDLog("secondary %f", a.Degrees());
519  return a;
520 }
521 
523 {
524  double ca = std::cos(angle.radians());
525  double sa = std::sin(angle.radians());
526  return Vector(L, M * ca + N * sa, N * ca - M * sa);
527 }
528 
530 {
531  double ca = std::cos(angle.radians());
532  double sa = std::sin(angle.radians());
533  return Vector(L * ca - N * sa, M, L * sa + N * ca);
534 }
535 
537 {
538  double ca = std::cos(angle.radians());
539  double sa = std::sin(angle.radians());
540  return Vector(L * ca + M * sa, M * ca - L * sa, N);
541 }
Alignment::instrumentToObserved
void instrumentToObserved(Angle instrumentHa, Angle instrumentDec, Angle *observedHa, Angle *observedDec)
Definition: scopesim_helper.cpp:321
Alignment::mountToApparentHaDec
void mountToApparentHaDec(Angle primary, Angle secondary, Angle *apparentHa, Angle *apparentDec)
mountToApparentHaDec: convert mount position to apparent Ha, Dec
Definition: scopesim_helper.cpp:226
Angle::DEGREES
@ DEGREES
Definition: scopesim_helper.h:70
Alignment::longitude
Angle longitude
Definition: scopesim_helper.h:372
Angle::Angle
Angle()
Definition: scopesim_helper.h:72
Alignment::apparentRaDecToMount
void apparentRaDecToMount(Angle apparentRa, Angle apparentDec, Angle *primary, Angle *secondary)
Definition: scopesim_helper.cpp:312
Vector::Vector
Vector()
Vector creates an empty vector.
Definition: scopesim_helper.h:510
Vector::rotateZ
Vector rotateZ(Angle angle)
rotateZ rotates this vector through angle about the Z axis
Definition: scopesim_helper.cpp:536
Vector::length
double length()
Definition: scopesim_helper.h:529
Alignment::id
double id()
Definition: scopesim_helper.h:406
Alignment::apparentHaDecToMount
void apparentHaDecToMount(Angle apparentHa, Angle apparentDec, Angle *primary, Angle *secondary)
apparentHaDecToMount
Definition: scopesim_helper.cpp:269
Alignment::np
double np()
Definition: scopesim_helper.h:407
Angle::radians
double radians()
radians
Definition: scopesim_helper.cpp:48
Axis::TrackingRateDegSec
Angle TrackingRateDegSec
TrackingRateDegSec.
Definition: scopesim_helper.h:288
LOGF_EXTRA1
#define LOGF_EXTRA1(fmt,...)
Definition: indilogger.h:84
Axis::isTracking
bool isTracking()
Definition: scopesim_helper.h:267
Vector::rotateY
Vector rotateY(Angle angle)
rotateY rotates this vector through angle about the Y axis
Definition: scopesim_helper.cpp:529
Alignment::mountToApparentRaDec
void mountToApparentRaDec(Angle primary, Angle secondary, Angle *apparentRa, Angle *apparentDec)
mountToApparentRaDec: convert mount position to apparent Ra, Dec
Definition: scopesim_helper.cpp:261
Axis::update
void update()
Definition: scopesim_helper.cpp:124
Angle::HOURS
@ HOURS
Definition: scopesim_helper.h:70
Axis::AXIS_TRACK_RATE
AXIS_TRACK_RATE
The AXIS_TRACK_RATE enum defines the common track rates.
Definition: scopesim_helper.h:249
Angle::operator==
bool operator==(const Angle &a)
Definition: scopesim_helper.cpp:50
Angle
The Angle class This class implements an angle type. This holds an angle that is always in the range ...
Definition: scopesim_helper.h:50
Alignment::mountType
MOUNT_TYPE mountType
Definition: scopesim_helper.h:374
Vector::L
double L
Definition: scopesim_helper.h:568
Alignment::ch
double ch()
Definition: scopesim_helper.h:408
indilogger.h
LOGF_DEBUG
#define LOGF_DEBUG(fmt,...)
Definition: indilogger.h:83
type
__le16 type
Definition: pwc-ioctl.h:2
Vector::normalise
void normalise()
Definition: scopesim_helper.cpp:500
Alignment::setCorrections
void setCorrections(double ih, double id, double ch, double np, double ma, double me)
setCorrections set the values of the six corrections
Definition: scopesim_helper.cpp:465
Angle::Degrees
double Degrees()
Degrees.
Definition: scopesim_helper.h:84
Axis::StartGuide
void StartGuide(double rate, uint32_t durationMs)
StartGuide start guiding.
Definition: scopesim_helper.cpp:115
Alignment::ma
double ma()
Definition: scopesim_helper.h:409
Vector::N
double N
Definition: scopesim_helper.h:570
Axis::setDegrees
void setDegrees(double degrees)
Definition: scopesim_helper.cpp:64
scopesim_helper.h
Vector::rotateX
Vector rotateX(Angle angle)
rotateX rotates this vector through angle about the X axis
Definition: scopesim_helper.cpp:522
Axis::TrackRate
AXIS_TRACK_RATE TrackRate()
TrackRate returns the AXIS_TRACK_RATE property.
Definition: scopesim_helper.cpp:110
Vector::primary
Angle primary()
primary returns the primary angle (Ra, Ha, Azimuth) from this vector
Definition: scopesim_helper.cpp:508
Angle::ANGLE_UNITS
ANGLE_UNITS
Definition: scopesim_helper.h:70
Angle::RADIANS
@ RADIANS
Definition: scopesim_helper.h:70
Vector::M
double M
Definition: scopesim_helper.h:569
get_local_sidereal_time
double get_local_sidereal_time(double longitude)
get_local_sidereal_time Returns local sideral time given longitude and system clock.
Axis::isSlewing
bool isSlewing
Definition: scopesim_helper.h:265
Vector::secondary
Angle secondary()
secondary returns the secondary angle (dec, altitude) from this vector
Definition: scopesim_helper.cpp:515
Axis::Tracking
void Tracking(bool enabled)
Definition: scopesim_helper.cpp:83
Alignment::lst
Angle lst()
Definition: scopesim_helper.cpp:221
Axis::axisName
const char * axisName
Definition: scopesim_helper.h:253
Axis::StartSlew
void StartSlew(Angle angle)
Definition: scopesim_helper.cpp:76
Angle::operator!=
bool operator!=(const Angle &a)
Definition: scopesim_helper.cpp:55
Alignment::me
double me()
Definition: scopesim_helper.h:410
Angle::Degrees360
double Degrees360()
Degrees360.
Definition: scopesim_helper.h:90
Axis::setHours
void setHours(double hours)
Definition: scopesim_helper.cpp:70
me
char * me
Definition: indidriver.c:50
OFF
#define OFF
Definition: stvdriver.h:26
Vector
The Vector class This implements the Directional Cosine used by Taki in his Matrix method....
Definition: scopesim_helper.h:503
Alignment::ih
double ih()
Definition: scopesim_helper.h:405
Axis::position
Angle position
Definition: scopesim_helper.h:259
Alignment::observedToInstrument
void observedToInstrument(Angle observedHa, Angle observedDec, Angle *instrumentHa, Angle *instrumentDec)
Definition: scopesim_helper.cpp:349
Angle::difference
double difference(Angle a)
Definition: scopesim_helper.h:145
Axis::mcRate
int mcRate
Definition: scopesim_helper.h:299
Alignment::latitude
Angle latitude
Definition: scopesim_helper.h:371