scopesim_helper.h

Go to the documentation of this file.

/*
 * scopesim_helper.h
 *
 * Copyright 2020 Chris Rowland <[email protected]>
 *
 * helper classes for the telescope simulator
 *
 * The Angle structure defines an angle class that manages the wrap round
 * 0 to 360 and handles arithmetic and logic across this boundary.
 *
 * The Axis class manages a simulated mount axis and handles moving, tracking, and guiding.
 *
 * The Alignment class handles the alignment, converting between the observed and instrument
 * places, and allowing for the axis positions needed for a GEM mount.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 *
 *
 */
 
 
#pragma once
 
#include <stdint.h>
#include <sys/time.h>
#include <cmath>
 
#include <indicom.h>
 
extern char device_str[64];
 
class Angle
{
    private:
        double angle;     // position in degrees, range -180 to 0 to 180
 
        static double range(double deg)
        {
            while (deg > 180.0) deg -= 360.0;
            while (deg <= -180.0) deg += 360.0;
            return deg;
        }
 
        static double hrstoDeg(double hrs)
        {
            return range(hrs * 15.0);
        }
 
    public:
        enum ANGLE_UNITS {DEGREES, HOURS, RADIANS};
 
        Angle()
        {
            angle = 0;
        }
 
        Angle(double value, ANGLE_UNITS type);
 
        Angle(double degrees)
        {
            angle = range(degrees);
        }
 
        //virtual ~Angle() = default;
 
        double Degrees()
        {
            return angle;
        }
 
        double Degrees360()
        {
            return (angle >= 0) ? angle : 360.0 + angle;
        }
 
        double Hours()
        {
            double h = angle / 15.0;
            if (h < 0.0)
                h = 24 + h;
            return h;
        }
        double HoursHa()
        {
            return angle / 15.0;
        }
 
        double radians();
 
        void setDegrees(double deg)
        {
            angle = range(deg);
        }
 
        void setHours(double hrs)
        {
            angle = hrstoDeg(hrs);
        }
 
        Angle add(Angle a)
        {
            double total = a.Degrees() + this->Degrees();
            return Angle(total);
        }
 
        Angle subtract(Angle a)
        {
            return Angle(this->Degrees() - a.Degrees());
        }
 
        double difference(Angle a)
        {
            return range(this->angle - a.angle);
        }
 
        Angle operator - ()
        {
            return Angle(-this->angle);
        }
 
        Angle &operator += (const Angle &a)
        {
            angle = range(angle + a.angle);
            return *this;
        }
 
        Angle &operator += (const double d)
        {
            angle = range(angle + d);
            return *this;
        }
 
        Angle &operator-= (const Angle &a)
        {
            angle = range(angle - a.angle);
            return *this;
        }
 
        Angle &operator-= (const double d)
        {
            angle = range(angle - d);
            return *this;
        }
 
        Angle operator+ (const Angle &a)
        {
            return Angle(this->angle + a.angle);
        }
 
        Angle operator+ (const double &d)
        {
            return Angle(this->angle + d);
        }
 
        Angle operator- (const Angle &rhs)
        {
            return Angle(this->angle - rhs.angle);
        }
 
        Angle operator- (const double &rhs)
        {
            return Angle(this->angle - rhs);
        }
 
        Angle operator * (const double duration)
        {
            return Angle(this->angle * duration);
        }
 
        bool operator== (const Angle &a);
 
        bool operator!= (const Angle &a);
 
        bool operator > (const Angle &a)
        {
            return difference(a) > 0;
        }
 
        bool operator < (const Angle &a)
        {
            return difference(a) < 0;
        }
        bool operator >= (const Angle &a)
        {
            return difference(a) >= 0;
        }
        bool operator <= (const Angle &a)
        {
            return difference(a) <= 0;
        }
};
 
 
class Axis
{
    public:
        enum AXIS_TRACK_RATE { OFF, SIDEREAL, SOLAR, LUNAR };
 
        Axis(const char * name)
        {
            axisName = name;
        }
 
        const char * axisName;
 
        // sets position and target so does not cause a slew.
        void setDegrees(double degrees);
        void setHours(double hours);
 
        Angle position; // current angle of the telescope position about axis
 
        void StartSlew(Angle angle);
 
        void Abort()
        {
            target = position;
            mcRate = 0;
            guideDuration = 0;
        }
 
        bool isSlewing = false;
 
        bool isTracking()
        {
            return tracking;
        }
 
        void Tracking(bool enabled);
 
        void TrackRate(AXIS_TRACK_RATE rate);
 
        AXIS_TRACK_RATE TrackRate();
 
        double getTrackingRateDegSec();
 
        Angle TrackingRateDegSec;
 
        void StartGuide(double rate, uint32_t durationMs);
 
        bool IsGuiding()
        {
            return guideDuration > 0;
        }
 
        int mcRate = 0;             // int -4 to 4 sets move rate, zero is stopped
 
        void update();         // called about once a second to update the position and mode
 
        // needed for debug MACROS
        const char *getDeviceName()
        {
            return device_str;
        }
 
    private:
        Angle target;           // target axis position
 
        struct timeval lastTime
        {
            0, 0
        };
 
        bool tracking = false;      // this allows the tracking state and rate to be set independently
 
        AXIS_TRACK_RATE trackingRate { AXIS_TRACK_RATE::OFF };
 
        Angle rotateCentre { 90.0 };
 
        double guideDuration = 0;
        Angle guideRateDegSec;
 
        // rates are angles in degrees per second derived from the values in indicom.h
        // which are in arcsec per second.
 
        const Angle solarRate { TRACKRATE_SOLAR / 3600.0 };
        const Angle siderealRate { TRACKRATE_SIDEREAL / 3600.0 };
        const Angle lunarRate { TRACKRATE_LUNAR / 3600.0 };
 
        Angle mcRates[5]
        {
            0,
            siderealRate,   // guide rate
            0.5,            // fine rate
            2.5,            // center rate
            6.0,            // goto rate
        };
};
 
class Alignment
{
    public:
        Alignment() {}
 
        enum MOUNT_TYPE { ALTAZ, EQ_FORK, EQ_GEM };
 
        Angle latitude = 0;
        Angle longitude = 0;
 
        MOUNT_TYPE mountType = EQ_FORK;
 
        void mountToApparentRaDec(Angle primary, Angle secondary, Angle * apparentRa, Angle* apparentDec);
 
 
        void apparentRaDecToMount(Angle apparentRa, Angle apparentDec, Angle *primary, Angle *secondary);
 
 
        void setCorrections(double ih, double id, double ch, double np, double ma, double me);
        void setCorrections(double *coeffs)
        {
            setCorrections(coeffs[0], coeffs[1], coeffs[2], coeffs[3], coeffs[4], coeffs[5]);
        }
 
        void setFlipHourAngle(double deg)
        {
            flipHourAngle = deg;
        }
 
        // needed for debug MACROS
        const char *getDeviceName()
        {
            return device_str;
        }
 
        double ih()
        {
            return IH;
        }
        double id()
        {
            return ID;
        }
        double np()
        {
            return NP;
        }
        double ch()
        {
            return CH;
        }
        double ma()
        {
            return MA;
        }
        double me()
        {
            return ME;
        }
 
        void instrumentToObserved(Angle instrumentHa, Angle instrumentDec, Angle *observedHa, Angle *observedDec);
 
        void observedToInstrument(Angle observedHa, Angle observedDec, Angle * instrumentHa, Angle * instrumentDec);
 
 
        void mountToApparentHaDec(Angle primary, Angle secondary, Angle *apparentHa, Angle *apparentDec);
 
        void mountToInstrumentHaDec(Angle primary, Angle secondary, Angle *instrumentHa, Angle *instrumentDec);
 
        // Inverse of mountToInstrumentHaDec: converts raw instrument HA/Dec (no Wallace) to
        // axis positions.  Uses the same flipHourAngle condition as apparentHaDecToMount so
        // it selects the correct pier side for a Goto without applying pointing corrections.
        void instrumentHaDecToMount(Angle instrumentHa, Angle instrumentDec, Angle *primary, Angle *secondary);
 
        void apparentHaDecToMount(Angle apparentHa, Angle apparentDec, Angle *primary, Angle *secondary);
 
        Angle lst();            // returns the current LST as an angle
    private:
 
 
 
 
        Angle flipHourAngle = 0;
 
        void correction(Angle instrumentHa, Angle instrumentDec, Angle *correctionHa, Angle *correctionDec);
 
        // mount model, these angles are in degrees
        // the angles are small so use double to avoid
        // loads of conversions
        double IH = 0;
        double ID = 0;
        double CH = 0;
        double NP = 0;
        double MA = 0;
        double ME = 0;
 
 
        // corrections done using direction cosines and rotations after Taki
        //apparentHaDecToMount(Vector HaDec, Vector * mount);
};
 
class Vector
{
    public:
        Vector()
        {
            L = M = N = 0;
        }
 
        Vector(double l, double m, double n);
 
        Vector(Angle primary, Angle secondary);
 
        double lengthSquared()
        {
            return L * L + M * M + N * N;
        }
 
        double length()
        {
            return std::sqrt(lengthSquared());
        }
 
        void normalise();
 
        Angle primary();
 
        Angle secondary();
 
        Vector rotateX(Angle angle);
 
        Vector rotateY(Angle angle);
 
        Vector rotateZ(Angle angle);
 
        double l()
        {
            return L;
        }
        double m()
        {
            return M;
        }
        double n()
        {
            return N;
        }
 
    protected:
        double L;   // in the Ha 0 direction, pointing at Ha 0, Dec 0, X direction
        double M;   // in the Ha 6 direction, pointing at Ha 6h, Dec 0, Y direction
        double N;   // toward the pole, Dec 0, Z direction
};