SpecificShare.h

Go to the documentation of this file.

#ifndef SPECIFICSHARE_H
#define SPECIFICSHARE_H

#include <string>

#include <pthread.h>

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

#include "gcp/util/common/AntennaDataFrameManager.h"
#include "gcp/util/common/QuadPath.h"

#include "gcp/antenna/control/specific/PolarEncoderPos.h"
#include "gcp/antenna/control/specific/Site.h"

// C header files from the array control code

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

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

namespace gcp {
  namespace antenna {
    namespace control {
      
      class AcuPort;

      class SpecificShare : public gcp::util::AntennaDataFrameManager {
    
      public:
    
    enum TimeOut {
      NO_WAIT, 
      WAIT_FOREVER
    };
        
    // Define the fundamental hardware tick rate used to
    // synchronize all antenna tracking A pulse with this period
    // is distributed to all tracking and receiver hardware to
    // synchronize antenna positions and data acquisition samples
    
        static const unsigned int NANOSECONDS_PER_POSITION = 10000000;
    
    //------------------------------------------------------------
    // An object to manage buffered registers
    //------------------------------------------------------------

    struct Block {

      // Public members

      SpecificShare* parent_;
      RegMapBlock* blk_;
      unsigned nElPerSample_;
      unsigned nFastElPerFrame_;
      unsigned nBytePerSample_;
      unsigned nBytePerEl_;
      unsigned nBytePerFrame_;
      gcp::util::DoubleBufferVec<unsigned char> buf_;
      unsigned char* bufPtr_;
      unsigned char* framePtr_;

      // Methods

      Block(char* boardName, char* blockName, 
        SpecificShare* parent);

      virtual ~Block();

      void buffer(unsigned iSamp, void* data, bool print=false);
      void buffer(void* data, bool print=false);

      void switchBuffers();
      void copyDataToFrame();
    };


    //------------------------------------------------------------
    // SpecificRegDb Object
    //------------------------------------------------------------
    
    class SpecificRegDb {
      
    public:
      
      SpecificRegDb();
      
      ~SpecificRegDb();
      
      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 SpecificShare;
      
      RegMap *regmap_;      

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

      double getUtc();

      
    private:
      
      pthread_mutex_t guard_; 
      
      gcp::util::TimeVal time_;
    };
    
    //----------------------------------------------------------------------
    // SpecificAstrom Object
    //------------------------------------------------------------
    
    class SpecificAstrom {
      
    public:
      
      SpecificAstrom();
      
      ~SpecificAstrom();
      
      void setSite(double longitude, double latitude, double altitude);
      
      void getSite(gcp::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_;   
      
      gcp::antenna::control::Site site_; 
      
      gcp::util::QuadPath* ut1utc_;     
      
      gcp::util::QuadPath* eqneqx_;     
      
    }; // Class SpecificAstrom
    
    //------------------------------------------------------------
    // SpecificPmacLock Object
    //------------------------------------------------------------
    
    class SpecificPmacLock { 
      
    public:
      
      SpecificPmacLock(SpecificShare *share);
      
      ~SpecificPmacLock();
      
    private:
      
      pthread_mutex_t guard_;  
      
      int count_;              
      
      RegMapBoard *pmac_;      
      
      RegMapBlock *host_read_; 

    }; // End class SpecificPmacLock
    
    //------------------------------------------------------------
    // SpecificShare Methods
    //------------------------------------------------------------
    
    struct HostAddress {
      char* name;
      char* address;
    };
    
    // Static members and functions
    
    static SpecificShare* share;
    
    static HostAddress host_address[];
    
    static std::string hostIpAddress(std::string host);
    
    static void pciBusErrorHandler(int sig);
    
    static void pciSegvErrorHandler(int sig);
    
    SpecificShare(std::string host);
    
    ~SpecificShare();
    
    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(gcp::util::TimeVal& time);

    void setClock();
    
    public:

    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(gcp::util::DataFrameManager* frame);
    
    void debugTrigger();
    
    void setNewFramePending() {newFramePending_ = true;};
    
    void clearNewFramePending() {newFramePending_ = false;};
    
    bool isNewFramePending() {return newFramePending_;};
    
    // Method to add an element to the list of registers being
    // buffered

    Block* addBufferedBlock(char* boardName, char* blockName);

    // Method to copy data to the frame

    void copyBufferedBlocksToFrame();

    // Method to switch buffers

    void switchBuffers();

      private:
    
    // A vector of blocks that are currently being buffered

    std::vector<Block*> bufferedBlocks_;

    unsigned* tmpbuf_;         
    
    std::string controlHost_;       
    
    SpecificRegDb *regdb_;      
    
    volatile bool newFramePending_;    
    
    SpecificClock *clock_;          
        
    SpecificAstrom *astrom_;        
    
    SpecificPmacLock *pmac_lock_;   
    
    gcp::util::TimeVal startTime_;
    gcp::util::TimeVal endTime_;

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

#endif