Scanner.h

#ifndef SCANNER_H
#define SCANNER_H

#include <list>

#include "gcp/util/common/AntNum.h"
#include "gcp/util/common/DataFrameManager.h"

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

#include "gcp/antenna/control/specific/FrameBoard.h"
#include "gcp/antenna/control/specific/FrameSender.h"
#include "gcp/antenna/control/specific/SpecificShare.h"

namespace gcp {
  namespace antenna {
    namespace control {
      
      
      class Scanner {
    
      public:
    
    Scanner(SpecificShare* share, gcp::util::AntNum* ant);
    
    ~Scanner();
    
    void packNextFrame();

    void dispatchNextFrame(FrameSender* consumer);
    
    gcp::util::DataFrameManager* dispatchNextFrame();

    unsigned int getNframesInQueue();

    std::list<Board*> listBoards();
    
      private:
    
    SpecificShare* share_;

    gcp::util::AntennaFrameBuffer fb_;
    
    FrameBoard* frame_; 
    
    //------------------------------------------------------------
    // Internal record-keeping structs
    //------------------------------------------------------------
    
    struct Features {
      unsigned seq_;  // Sequence number of the last feature
      // marker command received from the control
      // program
      unsigned transient_;  // Bit-mask union of persistent
      // feature markers received from the
      // control program since the last
      // frame.
      unsigned persistent_; // The bit mask union of persistent
      // feature markers previously received
      // from the control program but not
      // cancelled.
      void reset();
    } features_;
    /*
     * A structure of the following type is used to store the
     * current bit mask of receiver walsh states, and the bit mask
     * of walsh states which was in effect during the frame that
     * we are currently sending to the archiver.
     */
    struct Walsh {
      bool request_on_; // If walshing is requested, this will be
      // set to true. If requested, slow
      // walshing will commence on the next
      // invocation of the tgen interrupt
      // handler. If walshing is currently on,
      // walshing will cease at the end of the
      // current walsh cycle.
      bool current_on_; // True if walshing was on during the
      // last integration.  at the end of the
      // current walsh cycle.
      int counter_;     // The walsh iteration counter.  This
      // tells the scanner where in the walsh
      // cycle we currently are. 
      unsigned current_state_; // The current bit mask of walsh states 
      unsigned last_state_;    // The bit mask for the frame we
      // are currently sending
      void reset();
    } walsh_;
    
    
    void initialize();
    
    void recordFeatures();
    
    void setTime();
    
    void recordTime();
    
    void recordRecordNumber(unsigned nrecord);
    
    void recordWalshState();
    
    bool skipOne_; 
    
    unsigned recordNumber_; 
    
      }; // End class Scanner
      
    }; // End namespace control
  }; // End namespace antenna
} // End namespace gcp

#endif // End #ifndef