SzaShare.h

Go to the documentation of this file.

#ifndef SZASHARE_H
#define SZASHARE_H

#include <string>

#include <pthread.h>

#include "carma/szautil/TimeVal.h"

#include "carma/szautil/AntennaDataFrameManager.h"
#include "carma/szautil/QuadPath.h"

#include "carma/antenna/sza/antenna/control/PolarEncoderPos.h"
#include "carma/antenna/sza/antenna/control/Site.h"

// C header files from the array control code

#include "carma/szaarrayutils/szaregs.h"
#include "carma/szaarrayutils/astrom.h"

namespace sza {
  namespace antenna {
    namespace control {
      
      class SzaShare : public sza::util::AntennaDataFrameManager {
        
      public:
        
        enum TimeOut {
          NO_WAIT, 
          WAIT_FOREVER
        };
        
        //------------------------------------------------------------
        // SzaRegDb Object
        //------------------------------------------------------------
        
        class SzaRegDb {
          
        public:
          
          
          SzaRegDb();
          
          ~SzaRegDb();
          
          void grabRegs(TimeOut timeout);
          
          void ungrabRegs();
          
          RegMapBoard* findRegMapBoard(std::string boardName);
          
          void flagBoard(int board);
          
          void unflagBoard(int board);
          
          bool verifyBoard(int board);
          
        private:
          
          friend class SzaShare;
          
          SzaRegMap *regmap_;      

          pthread_mutex_t guard_;  
          
          unsigned *shadow_;       
          int nshadow_;            
          
          unsigned* boardStatusReg(int board);
          
        };
        
        //------------------------------------------------------------
        // SzaClock Object
        //------------------------------------------------------------
        
        class SzaClock {
          
        public:
          
          SzaClock();
          
          ~SzaClock();
          
          void setClock(unsigned long mjd, unsigned long sec, 
                        unsigned long nanoSeconds);
          
          void setClock(sza::util::TimeVal& time);
          
          void setClock();

          double getUtc();
          
        private:
          
          pthread_mutex_t guard_; 
          
          sza::util::TimeVal time_;
        };
        
        //----------------------------------------------------------------------
        // SzaAstrom Object
        //------------------------------------------------------------
        
        class SzaAstrom {
          
        public:
          
          SzaAstrom();
          
          virtual ~SzaAstrom();
          
          virtual void setSite(double longitude, double latitude, double altitude);
          
          void getSite(sza::antenna::control::Site *site);
          
          void extendUt1Utc(double utc, double ut1utc);
          
          void extendEqnEqx(double tt, double eqneqx);
          
          double getUt1Utc(double utc);
          
          double getEqnEqx(double tt);
          
        private:
          
          pthread_mutex_t guard_;   
          
          sza::antenna::control::Site site_; 
          
          sza::util::QuadPath* ut1utc_;     
          
          sza::util::QuadPath* eqneqx_;     
          
        }; // Class SzaAstrom
        
        //------------------------------------------------------------
        // SzaPmacLock Object
        //------------------------------------------------------------
        
        class SzaPmacLock { 
          
        public:
          
          SzaPmacLock(SzaShare *share);
          
          ~SzaPmacLock();
          
        private:
          
          pthread_mutex_t guard_;  
          
          int count_;              
          
          RegMapBoard *pmac_;      
          
          RegMapBlock *host_read_; 

        }; // End class SzaPmacLock
        
        //------------------------------------------------------------
        // SzaShare Methods
        //------------------------------------------------------------
        
        struct HostAddress {
          char* name;
          char* address;
        };
        
        // Static members and functions
        
        static SzaShare* share;
        
        static HostAddress host_address[];
        
        static std::string hostIpAddress(std::string host);
        
        virtual void setTuningPending(bool pending) {};


        static void pciBusErrorHandler(int sig);
        
        static void pciSegvErrorHandler(int sig);
        
        SzaShare(std::string host);
        
        ~SzaShare();
        
        void grabRegs(TimeOut timeout);
        
        void ungrabRegs();
        
        /*
         * Flag a board as unreachable. Note that this is called
         * automatically by read_regdb() and write_regdb() if their
         * 'check' argument is true and an exception occurs. If
         * 'check' is false then the caller is expected to perform
         * exception handling and to call the following function if an
         * exception occurs.
         *
         * @throws Exception
         */
        void flagBoard(int board);
        
        /*
         * This function will be called by the scanner task after
         * successfully reading all registers of a previously flagged
         * board without incuring an exception. It marks the board as
         * usable by other tasks.
         *
         * @throws Exception
         */
        void unflagBoard(int board);
        
        bool verifyBoard(int board);
        
        virtual double getLst(double utc);
        
        double getTt(double lst);
        
        double getUtc();
        
        void setClock(unsigned long mjd, unsigned long sec, 
                      unsigned long nanoSeconds);
        
        void setClock(sza::util::TimeVal& time);

        void setClock();

        virtual void setSite(double longitude, double latitude, double altitude);
        
        double getUt1Utc(double utc);
        
        double getEqnEqx(double tt);
        
        void extendUt1Utc(double utc, double ut1utc);
        
        void extendEqnEqx(double tt, double eqneqx);
        
        RegMapBoard* findRegMapBoard(std::string boardName);
        
        void freezePmacReadout();
        
        void unfreezePmacReadout();
        
        unsigned int getNboard();
        
        unsigned int getNarchived();
        
        unsigned int getNreg();

        unsigned int getNbyte();

        void packFrame(sza::util::DataFrameManager* frame);
        
        RegMap* getRegMap();

      private:
        
        unsigned* tmpbuf_;         
        
        std::string controlHost_;       
        
        SzaRegDb *regdb_;          
        
        SzaClock *clock_;          
        
        SzaAstrom *astrom_;        
        
        SzaPmacLock *pmac_lock_;   
        
      }; // class SzaShare
      
    }; // End namespace control
  }; // End namespace antenna
}; // End namespace sza

#endif