Scanner.h

#ifndef GCP_MEDIATOR_SCANNER_H
#define GCP_MEDIATOR_SCANNER_H

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

#include "gcp/util/common/AntennaDataFrameManager.h"
#include "gcp/util/common/AntennaFrameBuffer.h"
#include "gcp/util/common/ArrayFrameBuffer.h"
#include "gcp/util/common/DataFrameManager.h"
#include "gcp/util/common/GenericTask.h"
#include "gcp/util/common/NetStr.h"
#include "gcp/util/common/TcpClient.h"

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

#include "gcp/mediator/specific/ScannerMsg.h"

// Don't move this around: GCC3.2.2 is easily confused!

#include "gcp/control/code/unix/libunix_src/common/scanner.h"

namespace gcp {

  namespace util {
    class ArrayDataFrameManager;
    class BoardDataFrameManager;
  }

#if DIR_HAVE_MUX

  namespace receiver {
    class DioConsumer;
    class XMLConsumer;
  }

#endif

  namespace mediator {
    
    class Master;
    class XMLConsumer;
    class AntennaConsumer;

    class Scanner :
      public gcp::util::GenericTask<ScannerMsg> {
      
      public:
      
      //------------------------------------------------------------
      // Scanner public members
      //------------------------------------------------------------
      
      ~Scanner();
      
      void packAntennaFrame(gcp::util::AntennaDataFrameManager* frame);
      
#if DIR_HAVE_MUX

      void packBolometerFrame();
#endif

      void packDataFrame(gcp::util::RegMapDataFrameManager* frame, 
             std::string regMapName);      
      
      void packBoard(gcp::util::BoardDataFrameManager* dataFrame);

      void packBoardSynch(gcp::util::BoardDataFrameManager* dataFrame, unsigned int id);

      void sendPackBoloDataFrameMsg();

      std::string dioHost();
      std::string hwHost();
      unsigned dioPort();
      unsigned hwPort();

      //------------------------------------------------------------
      // Scanner private members
      //------------------------------------------------------------
      
      private:

      // Needed so that  alone can instantiate this class
      
      friend class Master; 
      
      // Needed because AntennaConsumer will call our packFrame method.
      
      friend class AntennaConsumer;
      
      // Needed because DioConsumer will call our packFrame method.

      friend class DioConsumer;
      
      // Needed because XMLConsumer will call our packFrame method.
      
      friend class XMLConsumer;
      
      struct {
    unsigned transient;
    unsigned persistent;
    unsigned seq;
      } features_;

      void initAntennaResources();
      
      //------------------------------------------------------------
      // Declare startup functions for threads managed by this class.
      //------------------------------------------------------------
      
      static THREAD_START(startAntennaConsumer);  
      static THREAD_START(startReceiverConfigConsumer);
      static THREAD_START(startPointingTelConsumer);
      static THREAD_START(startHoloConsumer);
      static THREAD_START(startSecondaryConsumer);
      static THREAD_START(startFridgeConsumer);
      static THREAD_START(startDeicingConsumer);

#if DIR_HAVE_MUX
      static THREAD_START(startBolometerConsumer);
      static THREAD_START(startSquidConsumer);
#endif
      
      //------------------------------------------------------------
      // Declare cleanup handlers for threads managed by this class.
      //------------------------------------------------------------
      
      static THREAD_CLEAN(cleanAntennaConsumer);
      static THREAD_CLEAN(cleanReceiverConfigConsumer);
      static THREAD_CLEAN(cleanPointingTelConsumer);
      static THREAD_CLEAN(cleanHoloConsumer);
      static THREAD_CLEAN(cleanSecondaryConsumer);
      static THREAD_CLEAN(cleanFridgeConsumer);
      static THREAD_CLEAN(cleanDeicingConsumer);

#if DIR_HAVE_MUX
      static THREAD_CLEAN(cleanBolometerConsumer);
      static THREAD_CLEAN(cleanSquidConsumer);
#endif

      Master* parent_;
      
      AntennaConsumer* antennaConsumer_;     
      
#if DIR_HAVE_MUX

      gcp::receiver::DioConsumer* bolometerConsumer_;
      
      gcp::receiver::DioConsumer* squidConsumer_;

      gcp::receiver::XMLConsumer* receiverConfigConsumer_;
      
#endif

      XMLConsumer* deicingConsumer_;
      
      XMLConsumer* pointingTelConsumer_;
      
      XMLConsumer* holoConsumer_;

      XMLConsumer* secondaryConsumer_;
      
      XMLConsumer* fridgeConsumer_;
      
      ArrayMap* arraymap_;     
      
      std::string host_;           
      
      gcp::util::TcpClient client_;
      
      gcp::util::NetStr* arrayStr_;       
      
      static const unsigned int NUM_BUFFER_FRAMES   = 10;
      static const unsigned int MIN_FRAMES_IN_QUEUE = 4;
      gcp::util::ArrayFrameBuffer fb_;
      unsigned boloId_;
      bool dispatchPending_;

      //------------------------------------------------------------
      // Antenna resources
      //------------------------------------------------------------
      
      unsigned nAntenna_;
      
      std::vector<unsigned> nArchiveAntenna_;     
      
      std::vector<int> antStartSlots_;
      
      std::vector<int> antRecSlots_;
      
      unsigned antReceivedCurrent_;
      unsigned antReceivedLast_;
      
      void setAntReceived(bool received, 
              gcp::util::ArrayDataFrameManager* frame=0);
      
      void setAntReceived(unsigned iant, bool received, 
              gcp::util::ArrayDataFrameManager* frame=0);
      
      bool antennasChangedState();
      
      void reportStateChange();
      
      Scanner(Master* master);
      
      bool isConnected(); 
      
      bool connect();        
      
      void disconnect();     
      
      void connectScanner(bool reEnable);

      void disconnectScanner();

      void processMsg(ScannerMsg* taskMsg);
      
      gcp::util::ArrayDataFrameManager* 
    startNewArrayFrame();
      
      void initializeShare(gcp::util::TimeVal& timeVal);

      void initializeDefaultRegisters(gcp::util::ArrayDataFrameManager* frame, 
                      gcp::util::TimeVal& mjd);

      void checkDataFrames();  
      
      void pollConsumers();

      void packFrame(gcp::util::DataFrame* frame);

      void dispatchNextFrame();
    
      bool connected();
      
      //------------------------------------------------------------
      // Messaging methods
      //------------------------------------------------------------

      void sendDispatchDataFrameMsg();
      
      void sendFlagAntennaMsg(unsigned antenna, bool flag);
      
      void sendScannerConnectedMsg(bool connected);
      
      void sendControlConnectedMsg(bool connected);

      void respondToHeartBeat();
      
      void parseGreeting();
      
      static NET_READ_HANDLER(readHandler);
      
      static NET_SEND_HANDLER(sendHandler);

      static NET_ERROR_HANDLER(networkError);

      void serviceMsgQ();
      void serviceMsgQSave();

      void changeFeatures(unsigned seq, unsigned mode, unsigned mask);

      Master* parent() {return parent_;};

      void forwardDioMsg(ScannerMsg* msg);

    }; // End class Scanner
    
  } // End namespace mediator
} // End namespace gcp

#endif // End #ifndef GCP_MEDIATOR_SCANNER_H