bnet/src/RocWorkerApplication.cxx (r4864/r4113)

Go to the documentation of this file.

/********************************************************************
 * The Data Acquisition Backbone Core (DABC)
 ********************************************************************
 * Copyright (C) 2009-
 * GSI Helmholtzzentrum fuer Schwerionenforschung GmbH
 * Planckstr. 1
 * 64291 Darmstadt
 * Germany
 * Contact:  http://dabc.gsi.de
 ********************************************************************
 * This software can be used under the GPL license agreements as stated
 * in LICENSE.txt file which is part of the distribution.
 ********************************************************************/
#include "bnet/RocWorkerApplication.h"

#include "dabc/logging.h"
#include "dabc/Manager.h"
#include "dabc/Device.h"
#include "dabc/Configuration.h"
#include "dabc/Parameter.h"

#include "bnet/GeneratorModule.h"

#include "roc/Board.h"
#include "roc/UdpBoard.h"
#include "roc/Commands.h"
#include "roc/CombinerModule.h"
#include "roc/ReadoutApplication.h"

#include "bnet/RocFactory.h"

bnet::RocWorkerApplication::RocWorkerApplication() :
   bnet::MbsWorkerApplication(xmlRocWorkerClass),
   fRocBrds(),
   fCalibrState(calNONE),
   fCombinerName()
{
   // register application specific parameters here:

   CreateParInt(roc::xmlSyncNumber, 0);
   CreateParInt(roc::xmlSyncScaleDown, 2);

   CreateParBool(roc::xmlMeasureADC, false);
   CreateParBool(roc::xmlUseDLM, false);

   CreateParInt(roc::xmlSpillRoc, -1);
   CreateParInt(roc::xmlSpillAux, -1);
   CreateParDouble(roc::xmlCalibrationPeriod, -1.);
   CreateParDouble(roc::xmlCalibrationLength, 0.5);

   for (int nr=0;nr<NumReadouts();nr++)
      CreateParStr(FORMAT(("%s%d", roc::xmlRocFebs, nr)));

   CreateParInt(roc::xmlMBSSyncRoc, -1);
   CreateParInt(roc::xmlMBSSyncNumber, -1);
   CreateParStr(roc::xmlMBSSyncNode, "");
   CreateParInt(roc::xmlMBSSyncProcId, -1);
   
   CreateParStr(roc::xmlEpicsStreamNode, "");
   CreateParStr(roc::xmlEpicsTransportNode, "");
   
   fDoMeasureADC = false;
}


bool bnet::RocWorkerApplication::CreateCombiner(const char* modulename)
{
   fRocBrds.returnBoards();
   for(int n=0; n<NumReadouts(); n++) 
      fRocBrds.addRoc(ReadoutPar(n), GetParStr(FORMAT(("%s%d", roc::xmlRocFebs, n))));
 
   fCombinerName = modulename;
   
   fDoMeasureADC = GetParBool(roc::xmlMeasureADC, false);
   
   return roc::ReadoutApplication::CreateRocCombiner(modulename,                                               // modulename
         true,                                                     // bnet mode
         GetParStr(bnet::CfgReadoutPool, bnet::ReadoutPoolName).c_str(),   // inp pool name
         bnet::TransportPoolName,                                  // out pool name
         GetParInt(bnet::xmlTransportBuffer, 16*1024),             // buffer size
         1,                                                        // num outputs
         true,                                                     // skip error data
         GetParStr(roc::xmlMBSSyncNode,"").c_str(),                // optional MBS node
         GetParStr(roc::xmlEpicsStreamNode, "").c_str(),          // epics stream node
         fRocBrds);
}


bool bnet::RocWorkerApplication::CreateReadout(const char* portname, int portnumber)
{
   // this method is obsolete in this application, 
   // while combiner module with all inputs connected will be create in CreateCombiner method
   // here we can create some debug parameters for ADC values
   
   
   if (IsGenerator()) return false;
   
   if (fDoMeasureADC && (portnumber<(int)fRocBrds.size()) && (fRocBrds[portnumber].brd!=0))
     for (int nfeb=0;nfeb<2;nfeb++)
      for (int nadc=0;nadc<fRocBrds.numAdc(portnumber, nfeb);nadc++) {
         std::string parname = dabc::format("ROC%u_FEB%d_ADC%d", fRocBrds[portnumber].brd->rocNumber(), nfeb, nadc);

         if (!FindPar(parname.c_str())) {
            dabc::RateParameter* par = new dabc::RateParameter(this, parname.c_str(), true, 5., "adc", 0, 0xfff, 4, 0);
            par->SetDebugOutput(false);
         }
      }


   return true;
}

std::string bnet::RocWorkerApplication::GetCombinerOutputName(const char* name)
{
   return dabc::format("%s/Output0", name);
}

int bnet::RocWorkerApplication::ExecuteCommand(dabc::Command* cmd)
{
   if (cmd->IsName(roc::CmdCalibration::CmdName())) {
//      bool flag = cmd->GetBool(roc::CmdCalibration::FlagName(), true);
//      dabc::Command* gcmd = new roc::CmdGlobalCalibration(flag);
//      dabc::SetCmdReceiver(gcmd, GetParStr(CfgClusterMgr).c_str(), dabc::xmlAppDfltName);
//      dabc::mgr()->Submit(gcmd);
//      return dabc::cmd_true;
      dabc::SetCmdReceiver(cmd, GetParStr(CfgClusterMgr).c_str(), dabc::xmlAppDfltName);
      dabc::mgr()->Submit(cmd);
      return dabc::cmd_postponed;
   } else
   if (cmd->IsName(roc::CmdGlobalCalibration::CmdName())) {
      bool flag = cmd->GetBool(roc::CmdGlobalCalibration::FlagName(), true);
      SwitchCalibrationMode(flag);
      return dabc::cmd_true;
   }

   return bnet::MbsWorkerApplication::ExecuteCommand(cmd);
}

bool bnet::RocWorkerApplication::AfterAppModulesStopped()
{
   if (fCalibrState == calON)
      SwitchCalibrationMode(false);
   return bnet::MbsWorkerApplication::AfterAppModulesStopped();
}

bool bnet::RocWorkerApplication::SwitchCalibrationMode(bool on)
{
   if ((fCalibrState == calON) && on) return true;

   if ((fCalibrState == calOFF) && !on) return true;

   DOUT0(("SwitchCalibration %s %5.2f", DBOOL(on), TimeStamp()*1e-6));

   if (on && fDoMeasureADC) {
      roc::MessagesVector* vect = fRocBrds.readoutExtraMessages();

      if (vect!=0) {

         for (unsigned n=0; n<vect->size(); n++)
            if (vect->at(n).isSysMsg() && vect->at(n).getSysMesType()==roc::SYSMSG_ADC) {
               uint32_t val = vect->at(n).getSysMesData();

               std::string parname = dabc::format("ROC%u_FEB%d_ADC%d", vect->at(n).getRocNumber(), val >> 31, (val >> 24) & 0x7f);

               SetParStr(parname.c_str(), dabc::format("%u", val & 0xffffff));

//               dabc::RateParameter* rate = dynamic_cast<dabc::RateParameter*> (FindPar(parname.c_str()));
//               if (rate) rate->ChangeRate(val & 0xffffff);
            }


         dabc::Command* cmd = new roc::CmdMessagesVector(vect);
         dabc::SetCmdReceiver(cmd, fCombinerName.c_str());
         dabc::mgr()->Submit(cmd);
      }
   }

   fRocBrds.autoped_switch(on);

   //  DLM 10/11 not implemented for calibration switch on/off
   // fRocBrds.issueDLM(on ? 10 : 11);

   fCalibrState = on ? calON : calOFF;

   return true;
}


bool bnet::RocWorkerApplication::BeforeAppModulesDestroyed()
{
   fRocBrds.returnBoards();

   fCombinerName.clear();

   return bnet::MbsWorkerApplication::BeforeAppModulesDestroyed();
}