Share.h

#ifndef SZA_ANTENNA_SZASHARE_H
#define SZA_ANTENNA_SZASHARE_H

#include <string>

#include <pthread.h>

#include "carma/szautil/TimeVal.h"

#include "carma/szautil/DataFrameManager.h"
#include "carma/szautil/Mutex.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:
        
        enum TimeOut {
          NO_WAIT, 
          WAIT_FOREVER
        };
        
        enum Type {
          CHAR,
          UCHAR,
          SHORT,
          USHORT,
          INT,
          UINT,
          LONG,
          ULONG,
          FLOAT,
          DOUBLE
        };

        struct DataPtr {
          Type type;
          void* ptr_;
        };

        //------------------------------------------------------------
        // SzaRegDb Object
        //------------------------------------------------------------
        
        class SzaRegDb {
          
        public:
          
          SzaRegDb();
          
          ~SzaRegDb();
          
          void readShadowReg(RegMapBlock *blk, unsigned first,
                             unsigned nreg, DataPtr& value);
          
          void writeShadowReg(RegMapBlock *blk,  unsigned first, 
                              unsigned nreg, Dataptr& value);
          
          void grabRegs(TimeOut timeout);
          
          void ungrabRegs();
          
          RegMapBoard* findRegMapBoard(std::string boardName);
          
          void SzaShare::SzaRegDb::flagBoard(int board);
          
          void SzaShare::SzaRegDb::unflagBoard(int board);
          
          bool SzaShare::SzaRegDb::verifyBoard(int board);
          
        private:
          
          friend class SzaShare;
          
          SzaRegMap* regmap_;      
          
          sza::util::Mutex guard_;  
          
          unsigned char* shadow_;       
          
          int nShadow_;            
          
          unsigned* SzaShare::SzaRegDb::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:
          
          sza::util::Mutex guard_;
          
          sza::util::TimeVal time_;
        };
        
        //----------------------------------------------------------------------
        // SzaAstrom Object
        //------------------------------------------------------------
        
        class SzaAstrom {
          
        public:
          
          SzaAstrom();
          
          ~SzaAstrom();
          
          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:
          
          sza::util::Mutex guard_;   
          
          sza::antenna::control::Site site_; 
          
          sza::util::QuadPath* ut1utc_;     
          
          sza::util::QuadPath* eqneqx_;     
          
        }; // Class SzaAstrom
        
        //------------------------------------------------------------
        // 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);
        
        SzaShare(std::string host);
        
        ~SzaShare();
        
        void readReg(RegMapBlock *blk, unsigned first, unsigned nreg, 
                     unsigned *value);
        
        void readRawReg(RegMapBlock *blk, unsigned first, unsigned nreg, 
                        unsigned *value);
        
        void writeReg(RegMapBlock* blk, unsigned first, unsigned nreg, 
                      signed char* value);

        void writeReg(RegMapBlock* blk, unsigned first, unsigned nreg, 
                      unsigned char* value);

        void writeReg(RegMapBlock* blk, unsigned first, unsigned nreg, 
                      signed short* value);

        void writeReg(RegMapBlock* blk, unsigned first, unsigned nreg, 
                      unsigned short* value);

        void writeReg(RegMapBlock* blk, unsigned first, unsigned nreg, 
                      int* value);

        void writeReg(RegMapBlock* blk, unsigned first, unsigned nreg, 
                      unsigned int* value);

        void writeReg(RegMapBlock* blk, unsigned first, unsigned nreg, 
                      long* value);

        void writeReg(RegMapBlock* blk, unsigned first, unsigned nreg, 
                      unsigned long* value);

        void writeReg(RegMapBlock *blk, unsigned first, unsigned nreg, 
                      float* value);

        void writeReg(RegMapBlock *blk, unsigned first, unsigned nreg, 
                      double* value);
        
        void writeRawReg(RegMapBlock* blk, unsigned first, unsigned nreg, 
                         unsigned char* value);

        void writeRawReg(RegMapBlock* blk, unsigned first, unsigned nreg, 
                         unsigned short* value);

        void writeRawReg(RegMapBlock* blk, unsigned first, unsigned nreg, 
                         unsigned* value);

        void writeRawReg(RegMapBlock* blk, unsigned first, unsigned nreg, 
                         float* value);

        void writeRawReg(RegMapBlock* blk, unsigned first, unsigned nreg, 
                         double* value);
        
        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);
        
        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();

        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);
        
        unsigned int getNboard();
        
        unsigned int getNarchived();
        
        void packFrame(sza::util::DataFrameManager* frame);
        
      private:
        
        void packRegBoard(RegMapBoard* brd, 
                          sza::util::DataFrameManager* frame);
        
        unsigned char* tmpbuf_;         
        
        std::string controlHost_;       
        
        SzaRegDb *regdb_;          
        
        SzaClock *clock_;          
        
        SzaAstrom *astrom_;        
        
      }; // class SzaShare
      
    }; // End namespace control
  }; // End namespace antenna
}; // End namespace sza

#endif