Tracker.h

Go to the documentation of this file.

#ifndef TRACKER_H
#define TRACKER_H

#include <list>

// Class includes

#include "gcp/util/common/Atmosphere.h"
#include "gcp/util/common/PmacMode.h"
#include "gcp/util/common/Source.h"
#include "gcp/util/common/TrackingStatus.h"

#include "gcp/util/common/TimeVal.h"

#include "gcp/antenna/control/specific/Atmosphere.h"
#include "gcp/antenna/control/specific/EmlDebug.h"
#include "gcp/antenna/control/specific/Site.h"
#include "gcp/antenna/control/specific/SpecificTask.h"
#include "gcp/antenna/control/specific/Pointing.h"
#include "gcp/antenna/control/specific/PointingCorrections.h"
#include "gcp/antenna/control/specific/Position.h"
#include "gcp/antenna/control/specific/Scan.h"
#include "gcp/antenna/control/specific/TrackerBoard.h"
#include "gcp/antenna/control/specific/TrackerMsg.h"
#include "gcp/antenna/control/specific/TrackerOffset.h"

// Needed for various gcp::control enumerators

#include "gcp/control/code/unix/libunix_src/specific/specificregs.h"

namespace gcp {
  namespace antenna {
    namespace control {

      class AntennaDrive;
      class ServoCommsSa;

      class Tracker :  
    public SpecificTask,
    public gcp::util::GenericTask<TrackerMsg> {
        
    //============================================================
    // Public members
    //============================================================
    
    public:
    
    //------------------------------------------------------------
    // Protected members
    //------------------------------------------------------------
    
    protected:
    
    bool simPmac_;
    bool simGps_;

    enum NextDriveState {
      IGNORE,   // No further action needed (pmac halted)
      HALT,     // Tell the pmac to stop the telescope drives
      SLEW,     // Tell the pmac to slew
      WAIT,     // Waiting for the pmac to signal completion of a
            // slew
      TARGET,   // Prepare to change source
      SYNC,     // Prepare the pmac to start a new track
      SLAVE,    // Send the next 1-second position of an ongoing
            // track
      REBOOT    // Tell the pmac to reboot itself 
    };
    
    //------------------------------------------------------------
    // Protected methods & members
    //------------------------------------------------------------
    
    friend class AntennaDrive;
    
    AntennaDrive* parent_;
    
    Tracker(AntennaDrive* parent);
    
    virtual ~Tracker(); 
    
    virtual void processMsg(TrackerMsg* msg);
    
    bool shutdownPending_; 
    
    // The current year - received from the control program.

    int year_;              
    
    // The next PMAC action to perform.

    NextDriveState whatNext_;
    
    // The set of externally provided pointing parameters that
    // have been recorded in the archive since their last
    // change. This is a bit set of Pointing::Parameter values
    // above

    unsigned archived_; 
    
    // The set of externally provided pointing parameters which
    // have not been received yet. This is a bitwise union of
    // Pointing::Parameter values

    unsigned lacking_;     

    // Calibration of encoders is pending;
    
    bool encoderCalPending_;
    
    // The sequence number of the last telescope positioning
    // request received from the control program.

    volatile long lastReq_;       
    
    // The last sequence number that was acknowledged to the
    // control program on completion.

    volatile long lastAck_;        
    
    // The tracking status at the previous 1-second tick.

    gcp::util::TrackingStatus::Status oldStatus_; 
    
    // The current tracking status

    gcp::util::TrackingStatus::Status newStatus_; 
    
    // This should be set to non-zero whenever any parameters that
    // could break the current track are changed.

    bool paramsUpdated_;   
    
    // The last value of the "acquired" status of the drive

    int pmacTracking_;     
    
    // The latest atmospheric refraction terms

    Atmosphere atmos_;      
    
    // The telescope pointing model

    Model model_;           
    
    // Registers of the servo box

    ServoCommsSa* servo_;

    // The position to request on the next 1-sec pulse

    Pointing nextTarget_;  
    Pointing nextTarget1_;
    Pointing nextTarget2_;
    
    // The last three commanded mount positions

    Position lastCommanded_;    // Position commanded on the last tick
    Position prevCommanded_;    // Position commanded two ticks ago
    Position tertCommanded_;    // Position commanded three ticks ago

    // The location of the telescope

    Site site_;             
    
    // An object for handling atmospheric calculations

    gcp::util::Atmosphere refracCalculator_;

    // The current source

    gcp::util::Source src_;            
    
    // The current scan

    Scan scan_;            
    
    gcp::util::TimeVal currentTick_;

    // The time of the previous time-code-reader interrupt

    gcp::util::TimeVal lastTick_;   
    
    TrackerBoard* tracker_; 
    
    TrackerOffset offset_;  
    
    //------------------------------------------------------------
    // Protected Methods
    //------------------------------------------------------------
    
    void resetMembers();
    
    void reset();
    
    virtual void initialize();
    
    void archiveStatus();
    
    void updatePmac(TimeVal& mjd, AxisPositions *current);

    void updateMountLimits();
    
    void sourcePosition(gcp::util::TimeVal& mjd);
    void sourcePosition(gcp::util::TimeVal& mjd, Pointing& thisTargetVal);
    void sourcePositionTrack(gcp::util::TimeVal& mjd, double utc);
    void sourcePositionTrack(gcp::util::TimeVal& mjd, double utc, Pointing& thisTargetVal);
    void sourcePositionCenter(gcp::util::TimeVal& mjd);
    void sourcePositionCenter(gcp::util::TimeVal& mjd, Pointing& thisTargetVal);
    
    virtual void pmacNewPosition(gcp::util::PmacMode::Mode mode, 
                     AxisPositions *current, gcp::util::TimeVal& mjd); 
    
    void finalizePointing(double pmra, double pmdec, 
                  PointingCorrections *f,
                  Pointing* p,
                  gcp::util::TimeVal& mjd);
    void finalizePointing(double pmra, double pmdec, 
                  PointingCorrections *f,
                  Pointing* p,
                  gcp::util::TimeVal& mjd, Pointing& thisTargetVal);

    void finalizePointing(gcp::util::TimeVal& mjd);
    void finalizePointing(gcp::util::TimeVal& mjd, Pointing& thisTargetVal);
    
    void registerRequest(unsigned seq);
    
    //............................................................
    // Methods which are called in response to messages from the
    // Drive Task
    //............................................................
    
    virtual void addTick(TrackerMsg* msg);
    virtual void addTickOvro(TrackerMsg* msg);
    
    void calCollimation(TrackerMsg* msg);
    
    void calEncoders(TrackerMsg* msg);
    
    void calFlexure(TrackerMsg* msg);
    
    void calTilts(TrackerMsg* msg);
    
    void changeYear(TrackerMsg* msg);
    
    void extendEqnEqx(TrackerMsg* msg);
    
    void extendTrack(TrackerMsg* msg);
    void extendScan(TrackerMsg* msg);
    
    void extendUt1Utc(TrackerMsg* msg);
    
    void haltTelescope(TrackerMsg* msg=0);
    
    void locateSite(TrackerMsg* msg);
    
    void locateAntenna(TrackerMsg* msg);

    void rebootDrive(TrackerMsg* msg);
    
    void recordEncoderLimits(TrackerMsg* msg);
    
    void selectModel(TrackerMsg* msg);
    
    void setEncoderZero(TrackerMsg* msg);
    
    void setOffset(TrackerMsg* msg);
    
    void setSlewRate(TrackerMsg* msg);
    
    void slewTelescope(TrackerMsg* msg);
    
    void updateRefraction(TrackerMsg* msg);
    void updateRefraction();
    
    virtual void connectPmac();
    
    virtual void disconnectPmac();

    bool okToPoint();

    void setNextState(NextDriveState state);

    void strobeServo(TrackerMsg* msg);

    // acknowledges cmpletion of a motion command
    bool acknowledgeCompletion();

    // executes a Servo Specific command
    void executeServoCmd(TrackerMsg* msg);

      }; // End class Tracker
      
    }; // End namespace control
  }; // End namespace antenna
} // End namespace gcp

#endif