abbplugin/src/AbbFactory.cxx (r4864/r3116)

Go to the documentation of this file.

#include "roc/AbbFactory.h"

#include "base/Url.h"

#include "roc/AbbDevice.h"
#include "roc/ReadoutModule.h"
#include "roc/SplitterModule.h"
#include "roc/AbbBoard.h"
#include "sp605/OpticBoard.h"

#include "dabc/Command.h"
#include "dabc/logging.h"
#include "dabc/Manager.h"
#include "dabc/MemoryPool.h"

dabc::FactoryPlugin rocabbfactory(new roc::AbbFactory("abb"));

roc::AbbFactory::AbbFactory(const char* name) :
   dabc::Factory(name),
   base::BoardFactory()
{
}

dabc::Device* roc::AbbFactory::CreateDevice(const char* classname, const char* devname, dabc::Command cmd)
{
   if (strcmp(classname, roc::typeAbbDevice)==0) {
      DOUT2(("roc::AbbFactory::CreateDevice - Creating Abb UdpDevice %s ...", devname));

      roc::AbbDevice* dev = new roc::AbbDevice(devname, cmd.GetStr("Thread"), cmd);

      if (!dev->IsConnected()) {
         dabc::Object::Destroy(dev);
         return 0;
      }

      return dev;
   }

   return 0;
}

dabc::Module* roc::AbbFactory::CreateModule(const char* classname, const char* modulename, dabc::Command cmd)
{
   DOUT2(("roc::AbbFactory::CreateModule called for class:%s, module:%s", classname, modulename));

   if (strcmp(classname, "roc::SplitterModule")==0) {
      DOUT2(("roc::AbbFactory::CreateModule - Created roc::SplitterModule %s ", modulename));
      return new roc::SplitterModule(modulename, cmd);
   }

   return 0;
}

void roc::AbbFactory::ShowDebug(int lvl, const char* msg)
{
   if (lvl<0) EOUT((msg));
        else DOUT0((msg));
}


bool roc::AbbFactory::IsFactoryFor(const char* name)
{
   return roc::Board::IsOpticAddress(name);
}


base::Board* roc::AbbFactory::DoConnect(const char* name, base::ClientRole role)
{
   // name is always start with prefix abb
   // Allowed following names:
   //     "abbN"   - N is SFP number on ABB board
   //     "abbNY"  - N is SFP number (0,1) on ABB board and Y is SFP number on DCB board (0,1,2,3)
   // For boards other than ROC bord type must be specified like:
   //     "abb1/sp605" - Means board sp605 is connected to the second SFP of ABB
   // Optionally, optic:// protocol can be specified:
   //   optic://abb1/syscore2

   if (!roc::Board::IsOpticAddress(name)) return false;

   unsigned path = roc::AbbDevice::GetOpticPath(name);

   if (path == roc::AbbDevice::UndefinedOpticPath) {
      EOUT(("Optic path cannot be defined"));
      return false;
   }


   DOUT3(("Found optic address"));

//   dabc::SetDebugLevel(0);

   if (dabc::mgr.null()) {
      if (!dabc::Factory::CreateManager("dabc")) return 0;

      dabc::SetDebugLevel(0);
      dabc::lgr()->SetLogLimit(1000000);
      dabc::lgr()->SetDebugMask(dabc::lgr()->GetDebugMask() & ~dabc::Logger::lTStamp);

      dabc::Manager::SetAutoDestroy(true);
   }


   std::string devname = "/roc/Abb";
   
   DOUT3(("Creating ABB device"));
   if (!dabc::mgr.FindDevice(devname).null()) {
      EOUT(("Device with name %s already exists!!!", devname.c_str()));
      return 0;
   }
   
   dabc::mgr.CreateDevice(typeAbbDevice, devname.c_str(), "RocAbbThrd");

   AbbDevice* dev = dynamic_cast<roc::AbbDevice*> (dabc::mgr.FindDevice(devname).GetObject());
   
   if (dev==0) {
      EOUT(("Cannot create AbbDevice class !!!"));
      return 0;
   }
   
   DOUT3(("Creating ABB board"));

   roc::AbbBoard* brd = 0;
   sp605::OpticBoard* brd2 = 0;
   base::Board* resbrd = 0;

   base::Url url(name);
   if (url.IsValid()) {
      if (url.HasOption(roleToString(base::roleDAQ))) role = base::roleDAQ; else
      if (url.HasOption(roleToString(base::roleControl))) role = base::roleControl; else
      if (url.HasOption(roleToString(base::roleObserver))) role = base::roleObserver;
   }

   if (role==base::roleNone) role = base::roleObserver;

   if (url.GetFileName() == "sp605") {

      brd2 = new sp605::OpticBoard(dev, path, role);

      if (!brd2->initAbbBoard()) { delete brd2; return 0; }

      resbrd = brd2;

   } else {

      brd = new roc::AbbBoard(dev, path, role);

      if (!brd->initAbbBoard()) { delete brd; return 0; }

      resbrd = brd;
   }

   if (role == base::roleDAQ) {

      DOUT3(("Creating readout module"));

      std::string modname = "/roc/AbbReadout";
      std::string poolname = "/roc/AbbPool";

      bool res = dabc::mgr.CreateMemoryPool(poolname.c_str(), 16384, 100);

      dabc::CmdCreateModule cmd("roc::ReadoutModule", modname.c_str(), "RocAbbThrd");
      cmd.SetStr("PoolName", poolname);
      if (!dabc::mgr.Execute(cmd)) res = false;

      dabc::CmdCreateTransport cmd2(FORMAT(("%s/Input",modname.c_str())), devname);
      cmd2.SetStr(roc::xmlBoardAddr, name);

      if (res && !dabc::mgr.Execute(cmd2)) res = false;

      ReadoutModule* rm = dynamic_cast<roc::ReadoutModule*>(dabc::mgr.FindModule(modname.c_str()).GetObject());

      if (!res || (rm==0)) { DoClose(resbrd); return 0; }

      if (brd)
         brd->setReadout(rm);
      else
         brd2->setReadout(rm);
   }

   DOUT3(("Did connect %p", resbrd));

   return resbrd;
}

bool roc::AbbFactory::DoClose(base::Board* brd)
{
   if (brd==0) return true;
   
   roc::AbbBoard* abbbrd = dynamic_cast<roc::AbbBoard*> (brd);
   sp605::OpticBoard* sp605brd = dynamic_cast<sp605::OpticBoard*> (brd);
   
   if (abbbrd!=0) { delete abbbrd; } else
   if (sp605brd!=0) { delete sp605brd; } else {
      EOUT(("Wrong board class"));
      return false;
   }


//   DOUT0(("Manager = %s", DBOOL(dabc::mgr.null())));
   
   // delete device when no more board classes

   if (dabc::mgr.null()) return true;

//   dabc::mgr.StopModule("/roc/AbbReadout");
   dabc::mgr.DeleteModule("/roc/AbbReadout");
   dabc::mgr.FindDevice("/roc/Abb").Destroy();
   dabc::mgr.FindItem("/roc/AbbPool").Destroy();

   dabc::mgr.SyncWorker();
   
   return true;
}