spadicplugin/src/SusiboInput.cxx (r4864/r3233)

Go to the documentation of this file.

#include "spadic/SusiboInput.h"

#include "dabc/Port.h"
#include "dabc/Pointer.h"
#include "mbs/MbsTypeDefs.h"
#include "spadic/Message.h"

#include "base/commons.h"

#include "spadiclib.h"


#include <vector>

spadic::SusiboInput::SusiboInput(const char* name, uint32_t bufsize) :
   dabc::DataInput(),
   fBoardID(1),
   fBufferSize(bufsize),
   fMaxBufferEvents(1),
   fHitDelay(100),
   fFormatMbs(true),
   fTestTrigger(false),
   fTriggerPerSecond(10),
   fTimeout(0.1),
   fLib(0)
{
}

spadic::SusiboInput::~SusiboInput()
{
   Close();
}

bool spadic::SusiboInput::Read_Init(const dabc::WorkerRef& wrk, const dabc::Command& cmd)
{
   fBoardID = wrk.Cfg(spadic::xmlSusiboDevID, cmd).AsInt(fBoardID);
   fBufferSize = wrk.Cfg(dabc::xmlBufferSize, cmd).AsInt(fBufferSize);
   fMaxBufferEvents = wrk.Cfg(spadic::xmlEventsPerBuffer, cmd).AsInt(fMaxBufferEvents);
   fHitDelay = wrk.Cfg(spadic::xmlHitDelay, cmd).AsInt(fHitDelay);
   fFormatMbs = wrk.Cfg(spadic::xmlFormatMbs, cmd).AsBool(fFormatMbs);
   fTimeout = wrk.Cfg(spadic::xmlTimeout, cmd).AsDouble(fTimeout);
   fTestTrigger = wrk.Cfg(spadic::xmlUseInternalTrigger, cmd).AsBool(fTestTrigger);
   fTriggerPerSecond = wrk.Cfg(spadic::xmlInternalTriggerFreq, cmd).AsDouble(fTriggerPerSecond);
   DOUT1(("SusiboInput for board %d - BufferSize = %d byte, Timeout = %3.2f s, Delay=%d, TestTrigger=%3.1f Hz",
         fBoardID, fBufferSize, fTimeout, fHitDelay, (fTestTrigger ? fTriggerPerSecond : -1.)));

   return Init();
}

bool spadic::SusiboInput::Init()
{
   Close();
   if (fBufferSize==0) {
      EOUT(("Buffer size not specified !!!!"));
      return false;
   }

   fLib = new SuS::SpadicLib();

   if (!fLib->connectSpadic(SuS::SpadicIO::Ftdi, true, true, fBoardID, fHitDelay)) {
      EOUT(("Cannot connect to Susibo board %d",fBoardID));
      delete fLib;
      fLib = 0;
      return false;
   }
   DOUT1(("SusiboInput: connected to board id %d", fBoardID));

   fLastTriggerTime.GetNow();

   return true;
}

bool spadic::SusiboInput::Close()
{
   if(fLib) {
      fLib->disconnectSpadic();
      int timeout = 1000;
      while(!fLib->isReady() && timeout-- > 0) dabc::Sleep(0.001);
      if(timeout <= 0) EOUT(("could not disconnect SPADIC %d, timeout", fBoardID));
      if (timeout>900) dabc::Sleep(0.1); // need this waitstate still to avoid thread error message? JAM
      delete fLib;
      fLib = 0;
   }

   return true;
}

unsigned spadic::SusiboInput::Read_Size()
{
   return fBufferSize;
}

unsigned spadic::SusiboInput::Read_Complete(dabc::Buffer& buf)
{

   /* invoke test trigger*/

   if (fTestTrigger && (fTriggerPerSecond > 0.)) {
      if (fLastTriggerTime.Expired(1./fTriggerPerSecond)) {
         DOUT3(("SusiboInput:: sending test trigger %d, thrshld= %d", trigcounter, thrshld));
         fLib->write(0x11, 0x01); //negedge
         fLib->write(0x11, 0x00); //and back to 1
         fLastTriggerTime.GetNow();
      }
   }

   int nmax = buf.GetTotalSize() / (SUSIBO_PACKAGE_LENGTH + (fFormatMbs ? (sizeof(mbs::EventHeader) + sizeof(mbs::SubeventHeader)) : 0));
   if(fMaxBufferEvents>0 && fMaxBufferEvents<nmax)
      nmax=fMaxBufferEvents;
   std::list< std::vector<uint8_t> > packages;
   int numread = fLib->readPackages(packages, nmax);

   if (numread != (int) packages.size()) {
      EOUT(("Size of list %u differs from return value %d", packages.size(), numread));
   }

   std::vector<unsigned> msgs_ids; 
   bool isbadmsg = false;

   dabc::Pointer ptr = buf.GetPointer();
   unsigned totallen = 0;
   while (packages.size() > 0) {
      spadic::Message msg(&packages.front());
      if (msg.CheckMessage()) {
//         DOUT0(("Normal message id:%08d", msg.GetEventIDNumber()));

         msgs_ids.push_back(msg.GetEventIDNumber());

//         DOUT3(("SusiboInput::CheckMessage true"));
         if (fFormatMbs) {
//            DOUT3(("SusiboInput::FormatMbs true"));
            // find out trigger id number and put this into event number
            mbs::EventHeader* evhdr = (mbs::EventHeader*) ptr();
            evhdr->Init(msg.GetEventIDNumber());
            buf.Shift(ptr, sizeof(mbs::EventHeader));
            totallen += sizeof(mbs::EventHeader);
            mbs::SubeventHeader* subhdr = (mbs::SubeventHeader*) ptr();
            subhdr->Init();
            subhdr->iProcId = roc::proc_TRD_Spadic;
            subhdr->iSubcrate = fBoardID;
            subhdr->iControl = spadic::Message::packageStruct;
            buf.Shift(ptr, sizeof(mbs::SubeventHeader));
            totallen += sizeof(mbs::SubeventHeader);
            subhdr->SetRawDataSize(SUSIBO_PACKAGE_LENGTH);
            evhdr->SetSubEventsSize(sizeof(mbs::SubeventHeader) + SUSIBO_PACKAGE_LENGTH);
            buf.SetTypeId(mbs::mbt_MbsEvents);
         } else {
            buf.SetTypeId(spadic::bt_Spadic);
         }
         
/*         double sum=0;
         for (int n=0;n<45;n++)
            sum+=msg.Sample(0,n);
         if (fBoardID==1) DOUT0(("Board 1 ch 0 aver = %5.1f", sum/45));
*/

         for (unsigned nn = 0; nn < SUSIBO_PACKAGE_LENGTH; nn++) {
            *((uint8_t*) ptr()) = msg.Data(nn);
            buf.Shift(ptr, 1);
         }

         totallen += SUSIBO_PACKAGE_LENGTH;
     } else {
         isbadmsg = true;
     }

     packages.pop_front();

   }

   if (totallen==0) return dabc::di_RepeatTimeOut;

   if (!fTestTrigger && isbadmsg && (msgs_ids.size()<3)) {
      EOUT(("Found bad messages, drop all other"));
      return dabc::di_RepeatTimeOut;
   }

   if (!fTestTrigger && (msgs_ids.size()>2)) {
       isbadmsg = false;
       unsigned shift = (msgs_ids[1] - msgs_ids[0]) & 0xffffff;
       for (unsigned n=2;n<msgs_ids.size();n++)
          if (((msgs_ids[n] - msgs_ids[n-1]) & 0xffffff) != shift) isbadmsg = true;
       if (isbadmsg) {
          EOUT(("Found bad sequence in the messages, drop all of them"));
          return dabc::di_RepeatTimeOut;
       }
   }

   DOUT3(("SusiboInput:: totallen = %d",totallen));
   buf.SetTotalSize(totallen);

   return dabc::di_Ok;
}