Back to home page

sPhenix code displayed by LXR
 
 

    

File indexing completed on 2025-08-06 08:17:18 

0001 // @file GBTLink.cxx
0002 // @brief Definitions of GBTLink class used for the ITS/MFT raw data decoding
0003 // @sa <O2/Detectors/ITSMFT/common/reconstruction/src/GBTLink.cxx>
0004 //     <e5b583efa>
0005 
0006 #include "GBTLink.h"
0007 
0008 #include <bitset>
0009 
0010 using namespace mvtx;
0011 
0012 // using RDHUtils = mvtx::RDHUtils;
0013 // using RDH = mvtx::RAWDataHeader;
0014 
0015 ///======================================================================
0016 ///                 GBT Link data decoding class
0017 ///======================================================================
0018 
0019 ///_________________________________________________________________
0020 /// create link with given ids
0021 GBTLink::GBTLink(uint16_t _flx, uint16_t _fee)
0022   : flxId(_flx)
0023   , feeId(_fee)
0024 {
0025   //  chipStat.feeID = _fee;
0026   //  statistics.feeID = _fee;
0027   data.expand(RawBufferSize);
0028 }
0029 
0030 /////_________________________________________________________________
0031 ///// create string describing the link
0032 // std::string GBTLink::describe() const
0033 //{
0034 //   std::string ss = fmt::format("link cruID:{:#06x}/lID{} feeID:{:#06x}", cruID, int(idInCRU), feeID);
0035 //   if (lanes) {
0036 //     ss += fmt::format(" lanes {}", std::bitset<28>(lanes).to_string());
0037 //   }
0038 //   return ss;
0039 // }
0040 
0041 ///_________________________________________________________________
0042 /// reset link
0043 void GBTLink::clear(bool resetStat, bool resetTFRaw)
0044 {
0045   if (data.isEmpty())
0046   {
0047     data.clear();
0048   }
0049   else
0050   {
0051     data.moveUnusedToHead();
0052     //    std::cout << "Link: " << feeID << " buffer Size: " << data.getSize() << std::endl;
0053   }
0054 
0055   if (resetTFRaw)
0056   {
0057     rawData.clear();
0058     mL1TrgTime.clear();
0059     for (auto& trg : mTrgData)
0060     {
0061       trg.clear();
0062     }
0063     mTrgData.clear();
0064     dataOffset = 0;
0065     hbf_count = 0;
0066   }
0067 
0068   if (resetStat)
0069   {
0070     statistics.clear();
0071   }
0072   hbfEntry = 0;
0073   status = None;
0074 }
0075 
0076 ///_________________________________________________________________
0077 /// this function reads in 32 bytes  =  3 GBT words and 2 bytes
0078 int GBTLink::readFlxWord(GBTWord* gbtwords, uint16_t& w16)
0079 {
0080   for (uint8_t k = 0; k < 3; k++)
0081   {
0082     gbtwords[k] = *(reinterpret_cast<GBTWord*>(data.getPtr() + dataOffset));
0083     dataOffset += 10;
0084   }
0085 
0086   w16 = *(reinterpret_cast<uint16_t*>(data.getPtr() + dataOffset));
0087   dataOffset += 2;
0088   return 0;
0089 }
0090 
0091 //
0092 /////_________________________________________________________________
0093 // void GBTLink::printTrigger(const GBTTrigger* gbtTrg, int offs)
0094 //{
0095 //   std::bitset<12> trb(gbtTrg->triggerType);
0096 //   LOG(info) << "Offs: " << offs << " Trigger : Orbit " << gbtTrg->orbit << " BC: " << gbtTrg->bc << " Trigger: " << trb << " noData:"
0097 //             << gbtTrg->noData << " internal:" << gbtTrg->internal << " continuation:" << gbtTrg->continuation << " on " << describe();
0098 //   gbtTrg->printX();
0099 // }
0100 //
0101 /////_________________________________________________________________
0102 // void GBTLink::printCalibrationWord(const GBTCalibration* gbtCal, int offs)
0103 //{
0104 //   LOGP(info, "Offs: {} Calibration word {:5} | user_data {:#08x} on {}", offs, gbtCal->calibCounter, gbtCal->calibUserField, describe());
0105 //   gbtCal->printX();
0106 // }
0107 //
0108 /////_________________________________________________________________
0109 // void GBTLink::printHeader(const GBTDataHeader* gbtH, int offs)
0110 //{
0111 //   std::bitset<28> LA(gbtH->activeLanes);
0112 //   LOG(info) << "Offs: " << offs << " Header : Active Lanes " << LA << " on " << describe();
0113 //   gbtH->printX();
0114 // }
0115 //
0116 /////_________________________________________________________________
0117 ////void GBTLink::printHeader(const GBTDataHeaderL* gbtH, int offs)
0118 ////{
0119 ////  std::bitset<28> LA(gbtH->activeLanesL);
0120 ////  LOG(info) << "Offs: " << offs << " HeaderL : Active Lanes " << LA << " on " << describe();
0121 ////  gbtH->printX(expectPadding);
0122 ////}
0123 //
0124 /////_________________________________________________________________
0125 // void GBTLink::printTrailer(const GBTDataTrailer* gbtT, int offs)
0126 //{
0127 //   std::bitset<28> LT(gbtT->lanesTimeout), LS(gbtT->lanesStops); // RSTODO
0128 //   LOG(info) << "Offs: " << offs << " Trailer: Done=" << gbtT->packetDone << " Lanes TO: " << LT << " | Lanes ST: " << LS << " on " << describe();
0129 //   gbtT->printX();
0130 // }
0131 //
0132 /////_________________________________________________________________
0133 // void GBTLink::printDiagnostic(const GBTDiagnostic* gbtD, int offs)
0134 //{
0135 //   LOG(info) << "Offs: " << offs << " Diagnostic word on " << describe();
0136 //   gbtD->printX();
0137 // }
0138 //
0139 /////_________________________________________________________________
0140 // void GBTLink::printCableDiagnostic(const GBTCableDiagnostic* gbtD)
0141 //{
0142 //   LOGP(info, "Diagnostic for {} Lane {} | errorID: {} data {:#018x} on {}", "IB", gbtD->getCableID(), gbtD->laneErrorID, gbtD->diagnosticData, describe());
0143 //   gbtD->printX();
0144 // }
0145 //
0146 /////_________________________________________________________________
0147 // void GBTLink::printCableStatus(const GBTCableStatus* gbtS)
0148 //{
0149 //   LOGP(info, "Status data, not processed at the moment, on {}", describe());
0150 //   gbtS->printX();
0151 // }
0152 //
0153 /////====================================================================
0154 
0155 #ifdef _RAW_READER_ERROR_CHECKS_
0156 
0157 ///_________________________________________________________________
0158 /// Check RDH correctness
0159 // uint8_t GBTLink::checkErrorsRDH(const RDH& rdh)
0160 //{
0161 //   uint8_t err = uint8_t(NoError);
0162 //   if (!RDHUtils::checkRDH(rdh, true)) {
0163 //     statistics.errorCounts[GBTLinkDecodingStat::ErrNoRDHAtStart]++;
0164 //     gbtErrStatUpadated = true;
0165 //     if (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrNoRDHAtStart])) {
0166 //       err |= uint8_t(ErrorPrinted);
0167 //       LOG(info) << describe() << ' ' << irHBF << ' ' << statistics.ErrNames[GBTLinkDecodingStat::ErrNoRDHAtStart];
0168 //     }
0169 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrNoRDHAtStart);
0170 //     err |= uint8_t(Abort);
0171 //     return err; // fatal error
0172 //   }
0173 //   /*
0174 //   if ((RDHUtils::getPacketCounter(rdh) > packetCounter + 1) && packetCounter >= 0) {
0175 //     if (irHBF.isDummy()) {
0176 //       irHBF = RDHUtils::getHeartBeatIR(rdh);
0177 //     }
0178 //     statistics.errorCounts[GBTLinkDecodingStat::ErrPacketCounterJump]++;
0179 //     gbtErrStatUpadated = true;
0180 //     if (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrPacketCounterJump])) {
0181 //       LOG(info) << describe() << ' ' << irHBF << ' ' << statistics.ErrNames[GBTLinkDecodingStat::ErrPacketCounterJump]
0182 //                 << " : jump from " << int(packetCounter) << " to " << int(RDHUtils::getPacketCounter(rdh));
0183 //       err |= uint8_t(ErrorPrinted);
0184 //     }
0185 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrPacketCounterJump);
0186 //     err |= uint8_t(Warning);
0187 //   }
0188 //   packetCounter = RDHUtils::getPacketCounter(rdh);
0189 //   */
0190 //   return err;
0191 // }
0192 //
0193 ///// Check encountered alignment padding word correctness //YCMTODO
0194 // uint8_t GBTLink::checkErrorsAlignmentPadding()
0195 //{
0196 ////  uint8_t err = uint8_t(NoError);
0197 ////  if (lastPageSize - dataOffset >= CRUPageAlignment) {
0198 ////    statistics.errorCounts[GBTLinkDecodingStat::ErrWrongAlignmentWord]++;
0199 ////    gbtErrStatUpadated = true;
0200 ////    if (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrWrongAlignmentWord])) {
0201 ////      err |= uint8_t(ErrorPrinted);
0202 ////      LOG(info) << describe() << ' ' << statistics.ErrNames[GBTLinkDecodingStat::ErrWrongAlignmentWord] << " at offset " << dataOffset << " for page size " << lastPageSize;
0203 ////    }
0204 ////    errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrWrongAlignmentWord);
0205 ////    err |= uint8_t(Warning);
0206 ////    return err; // fatal error
0207 ////  }
0208 //  return err;
0209 //}
0210 //
0211 /////_________________________________________________________________
0212 ///// Check RDH Stop correctness
0213 // uint8_t GBTLink::checkErrorsRDHStop(const RDH& rdh)
0214 //{
0215 //   uint8_t err = uint8_t(NoError);
0216 //   if (lastRDH && RDHUtils::getLHCBC(*lastRDH) != RDHUtils::getLHCBC(rdh)
0217 //       && !RDHUtils::getStopBit(*lastRDH)) {
0218 //     statistics.errorCounts[GBTLinkDecodingStat::ErrPageNotStopped]++;
0219 //     gbtErrStatUpadated = true;
0220 //     if (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrPageNotStopped])) {
0221 //       LOG(info) << describe() << ' ' << irHBF << ' ' << statistics.ErrNames[GBTLinkDecodingStat::ErrPageNotStopped];
0222 //       RDHUtils::printRDH(*lastRDH);
0223 //       RDHUtils::printRDH(rdh);
0224 //       err |= uint8_t(ErrorPrinted);
0225 //     }
0226 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrPageNotStopped);
0227 //     err |= uint8_t(Warning);
0228 //   }
0229 //   return err;
0230 // }
0231 //
0232 /////_________________________________________________________________
0233 ///// Check if the RDH Stop page is empty
0234 // uint8_t GBTLink::checkErrorsRDHStopPageEmpty(const RDH& rdh)
0235 //{
0236 //   uint8_t err = uint8_t(NoError);
0237 //   if (RDHUtils::getStopBit(rdh) && RDHUtils::getPacketSize(rdh) != sizeof(RDH) + sizeof(FLXWord)) { // there could be only 1 diagnostic GBTWord after stop
0238 //     statistics.errorCounts[GBTLinkDecodingStat::ErrStopPageNotEmpty]++;
0239 //     gbtErrStatUpadated = true;
0240 //     if (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrStopPageNotEmpty])) {
0241 //       LOG(info) << describe() << ' ' << irHBF << ' ' << statistics.ErrNames[GBTLinkDecodingStat::ErrStopPageNotEmpty];
0242 //       RDHUtils::printRDH(rdh);
0243 //       err |= uint8_t(ErrorPrinted);
0244 //     }
0245 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrStopPageNotEmpty);
0246 //     err |= uint8_t(Warning);
0247 //   }
0248 //   return err;
0249 // }
0250 //
0251 /////_________________________________________________________________
0252 ///// Check the GBT Trigger word correctness
0253 // uint8_t GBTLink::checkErrorsTriggerWord(const GBTTrigger* gbtTrg)
0254 //{
0255 //   uint8_t err = uint8_t(NoError);
0256 //   if (!gbtTrg->isTriggerWord()) { // check trigger word
0257 //     statistics.errorCounts[GBTLinkDecodingStat::ErrMissingGBTTrigger]++;
0258 //     gbtErrStatUpadated = true;
0259 //     if (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrMissingGBTTrigger])) {
0260 //       gbtTrg->printX();
0261 //       LOG(info) << describe() << ' ' << irHBF << ' ' << statistics.ErrNames[GBTLinkDecodingStat::ErrMissingGBTTrigger];
0262 //       err |= uint8_t(ErrorPrinted);
0263 //     }
0264 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrMissingGBTTrigger);
0265 //     err |= uint8_t(Abort);
0266 //   }
0267 //   return err;
0268 // }
0269 //
0270 /////_________________________________________________________________
0271 ///// Check the GBT Calibration word correctness
0272 // uint8_t GBTLink::checkErrorsCalibrationWord(const GBTCalibration* gbtCal)
0273 //{
0274 //   // at the moment do nothing
0275 //   return uint8_t(NoError);
0276 // }
0277 //
0278 /////_________________________________________________________________
0279 ///// Check the GBT Header word correctness
0280 // uint8_t GBTLink::checkErrorsHeaderWord(const GBTDataHeader* gbtH)
0281 //{
0282 //   uint8_t err = uint8_t(NoError);
0283 //   if (!gbtH->isDataHeader()) { // check header word
0284 //     statistics.errorCounts[GBTLinkDecodingStat::ErrMissingGBTHeader]++;
0285 //     gbtErrStatUpadated = true;
0286 //     if (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrMissingGBTHeader])) {
0287 //       gbtH->printX();
0288 //       LOG(info) << describe() << ' ' << irHBF << ' ' << statistics.ErrNames[GBTLinkDecodingStat::ErrMissingGBTHeader];
0289 //       err |= uint8_t(ErrorPrinted);
0290 //     }
0291 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrMissingGBTHeader);
0292 //     err |= uint8_t(Abort);
0293 //   }
0294 //   return err;
0295 // }
0296 //
0297 /////_________________________________________________________________
0298 ///// Check active lanes status
0299 // uint8_t GBTLink::checkErrorsActiveLanes(int cbl)
0300 //{
0301 //   uint8_t err = uint8_t(NoError);
0302 //   if (~cbl & lanesActive) { // are there wrong lanes?
0303 //     statistics.errorCounts[GBTLinkDecodingStat::ErrInvalidActiveLanes]++;
0304 //     gbtErrStatUpadated = true;
0305 //     if (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrInvalidActiveLanes])) {
0306 //       std::bitset<32> expectL(cbl), gotL(lanesActive);
0307 //       LOG(info) << describe() << ' ' << irHBF << ' ' << statistics.ErrNames[GBTLinkDecodingStat::ErrInvalidActiveLanes] << ' '
0308 //                 << gotL << " vs " << expectL << " skip page";
0309 //       err |= uint8_t(ErrorPrinted);
0310 //     }
0311 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrInvalidActiveLanes);
0312 //     err |= uint8_t(Warning);
0313 //   }
0314 //   return err;
0315 // }
0316 //
0317 /////_________________________________________________________________
0318 ///// Check GBT Data word
0319 // uint8_t GBTLink::checkErrorsGBTData(int cablePos)
0320 //{
0321 //   uint8_t err = uint8_t(NoError);
0322 //   lanesWithData |= 0x1 << cablePos;    // flag that the data was seen on this lane
0323 //   if (lanesStop & (0x1 << cablePos)) { // make sure stopped lanes do not transmit the data
0324 //     statistics.errorCounts[GBTLinkDecodingStat::ErrDataForStoppedLane]++;
0325 //     gbtErrStatUpadated = true;
0326 //     if (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrDataForStoppedLane])) {
0327 //       LOG(info) << describe() << ' ' << irHBF << ' ' << statistics.ErrNames[GBTLinkDecodingStat::ErrDataForStoppedLane] << cablePos;
0328 //       err |= uint8_t(ErrorPrinted);
0329 //     }
0330 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrDataForStoppedLane);
0331 //     err |= uint8_t(Warning);
0332 //   }
0333 //
0334 //   return err;
0335 // }
0336 //
0337 /////_________________________________________________________________
0338 ///// Check GBT Data word ID: it might be diagnostic or status data
0339 // uint8_t GBTLink::checkErrorsGBTDataID(const GBTData* gbtD)
0340 //{
0341 //   if (gbtD->isData()) {
0342 //     return uint8_t(NoError);
0343 //   }
0344 //   uint8_t err = uint8_t(NoError);
0345 //   statistics.errorCounts[GBTLinkDecodingStat::ErrGBTWordNotRecognized]++;
0346 //   gbtErrStatUpadated = true;
0347 //   if (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrGBTWordNotRecognized])) {
0348 //     if (gbtD->isCableDiagnostic()) {
0349 //       printCableDiagnostic((GBTCableDiagnostic*)gbtD);
0350 //     } else if (gbtD->isStatus()) {
0351 //       printCableStatus((GBTCableStatus*)gbtD);
0352 //     }
0353 //     gbtD->printX();
0354 //     LOG(info) << describe() << ' ' << irHBF << ' ' << statistics.ErrNames[GBTLinkDecodingStat::ErrGBTWordNotRecognized];
0355 //     err |= uint8_t(ErrorPrinted);
0356 //   }
0357 //   err |= uint8_t(Skip);
0358 //   return err;
0359 // }
0360 //
0361 /////_________________________________________________________________
0362 ///// Check the GBT Trailer word correctness
0363 // uint8_t GBTLink::checkErrorsTrailerWord(const GBTDataTrailer* gbtT)
0364 //{
0365 //   uint8_t err = uint8_t(NoError);
0366 //   if (!gbtT->isDataTrailer()) {
0367 //     gbtT->printX();
0368 //     statistics.errorCounts[GBTLinkDecodingStat::ErrMissingGBTTrailer]++;
0369 //     gbtErrStatUpadated = true;
0370 //     if (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrMissingGBTTrailer])) {
0371 //       LOG(info) << describe() << ' ' << irHBF << ' ' << statistics.ErrNames[GBTLinkDecodingStat::ErrMissingGBTTrailer];
0372 //       err |= uint8_t(ErrorPrinted);
0373 //     }
0374 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrMissingGBTTrailer);
0375 //     err |= uint8_t(Abort);
0376 //     return err;
0377 //   }
0378 //   lanesStatus |= gbtT->lanesStatus; // register timeouts
0379 //   return err;
0380 // }
0381 //
0382 /////_________________________________________________________________
0383 ///// Check the Done status in GBT Trailer word
0384 // uint8_t GBTLink::checkErrorsPacketDoneMissing(const GBTDataTrailer* gbtT, bool notEnd)
0385 //{
0386 //   uint8_t err = uint8_t(NoError);
0387 //   if (!gbtT || (!gbtT->packetDone && notEnd)) { // Done may be missing only in case of carry-over to new CRU page
0388 //     statistics.errorCounts[GBTLinkDecodingStat::ErrPacketDoneMissing]++;
0389 //     gbtErrStatUpadated = true;
0390 //     if (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrPacketDoneMissing])) {
0391 //       LOG(info) << describe() << ' ' << irHBF << ' ' << statistics.ErrNames[GBTLinkDecodingStat::ErrPacketDoneMissing];
0392 //       err |= uint8_t(ErrorPrinted);
0393 //     }
0394 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrPacketDoneMissing);
0395 //     err |= uint8_t(Warning);
0396 //   }
0397 //   return err;
0398 // }
0399 //
0400 /////_________________________________________________________________
0401 ///// Check that all active lanes received their stop
0402 // uint8_t GBTLink::checkErrorsLanesStops()
0403 //{
0404 //   // make sure all lane stops for finished page are received
0405 //   uint8_t err = uint8_t(NoError);
0406 //   if ((lanesActive & ~lanesStop)) {
0407 //     if (RDHUtils::getTrgType(*lastRDH) != mvtx::TrgBitMap::SOT) { // only SOT trigger allows unstopped lanes?
0408 //       statistics.errorCounts[GBTLinkDecodingStat::ErrUnstoppedLanes]++;
0409 //       gbtErrStatUpadated = true;
0410 //       if (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrUnstoppedLanes])) {
0411 //         std::bitset<32> active(lanesActive), stopped(lanesStop);
0412 //         LOG(info) << describe() << ' ' << irHBF << ' ' << statistics.ErrNames[GBTLinkDecodingStat::ErrUnstoppedLanes]
0413 //                   << " | active: " << active << " stopped: " << stopped;
0414 //         err |= uint8_t(ErrorPrinted);
0415 //       }
0416 //       errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrUnstoppedLanes);
0417 //     }
0418 //     err |= uint8_t(Warning);
0419 //   }
0420 //   // make sure all active lanes (except those in time-out) have sent some data
0421 //   if ((~lanesWithData & lanesActive) != lanesTimeOut) {
0422 //     statistics.errorCounts[GBTLinkDecodingStat::ErrNoDataForActiveLane]++;
0423 //     gbtErrStatUpadated = true;
0424 //     if (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrNoDataForActiveLane])) {
0425 //       std::bitset<32> withData(lanesWithData), active(lanesActive), timeOut(lanesTimeOut);
0426 //       LOG(info) << describe() << ' ' << irHBF << ' ' << statistics.ErrNames[GBTLinkDecodingStat::ErrNoDataForActiveLane]
0427 //                 << " | with data: " << withData << " active: " << active << " timeOut: " << timeOut;
0428 //       err |= uint8_t(ErrorPrinted);
0429 //     }
0430 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrNoDataForActiveLane);
0431 //     err |= uint8_t(Warning);
0432 //   }
0433 //   return err;
0434 // }
0435 //
0436 /////_________________________________________________________________
0437 ///// Check diagnostic word
0438 // uint8_t GBTLink::checkErrorsDiagnosticWord(const GBTDiagnostic* gbtD)
0439 //{
0440 //   uint8_t err = uint8_t(NoError);
0441 //   if (RDHUtils::getPacketSize(lastRDH) != sizeof(RDH) + sizeof(FLXWord) || !gbtD->isDiagnosticWord()) { //
0442 //     statistics.errorCounts[GBTLinkDecodingStat::ErrMissingDiagnosticWord]++;
0443 //     gbtErrStatUpadated = true;
0444 //     if (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrMissingDiagnosticWord])) {
0445 //       gbtD->printX();
0446 //       LOG(info) << describe() << ' ' << irHBF << ' ' << statistics.ErrNames[GBTLinkDecodingStat::ErrMissingDiagnosticWord];
0447 //       err |= uint8_t(ErrorPrinted);
0448 //     }
0449 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrMissingDiagnosticWord);
0450 //     err |= uint8_t(Abort);
0451 //   }
0452 //   return err;
0453 // }
0454 //
0455 /////_________________________________________________________________
0456 ///// Check cable ID validity
0457 // uint8_t GBTLink::checkErrorsCableID(const GBTData* gbtD, uint8_t cableSW)
0458 //{
0459 //   uint8_t err = uint8_t(NoError);
0460 //   if (cableSW == 0xff) {
0461 //     statistics.errorCounts[GBTLinkDecodingStat::ErrWrongeCableID]++;
0462 //     gbtErrStatUpadated = true;
0463 //     if (needToPrintError(statistics.errorCounts[GBTLinkDecodingStat::ErrWrongeCableID])) {
0464 //       gbtD->printX();
0465 //       LOG(info) << describe() << ' ' << irHBF << ' ' << statistics.ErrNames[GBTLinkDecodingStat::ErrWrongeCableID] << ' ' << gbtD->getCableID();
0466 //       err |= uint8_t(ErrorPrinted);
0467 //     }
0468 //     errorBits |= 0x1 << int(GBTLinkDecodingStat::ErrWrongeCableID);
0469 //     err |= uint8_t(Skip);
0470 //   }
0471 //   return err;
0472 // }
0473 
0474 #endif
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!