roclib/src_roc/Board.cxx (r4864/r4162)

Go to the documentation of this file.

#include <string.h>
#include <stdio.h>

#include <iostream>
#include <string>
#include <vector>

#include "base/Url.h"

#include "roc/Board.h"
#include "roc/defines_roc.h"
#include "roc/defines_optic.h"
#include "roc/defines_udp.h"
#include "feet/defines_feet.h"

const char* roc::xmlRocPool         = "RocPool";
const char* roc::xmlTransportWindow = "TransportWindow";
const char* roc::xmlTransportKind   = "TransportKind";
const char* roc::xmlBoardAddr       = "BoardAddr";
const char* roc::xmlRole            = "Role";
const char* roc::xmlRocNumber       = "RocNumber";
const char* roc::xmlLowWater        = "LowWater";
const char* roc::xmlHighWater       = "HighWater";
const char* roc::xmlMsgFormat       = "MsgFormat";
const char* roc::xmlFlushTime       = "FlushTime";

const char* roc::typeUdpDevice      = "roc::UdpDevice";
const char* roc::typeAbbDevice      = "roc::AbbDevice";


//----------------------------------------------------------------------------

roc::Board::Board() :
   base::Board()
{

  // current ROC address def's from defines.h

  addRegAddrMapping("ROC_TYPE", ROC_TYPE);
  addRegAddrMapping("ROC_HWV", ROC_HWV);
  addRegAddrMapping("ROC_ROCID", ROC_ROCID);
  addRegAddrMapping("ROC_ADDSYSMSG", ROC_ADDSYSMSG);
  addRegAddrMapping("ROC_SYSTEM_RESET", ROC_SYSTEM_RESET);
}

//----------------------------------------------------------------------------

roc::Board::~Board()
{
}

//----------------------------------------------------------------------------

uint32_t roc::Board::getRocFpgaType()
{
   uint32_t num = 0;
   get(ROC_FPGA_TYPE, num);
   return num;
}

//----------------------------------------------------------------------------

uint32_t roc::Board::getRocSvnRev()
{
   uint32_t num = 0;
   get(ROC_SVN_REVISION, num);
   return num;
}

//----------------------------------------------------------------------------

uint32_t roc::Board::getRocBuildTime()
{
   uint32_t num = 0;
   get(ROC_BUILD_TIME, num);
   return num;
}

//----------------------------------------------------------------------------

int roc::Board::uploadCommandsList(unsigned num, const base::OperList& lst, double tmout)
{
   if (num >= ROC_CMD_LST_NUMBER) {
      Debug(-1, "Wrong number %u of commands list", num);
      return ROC_ADDRESS_ERROR;
   }

   base::OperList setlst;

   unsigned addr = ROC_CMD_LST_MEM + num * ROC_CMD_LST_SIZE / ROC_CMD_LST_NUMBER;

   for (int n=0;n<lst.number();n++) {
      if (!lst.isput(n)) {
         Debug(-1, "Only PUT operations are supported by commands list");
         return ROC_VALUE_ERROR;
      }

      if (addr >= ROC_CMD_LST_MEM + ROC_CMD_LST_SIZE) {
         Debug(-1, "Commands list to long %d for slot %u", lst.number(), num);
         return ROC_VALUE_ERROR;
      }

      setlst.addPut(addr, ROC_CMD_LST_PUT | (lst.oper(n).addr & ROC_CMD_LST_ADDRMASK));
      addr+=4;
      setlst.addPut(addr, lst.oper(n).value);
      addr+=4;
   }

   // check if last list command not specified, add it

   if ((lst.number()>0) && (lst.oper(lst.number()-1).addr != ROC_CMD_LST_ACTIVE)) {

      if (addr >= ROC_CMD_LST_MEM + ROC_CMD_LST_SIZE) {
         Debug(-1, "Commands list to long %d for slot %u", lst.number(), num);
         return ROC_VALUE_ERROR;
      }

      setlst.addPut(addr, ROC_CMD_LST_PUT | ROC_CMD_LST_ACTIVE);
      addr+=4;
      setlst.addPut(addr, 0);
      addr+=4;
   }

   return operGen(setlst, tmout);
}

//----------------------------------------------------------------------------

int roc::Board::downloadCommandsList(unsigned num, base::OperList& lst, double tmout)
{
   lst.clear();

   if (num >= ROC_CMD_LST_NUMBER) {
      Debug(-1, "Wrong number %u of commands list", num);
      return ROC_ADDRESS_ERROR;
   }

   base::OperList getlst;

   unsigned addr = ROC_CMD_LST_MEM + num * ROC_CMD_LST_SIZE / ROC_CMD_LST_NUMBER;

   unsigned lastaddr = addr + ROC_CMD_LST_SIZE / ROC_CMD_LST_NUMBER;

   while (addr<lastaddr) {
      getlst.addGet(addr);
      addr+=4;
   }

   int res = operGen(getlst, tmout);

   if (res!=0) return res;

   for (int n=0;n<getlst.number();n+=2) {
      uint32_t addr = getlst.oper(n).value;
      uint32_t value = getlst.oper(n+1).value;

      if ((addr & ROC_CMD_LST_PUT) == 0) {
         Debug(-1, "Commands list %u has non-Put operation", num);
         return ROC_VALUE_ERROR;
      }

      addr = addr & ROC_CMD_LST_ADDRMASK;
      if (addr==ROC_CMD_LST_ACTIVE) break;
      lst.addPut(addr, value);
   }

   return 0;
}


//----------------------------------------------------------------------------

int roc::Board::uploadStartDaqCmdList(bool reset_frontend, bool reset_fifo)
{
   base::OperList lst;
   uint32_t hw_kind = getRocFrontendKind();

   if (hw_kind==kind_nXYTER) {

      if (reset_frontend && (getTransportKind() == kind_UDP)) {
         lst.addPut(ROC_NX_TS_RESET, 1);
         lst.addPut(ROC_NX_TS_RESET, 0);
      }
      if (reset_fifo) {
         lst.addPut(ROC_NX_FIFO_RESET, 1);
         lst.addPut(ROC_NX_FIFO_RESET, 0);
      }

   } else 

      if ((hw_kind==kind_FEET) || (hw_kind==kind_oldFEET)) {
         if (reset_frontend)
            lst.addPut(ROC_FEET_RESET, 1);
         if (reset_fifo) {
            lst.addPut(ROC_FEET_FIFO_RESET, 1);
            lst.addPut(ROC_FEET_FIFO_RESET, 0);
         }
         lst.addPut(ROC_FEET_CMD_TO_FEET, 0x28);
         lst.addPut(ROC_FEET_CMD_TO_FEET, 0x2f);
      }

   if (getTransportKind() == kind_UDP)
      lst.addPut(ROC_ETH_START_DAQ, 1);
   else
      lst.addPut(ROC_OPTICS_START_DAQ, 1);

   return uploadCommandsList(0, lst, 3.);
}

//----------------------------------------------------------------------------

int roc::Board::uploadStopDaqCmdList()
{
   base::OperList lst;

   if (getTransportKind() == kind_UDP)
      lst.addPut(ROC_ETH_STOP_DAQ, 1);
   else
      lst.addPut(ROC_OPTICS_STOP_DAQ, 1);

   return uploadCommandsList(1, lst, 3.);
}



int roc::Board::setToDefault()
{
   int res = base::Board::setToDefault();
   if (res==0) res = uploadStartDaqCmdList();
   if (res==0) res = uploadStopDaqCmdList();
   return res;
}

//----------------------------------------------------------------------------

int roc::Board::invokeCommandsList(unsigned num, double tmout)
{
   return put(ROC_CMD_LST_NR, num, tmout);
}

//----------------------------------------------------------------------------

roc::Board* roc::Board::Connect(const char* name, roc::ClientRole role)
{
   std::string sname(name);

   base::Board* brd = base::Board::Connect(sname.c_str(), (base::ClientRole) role);

   if (brd==0) return 0;

   roc::Board* rocbrd = dynamic_cast<roc::Board*> (brd);

   if (rocbrd==0) {
      fprintf(stderr,"Non-ROC board created with url %s\n", name);
      base::Board::Close(brd);
      return 0;
   }

   return rocbrd;
}

//----------------------------------------------------------------------------

bool roc::Board::Close(Board* brd)
{
   return base::Board::Close(brd);
}

//----------------------------------------------------------------------------

uint32_t roc::Board::getRoclibVersion()
{
   return KNUT_VERSION;
}

//----------------------------------------------------------------------------

uint32_t roc::Board::getRocHardwareVersion()
{
   uint32_t val = 0;
   get(ROC_HWV, val);
   return val;
}

//----------------------------------------------------------------------------

uint32_t roc::Board::getRocHardwareType()
{
   uint32_t val = 0;
   get(ROC_TYPE, val);
   return val;
}

//----------------------------------------------------------------------------

void roc::Board::clearRocFifo()
{
   operPP(ROC_NX_FIFO_RESET, 1,
          ROC_NX_FIFO_RESET, 0);
}

//----------------------------------------------------------------------------

void roc::Board::restartRoc()
{
   put(ROC_SYSTEM_RESET, 1);
}

//----------------------------------------------------------------------------

int roc::Board::getRocThrottleState(uint32_t& val)
{
   return get(ROC_NX_THROTTLE, val);
}


bool roc::Board::IsUdpAddress(const char* name)
{
   base::Url url(name);

   // for any kind of invalid url we will try to create udp
   if (!url.IsValid()) return true;

   if (url.GetProtocol()=="udp") return true;

   if (url.GetProtocol().empty() && (url.GetHostName().find("abb")!=0)) return true;

   return false;

}


bool roc::Board::IsOpticAddress(const char* name)
{
   base::Url url(name);

   if ((url.GetProtocol().length()>0) && (url.GetProtocol()!="optic")) return false;

   // any optic address must contain abb in the beginning of the address
   return url.GetHostName().find("abb")==0;
}



bool roc::Board::IsLmdFileAddress(const char* name)
{
   base::Url url(name);

   if (!url.IsValid()) return false;

   if (url.GetProtocol()=="file") return true;

   if (url.GetProtocol().empty() && (url.GetFullName().find(".lmd")!=std::string::npos)) return true;

   return false;
}