Tracker.h

Go to the documentation of this file.

#ifndef TRACKER_H
#define TRACKER_H

#include <list>
#include <map>

// SZA class includes

#include "carma/szautil/Atmosphere.h"
#include "carma/szautil/PmacMode.h"
#include "carma/szautil/QuadPath.h"
#include "carma/szautil/Source.h"
#include "carma/szautil/TrackingStatus.h"

#include "carma/szautil/TimeVal.h"

#include "carma/antenna/sza/antenna/control/Atmosphere.h"
#include "carma/antenna/sza/antenna/control/CameraBoard.h"
#include "carma/antenna/sza/antenna/control/Site.h"
#include "carma/antenna/sza/antenna/control/SzaTask.h"
#include "carma/antenna/sza/antenna/control/PmacBoard.h"
#include "carma/antenna/sza/antenna/control/Pointing.h"
#include "carma/antenna/sza/antenna/control/PointingCorrections.h"
#include "carma/antenna/sza/antenna/control/Position.h"
#include "carma/antenna/sza/antenna/control/TrackerBoard.h"
#include "carma/antenna/sza/antenna/control/TrackerMsg.h"
#include "carma/antenna/sza/antenna/control/TrackerOffset.h"
#include "carma/antenna/sza/antenna/control/WrapMode.h"

// Needed for various sza::array enumerators

#include "carma/szaarrayutils/szaregs.h"

namespace sza {
  namespace antenna {
    namespace control {

      class AntennaDrive;

      class Tracker :  
        public SzaTask,
        public sza::util::GenericTask<TrackerMsg> {
        
        //============================================================
        // Public members
        //============================================================
        
        public:
        
        enum BoardType {
          CAMERA,
          TRACKER,
          PMAC
        };
        
        std::list<Board*> listBoards();
        
        //============================================================
        // Private members
        //============================================================
        
        private:
        
        // The receiver we're currently using

        sza::util::Rx::Id rxId_;

        bool simPmac_;
        bool ignoreWrapLogic_;

        enum NextPmacState {
          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 
        };
        
        //------------------------------------------------------------
        // Private methods & members
        //------------------------------------------------------------
        
        friend class AntennaDrive;
        
        AntennaDrive* parent_;
        
        Tracker(AntennaDrive* parent, bool simPmac=false, bool ignoreWrapLogic=true);
        
        ~Tracker();
        
        void processMsg(TrackerMsg* msg);
        
        //------------------------------------------------------------
        // Private member declarations
        //------------------------------------------------------------
        
        bool shutdownPending_; 
        
        int year_;              
        
        NextPmacState whatNext_;
        
        unsigned archived_; 
        
        unsigned lacking_;     
        
        long lastReq_;       
        
        long lastAck_;        

        std::map<sza::util::GenericTaskMsg::CarmaSeqNoType, unsigned long> lastReqCarmaSeqNo_;
        std::map<sza::util::GenericTaskMsg::CarmaSeqNoType, unsigned long> lastAckCarmaSeqNo_;
        sza::util::GenericTaskMsg::CarmaSeqNoType carmaSeqNoType_;
        
        sza::util::TrackingStatus::Status oldStatus_; 
        
        sza::util::TrackingStatus::Status newStatus_; 
        
        bool paramsUpdated_;   
        int pmacTracking_;     
        Atmosphere atmos_;      
        
        CameraBoard* camera_;   
        
        Model model_;           
        
        PmacBoard* pmac_;       
        
        Pointing nextTarget_;  
        
        Position lastCommanded_;    // Position commanded on the last tick
        Position prevCommanded_;    // Position commanded two ticks ago
        
        Site site_;             
        
        // An object for handling atmospheric calculations

        sza::util::Atmosphere refracCalculator_;

        sza::util::Source src_;            
        
        sza::util::TimeVal lastTick_;   
        
        TrackerBoard* tracker_; 
        
        TrackerOffset offset_;  
        
        //------------------------------------------------------------
        // Private Methods
        //------------------------------------------------------------
        
        void resetMembers();
        
        void reset();
        
        void initialize();
        
        void updatePmac(sza::util::TimeVal& mjd, 
                        AxisPositions* current);
        
        void archiveStatus();
        
        void updateMountLimits();
        
        void sourcePosition(sza::util::TimeVal& mjd);

        // Version for fixed sources

        void sourcePositionTrack(sza::util::TimeVal& mjd);
        
        void pmacNewPosition(sza::util::PmacMode::Mode mode, 
                             AxisPositions *current);
        
        void finalizePointing(double pmra, double pmdec, 
                              PointingCorrections *f);

        // Version for fixed sources

        void finalizePointing();
        
        void registerRequest(unsigned seq);

        void registerCarmaRequest(TrackerMsg* msg);
        void sendCarmaSeqNoMsg(bool success);
        
        void sendPmacDoneMessage(unsigned seq);
        void sendSourceSetMessage(unsigned seq);
        
        //............................................................
        // Methods which are called in response to messages from the
        // Drive Task
        //............................................................
        
        void addTick(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 extendUt1Utc(TrackerMsg* msg);
        
        void haltTelescope(TrackerMsg* msg);
        
        void locateSite(TrackerMsg* msg);
        
        void locateAntenna(TrackerMsg* msg);

        void rebootPmac(TrackerMsg* msg);
        
        void recordEncoderLimits(TrackerMsg* msg);
        
        void setTvAngle(TrackerMsg* msg);
        
        void selectModel(TrackerMsg* msg);
        
        void setEncoderZero(TrackerMsg* msg);
        
        void setOffset(TrackerMsg* msg);
        
        void setSlewRate(TrackerMsg* msg);
        
        void slewTelescope(TrackerMsg* msg);
        
        void unflagBoard(TrackerMsg* msg);
        
        void updateRefraction(TrackerMsg* msg);
        void updateRefraction();
        
        void strobePmac();
        
        void connectPmac();
        
        void disconnectPmac();

        bool okToPoint();

        void setWrapMode(WrapMode::Mode wrapMode);

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

#endif