activities.h

#ifndef ACTIVITIES_H_LOADED
#define ACTIVITIES_H_LOADED 1

#include "types.h"
#include "state.h"
#include "qp.h"

class Activity {
    friend class ActivityQueue;

 public:
    enum ActivityTypes { BaseActivity,
                         CalibrationActivity,
                         ScheduleFollowingActivity,
                         DriveAzAltActivity,
                         TrackSiderealActivity,
                         TrackAzimuthActivity, };

 private:
    const ActivityTypes type_;
    Activity* next_;

 protected:
    State* const state;         // const pointer to non-const State

    TelescopeController* const controller; // const pointer to non-const controller

    byte activity_status;
#define ACTIVITY_STATUS_COMPLETE 1
#define ACTIVITY_STATUS_INVALID 1<<1
    // /**
    //  * Set to true by a derived class when its work is done.
    //  * @see is_complete
    //  */
    // bool complete_p;

    void mark_as_complete(void) { activity_status |= ACTIVITY_STATUS_COMPLETE; }
    void mark_as_invalid(void) {
        activity_status |= (ACTIVITY_STATUS_COMPLETE | ACTIVITY_STATUS_INVALID);
    }

    Activity(TelescopeController*, State*, ActivityTypes);

 public:
    virtual void az_click(ms_t t, double azimuth);

    virtual void alt_click(ms_t t, double altitude);

    virtual void at_endstop(ms_t t, int az_click_count, int alt_click_count) = 0;

    bool is_complete(void) const { return activity_status & ACTIVITY_STATUS_COMPLETE; }

    bool is_valid(void) const { return ! (activity_status & ACTIVITY_STATUS_INVALID); }

    virtual void cancel(void);

    // The following is necessary because on the Arduino, there is no RTTI, so no dynamic_cast.
    ActivityTypes type(void) { return type_; }

    virtual ms_t start(ms_t now) { return TIME_NEVER; }

    virtual ms_t poke(ms_t t) { return TIME_NEVER; };

    static void* operator new (size_t size);
    static void operator delete (void *p);
    // overriding delete requires (I think) that we define destructors
    virtual ~Activity();

    static int max_activities(void);
    static int n_activities(void);
    static void delete_all_allocations(void);
};

class Calibration : public Activity {
 private:
    ms_t reftime;
    ms_t time_az1, time_az2, time_alt1, time_alt2;
    signed int cal_count;
    enum {ph_position,
          ph_az_forward, ph_az_backward,
          ph_alt_upward, ph_alt_downward} phase;


 public:
    Calibration(TelescopeController*, State*);
    ~Calibration();

    ms_t start(ms_t);
    void az_click(ms_t t, double);
    void alt_click(ms_t t, double);
    void at_endstop(ms_t t, int az_click_count, int alt_click_count);
    double clicks_per_sec_az(void);
    double clicks_per_sec_alt(void);
};

class ScheduleFollowing : public Activity {
 protected:
    ScheduleFollowing(TelescopeController*, State*, ActivityTypes);
    virtual ~ScheduleFollowing() = 0;

 public:
    virtual ms_t start(ms_t);
    virtual void cancel(void);
    virtual ms_t poke(ms_t t);
    //virtual void az_click(ms_t t, double);
    //virtual void alt_click(ms_t t, double);
    virtual void at_endstop(ms_t t, int az_click_count, int alt_click_count);
};

class DriveAzAlt : public ScheduleFollowing {
 private:
    SlewSchedule schedule;

 public:
    DriveAzAlt(TelescopeController*, State*, double phi, double theta);
    ~DriveAzAlt();
    ms_t start(ms_t);
};

class TrackSidereal : public ScheduleFollowing {
 private:
    TrackingSchedule schedule;

 public:
    TrackSidereal(TelescopeController*, State*, Position obs, double speed=0.0);
    ~TrackSidereal();
    ms_t start(ms_t);
};

class TrackAzimuth : public ScheduleFollowing {
 private:
    TrackingSchedule schedule;

 public:
    TrackAzimuth(TelescopeController*, State*, double speed);
    ~TrackAzimuth();
    ms_t start(ms_t);
};

class ActivityQueue {
 private:
    Activity* head_;

 public:
    ActivityQueue();
    Activity* current() const;
    Activity* next();
    void append(Activity*);
    void replace(Activity*);
    void cancel(void);
};

#endif /* ACTIVITIES_H_LOADED */