include/base/Board.h (r4864/r4162)

Go to the documentation of this file.

#ifndef BASE_BOARD_H
#define BASE_BOARD_H

#include "base/OperList.h"

#include <string>

#include <iostream>
#include <map>
#include <list>

namespace base {

  class BoardFactory;

  enum ClientRole {
     roleNone      = 0,            
     roleObserver  = 1,           
     roleControl   = 2,           
     roleDAQ       = 3            
   };

  extern const char* roleToString(ClientRole role);
  extern ClientRole defineClientRole(const char* name,
                                     ClientRole dflt = roleObserver);

  enum EFrontendKinds {
     kind_nXYTER = 1,  // normal nXYTER
     kind_oldFEET = 2, // old GET4, keep for historical reasons
     kind_FEET = 3,    // new GET4 v1.0,
     kind_newNX = 4,   // new readout for nXYTER with SysCore3
     kind_SPADIC = 5   // future SPADIC v1 firmware
  };

  enum EBackendKinds {
     kind_Optic    = 1,  // normal Optic readout - CBMNet v1
     kind_FX20     = 2,
     kind_FX40     = 3,
     kind_FX60     = 4,
     kind_newOptic = 5   // new optic readout - CBMNet v2
  };


  enum ETransportKinds {
     kind_UDP = 0,   // Ethernet for SysCore2
     kind_ABB = 1,   // Optic via AVNet
     kind_File = 2,  // LMD file
     kind_USB = 3    // USB to SysCore3
  };

  enum BasicAddresses {
     addr_HardwareType    = 0x00,
     addr_HardwareVersion = 0x04,
     addr_BoardId         = 0x10
  };


   class Board {
      friend class BoardFactory;

      protected:

         typedef std::map<std::string,uint32_t> mapn2a_t;
         typedef std::map<uint32_t,std::string> mapa2n_t;

         mapn2a_t fMapName2Addr;
         mapa2n_t fMapAddr2Name;

         BoardFactory*  fBrdFactory; 
         double         fDefaultTimeout;    
         int            fVerbosity;         
         int            fOperTrace;         
         ClientRole     fRole;              
         uint32_t       fBrdNumber;         



         Board();
         virtual ~Board();

         void traceOper(OperList& lst,  int rc);

         void setRole(ClientRole role) { fRole = role; }

         uint32_t initBoard(const char* name, uint32_t minversion);

      public:


         enum operErr {
           kOperSuccess    = 0,             
           kOperAddrErr    = 2,             
           kOperValueErr   = 3,             
           kOperStateErr   = 4,             
           kOperNetworkErr = 6,             
           kHostError      = 8,             
           kOperVerifyErr  = 20,            
           kOperBusErr     = 21            
         };

         enum addrErr {
            kAddrError = 0xffffffff         
         };


         void setDefaultTimeout(double tmout = 2.) { fDefaultTimeout = tmout>0 ? tmout : 1.; }

         double getDefaultTimeout() const { return fDefaultTimeout; }

         void setVerbosity(int lvl = 0) { fVerbosity = lvl; }
         int getVerbosity() const { return fVerbosity; }

         ClientRole getRole() const { return fRole; }

         void Debug(int lvl, const char *fmt, ...);



         void setOperTrace(int lvl = 1) { fOperTrace = lvl; }

         int getOperTrace() const { return fOperTrace; }



         virtual int operGen(OperList& lst, double tmout = 0.) = 0;

         virtual int operGen(bool* isput,
                             uint32_t* addr,
                             uint32_t* value,
                             int num,
                             double tmout = 0.);

         virtual unsigned GetBoardId() const { return 0; }

         int put(uint32_t addr, uint32_t value, double tmout = 0.);
         int get(uint32_t addr, uint32_t& value, double tmout = 0.);

         int operPP(uint32_t addr0, uint32_t  val0p,
                    uint32_t addr1, uint32_t  val1p,
                    double tmout = 0.);
         int operPG(uint32_t addr0, uint32_t  val0p,
                    uint32_t addr1, uint32_t& val1g,
                    double tmout = 0.);
         int operPPP(uint32_t addr0, uint32_t  val0p,
                     uint32_t addr1, uint32_t  val1p,
                     uint32_t addr2, uint32_t  val2p,
                     double tmout = 0.);
         int operGGG(uint32_t addr0, uint32_t&  val0p,
                     uint32_t addr1, uint32_t&  val1p,
                     uint32_t addr2, uint32_t&  val2p,
                     double tmout = 0.);
         int operPPPP(uint32_t addr0, uint32_t  val0p,
                      uint32_t addr1, uint32_t  val1p,
                      uint32_t addr2, uint32_t  val2p,
                      uint32_t addr3, uint32_t  val3p,
                      double tmout = 0.);


         static int operErrCode(int rc)
            { return rc & 0xff; }


         static int operErrIndex(int rc)
            { return (rc>>8) & 0xffffff; }


         static int operErrBuild(int code, int index)
           { return (code & 0xff) | ((index & 0xffffff)<<8); }


         static int operErrBuildInc(int rc, int inc)
           { return operErrBuild(rc,  operErrIndex(rc) + inc); }

         static std::string operErrToString(int rc);

         static const char* operErrCodeName(int rc);


         uint32_t findRegAddressByName(const char* name);
         const char* findRegNameByAddress(uint32_t addr);
         void printRegAddressMap(std::ostream& os, bool byname=false);
         void addRegAddrMapping(const char* name, uint32_t addr);
         void fillRegAddrNames(std::list<std::string>& lst);



         virtual int getTransportKind() const = 0;


         bool isFile() const { return getTransportKind() == base::kind_File; }

         bool isOptic() const { return getTransportKind() == base::kind_ABB; }

         bool isUSB() const { return getTransportKind() == base::kind_USB; }

         virtual bool restartBoard() { return false; }

         virtual bool is_SPI_I2C() const { return false; }

         virtual int setToDefault() { return 0; }


         virtual uint32_t getHardwareType();

         virtual uint32_t getHardwareVersion();


         virtual uint32_t getFrontendKind() { return getHardwareType() >> 16; }

         virtual uint32_t getBackendKind() { return getHardwareType() & 0xffff; }


         uint32_t boardNumber() const { return fBrdNumber; }

         uint32_t getBoardNumber();

         void setBoardNumber(uint32_t num);

         virtual int invokeDLM(unsigned num, double tmout = 0.) { return 0; }

         // DAQ methods



         virtual bool startDaq() = 0;


         virtual bool suspendDaq() = 0;


         virtual bool stopDaq() = 0;




         virtual bool getNextBuffer(void* &buf, unsigned& len, double tmout = 1.) = 0;


         virtual int getMsgFormat() const = 0;


         virtual void setFlushTimeout(double tmout) {}



         static Board* Connect(const char* url, ClientRole role = roleNone);
         static bool Close(Board* brd);

         static const char* versionToString(uint32_t ver);

   };

   class BoardFactory {

      protected:

         enum { MaxNumFactories = 10 };
         static BoardFactory* gArr[MaxNumFactories];

         BoardFactory();
         virtual ~BoardFactory();

      public:

         virtual bool IsFactoryFor(const char* url) { return false; }

         virtual void ShowDebug(int lvl, const char* msg);

         virtual Board* DoConnect(const char* name, base::ClientRole role) = 0;
         virtual bool DoClose(Board* brd) = 0;

         static Board* CreateBoard(const char* url, ClientRole role = roleNone);
         static bool DestroyBoard(base::Board* brd);
   };

}


#endif