include/nxyter/FebBase.h (r4864/r4162)

Go to the documentation of this file.

//============================================================================
//============================================================================

#ifndef NXYTER_FEBBASE_H
#define NXYTER_FEBBASE_H

#include <vector>

#include "roc/I2cDevice.h"
#include "base/Peripheral.h"
#include "nxyter/NxChip.h"
#include "nxyter/MainAdc.h"

namespace nxyter {

   class FebBase : public base::Peripheral {
      protected:
         int        fPort;                  
         int        fType;                  
         std::vector<nxyter::NxChip*>  fNxChip;  
         std::vector<bool>             fNxOffline;
         nxyter::MainAdc fMainAdc;          
         bool       fMode4nx;               
         std::vector<int> fAdcChannel;      
         roc::I2cDevice   fMonAdcDevice;    
         roc::I2cDevice   fEepromDevice;    
  
      public:
         enum FebType { kFeb1nx  = 100,     
                        kFeb1nxGenB,        
                        kFeb1nxGenC,        
                        kFeb1nxGenD,        
                        kFeb2nx  = 200,     
                        kFeb2nxGas,         
                        kFeb4nx  = 400,     
                        kFeb4nxBT           
         };

      protected:
         FebBase();
         FebBase(base::Board* board, int port, int type);
      public:
         virtual ~FebBase();

         int getPortNumber() const
           { return fPort; }

         int getFebClass() const
         { return 100*(fType/100); }

         int getFebType() const
           { return fType; }

         int numNx() const
           { return (int) fNxChip.size(); }

         nxyter::NxChip&   nx(int nxind);

         nxyter::MainAdc&  adc()
           { return fMainAdc; }

         virtual int getFebState();
         virtual int initRoc();

         virtual int probe();
         virtual int setToDefault(bool ispos0=false, bool ispos1=false);
         virtual void printNxHeadLine(std::ostream& os, int nxind);
         virtual void printRegisters(std::ostream& os, 
                                     int domask=nxyter::kDoAll);

         void resetNxI2cBus();
         void resetNxI2cRegister();


         void setNxOffline(int nxind, bool isoff)
           { fNxOffline.at(nxind) = isoff; }


         bool getNxOffline(int nxind)
           { return fNxOffline.at(nxind); }

         int setNxTestModes(bool testpuls, bool testtrig, int calselect); 
         int setNxRegisterAll(uint8_t reg, uint8_t val, bool veri=true); 


         bool monAdcSupport()
           { return fMonAdcDevice.getSlaveAddr() != 0; }


         bool eepromSupport()
           { return fEepromDevice.getSlaveAddr() != 0; }
           
         // ! return number of monitored ADC channels, 0 if not supported
         int getNumMonAdc();

         int getMonAdc(int ch, uint16_t &val);

      protected:
         void addNxChip(int addr, int nxnum, int adcmux);

      public:
         static const char* typeToString(int type);
         static int stringToType(const char* str);

         static void discoverFebs(base::Board* board,
                                  int& typeport0, int& typeport1, 
                                  bool liberal=false);

         static nxyter::FebBase* newFeb(base::Board* board, int port, int type);
   };

}


inline std::ostream& operator<<(std::ostream& os, nxyter::FebBase& obj)
  { obj.printRegisters(os); return os; }

#endif