diff --git a/fles/mcbm2018/CMakeLists.txt b/fles/mcbm2018/CMakeLists.txt
index dbd294e9d26b68c8407cd9593b2479fc3c69775c..e44e2b2cc4523712171294ce8a5d36649bb82d3b 100644
--- a/fles/mcbm2018/CMakeLists.txt
+++ b/fles/mcbm2018/CMakeLists.txt
@@ -27,6 +27,7 @@ Set(INCLUDE_DIRECTORIES
   ${CBMROOT_SOURCE_DIR}/fles/mcbm2018/tasks
 
   ${CBMDETECTORBASE_DIR}/trd # required for parameter handling of the trd
+  ${CBMDETECTORBASE_DIR}/psd
 )
 
 Set(SYSTEM_INCLUDE_DIRECTORIES
@@ -131,7 +132,7 @@ EndIf()
 Set(LINKDEF CbmFlibMcbm2018LinkDef.h )
 Set(LIBRARY_NAME CbmFlibMcbm2018)
 Set(DEPENDENCIES
-    CbmFlibFlesTools CbmData CbmBase fles_ipc Eve Base CbmTrdBase
+    CbmFlibFlesTools CbmData CbmBase fles_ipc Eve Base CbmTrdBase CbmPsdBase
 )
 
 GENERATE_LIBRARY()
diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.cxx b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.cxx
index 0b6371b396b27c6d6714e469910f761df91987c2..6e380f37b97f19458cc3d299af8fe73346dde6a2 100644
--- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.cxx
+++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.cxx
@@ -52,6 +52,7 @@ CbmMcbm2018MonitorAlgoPsd::CbmMcbm2018MonitorAlgoPsd() :
    fdTsStartTime( -1.0 ),
    fdTsStopTimeCore( -1.0 ),
    fdMsTime( -1.0 ),
+   fdPrevMsTime( -1.0 ),
    fuMsIndex( 0 ),
    fuCurrentEquipmentId( 0 ),
    fuCurrDpbId( 0 ),
@@ -84,6 +85,7 @@ CbmMcbm2018MonitorAlgoPsd::CbmMcbm2018MonitorAlgoPsd() :
    fvhHitChargeByWfmChan( kuNbChanPsd, nullptr ),
    fvhHitChargeEvoChan( kuNbChanPsd, nullptr ),
    fvhHitWfmChan( kuNbChanPsd, nullptr ),
+   fvhHitFitWfmChan( kuNbChanPsd, nullptr ),
    kvuWfmRanges( kuNbWfmRanges, 0 ),
    kvuWfmInRangeToChangeChan( kuNbChanPsd*kuNbWfmRanges, 0 ),
    fv3hHitWfmFlattenedChan( kuNbChanPsd*kuNbWfmRanges*kuNbWfmExamples, nullptr ),
@@ -104,10 +106,14 @@ CbmMcbm2018MonitorAlgoPsd::CbmMcbm2018MonitorAlgoPsd() :
    fhLostMsgsCntEvo( nullptr ),
    fhReadEvtsCntEvo( nullptr ),
    fhAdcTimeEvo( nullptr ),
+   fhMsLengthEvo( nullptr ),
    fhMsgsCntPerMsEvo( nullptr ),
    fhReadMsgsCntPerMsEvo( nullptr ),
    fhLostMsgsCntPerMsEvo( nullptr ),
    fhReadEvtsCntPerMsEvo( nullptr ),
+   fvhFitHarmonic1Chan( kuNbChanPsd, nullptr ),
+   fvhFitHarmonic2Chan( kuNbChanPsd, nullptr ),
+   fvhFitQaChan( kuNbChanPsd, nullptr ),
    fcSummary( nullptr ),
    fcHitMaps( nullptr ),
    fcChargesFPGA( nullptr ),
@@ -440,6 +446,8 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ProcessMs( const fles::Timeslice& ts, size_t u
                UInt_t uHitChannel = PsdReader.VectHitHdr.at(hit_iter).uHitChannel;
                UInt_t uSignalCharge = PsdReader.VectHitHdr.at(hit_iter).uSignalCharge;
                UInt_t uZeroLevel = PsdReader.VectHitHdr.at(hit_iter).uZeroLevel;
+               std::vector<uint16_t> uWfm = PsdReader.VectHitData.at(hit_iter).uWfm;
+
                if(uHitChannel >= kuNbChanPsd) //uHitChannel numerated from 0
                {
                   LOG(error) << "hit channel number out of range! channel index: " << uHitChannel << " max: " << GetNbChanPsd();
@@ -463,11 +471,12 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ProcessMs( const fles::Timeslice& ts, size_t u
                uint16_t uHitAmlpitude = 0;
                uint16_t uHitChargeWfm = 0;
                fvhHitWfmChan[ uHitChannel ]->Reset();
-               for(UInt_t wfm_iter = 0; wfm_iter < PsdReader.VectHitData.at(hit_iter).uWfm.size(); wfm_iter++)
+               fvhHitFitWfmChan[ uHitChannel ]->Reset();
+               for(UInt_t wfm_iter = 0; wfm_iter < uWfm.size(); wfm_iter++)
                {
-                  if(PsdReader.VectHitData.at(hit_iter).uWfm.at(wfm_iter) > uHitAmlpitude) uHitAmlpitude = PsdReader.VectHitData.at(hit_iter).uWfm.at(wfm_iter);
-                  uHitChargeWfm += PsdReader.VectHitData.at(hit_iter).uWfm.at(wfm_iter) - uZeroLevel;
-                  fvhHitWfmChan[ uHitChannel ]->Fill(wfm_iter, PsdReader.VectHitData.at(hit_iter).uWfm.at(wfm_iter));
+                  if(uWfm.at(wfm_iter) > uHitAmlpitude) uHitAmlpitude = uWfm.at(wfm_iter);
+                  uHitChargeWfm += uWfm.at(wfm_iter) - uZeroLevel;
+                  fvhHitWfmChan[ uHitChannel ]->Fill(wfm_iter, uWfm.at(wfm_iter));
                }
                fvhHitWfmChan[ uHitChannel ]->SetTitle(Form( "Waveform channel %03u charge %0u zero level %0u; Time [adc counts]; Amplitude [adc counts]", uHitChannel, uSignalCharge, uZeroLevel ));
                uHitAmlpitude -= uZeroLevel;
@@ -484,8 +493,8 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ProcessMs( const fles::Timeslice& ts, size_t u
 		     UInt_t uFlatIndexHisto = uWfmExampleIter * kuNbWfmRanges * kuNbChanPsd + i * kuNbChanPsd + uHitChannel;
                      fv3hHitWfmFlattenedChan[ uFlatIndexHisto ]->Reset();
 
-                     for(UInt_t wfm_iter = 0; wfm_iter < PsdReader.VectHitData.at(hit_iter).uWfm.size(); wfm_iter++)
-                        fv3hHitWfmFlattenedChan[ uFlatIndexHisto ]->Fill(wfm_iter, PsdReader.VectHitData.at(hit_iter).uWfm.at(wfm_iter));
+                     for(UInt_t wfm_iter = 0; wfm_iter < uWfm.size(); wfm_iter++)
+                        fv3hHitWfmFlattenedChan[ uFlatIndexHisto ]->Fill(wfm_iter, uWfm.at(wfm_iter));
                      fv3hHitWfmFlattenedChan[ uFlatIndexHisto ]->SetTitle(Form( "Waveform channel %03u charge %0u zero level %0u; Time [adc counts]; Amplitude [adc counts]", uHitChannel, uSignalCharge, uZeroLevel ));
 
                      kvuWfmInRangeToChangeChan.at(uFlatIndexOfChange) ++;
@@ -494,6 +503,36 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ProcessMs( const fles::Timeslice& ts, size_t u
 		  }// if( uSignalCharge > kvuWfmRanges.at(i) && uSignalCharge < kvuWfmRanges.at(i+1) )
                }// for (uint8_t i=0; i<kuNbWfmRanges; ++i)
 
+
+               int gate_beg = 0;
+               int gate_end = 7;
+               PsdSignalFitting::PronyFitter Pfitter(2,2,gate_beg,gate_end);
+
+               Pfitter.SetDebugMode(0);
+               Pfitter.SetWaveform(uWfm, uZeroLevel);
+               int SignalBeg = 2;
+               Int_t best_signal_begin = Pfitter.ChooseBestSignalBeginHarmonics(SignalBeg-1, SignalBeg+1);
+
+               Pfitter.SetSignalBegin(best_signal_begin);
+               Pfitter.CalculateFitHarmonics();
+               Pfitter.CalculateFitAmplitudes();
+
+               Float_t fit_integral = Pfitter.GetIntegral(gate_beg, gate_end);
+               Float_t fit_R2 = Pfitter.GetRSquare(gate_beg, gate_end);
+
+               std::complex<float>* harmonics = Pfitter.GetHarmonics();
+               std::vector<uint16_t> uFitWfm = Pfitter.GetFitWfm();
+               for(UInt_t wfm_iter = 0; wfm_iter < uFitWfm.size(); wfm_iter++)
+               {
+                  fvhHitFitWfmChan[ uHitChannel ]->Fill(wfm_iter, uFitWfm.at(wfm_iter));
+                  fvhHitWfmChan[ uHitChannel ]->SetTitle(Form( "Waveform channel %03u charge %0u zero level %0u R2 %.5f; Time [adc counts]; Amplitude [adc counts]", uHitChannel, uSignalCharge, uZeroLevel, fit_R2 ));
+               }
+
+               fvhFitQaChan[ uHitChannel ]->Fill(fit_integral, fit_R2);
+
+               if(fit_R2 > 0.02) continue;
+               fvhFitHarmonic1Chan[ uHitChannel ]->Fill(std::real(harmonics[1]), std::imag(harmonics[1]));
+               fvhFitHarmonic2Chan[ uHitChannel ]->Fill(std::real(harmonics[2]), std::imag(harmonics[2]));
             } // for(int hit_iter = 0; hit_iter < PsdReader.EvHdrAb.uHitsNumber; hit_iter++)
 
          }
@@ -540,6 +579,12 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ProcessMs( const fles::Timeslice& ts, size_t u
          }
       }
 
+      if( fulCurrentMsIdx != PsdReader.EvHdrAb.ulMicroSlice )
+         LOG(error) << "Wrong MS index!"
+                    << " in microslice " << fulCurrentMsIdx
+                    << " by PsdReader "  << PsdReader.EvHdrAb.ulMicroSlice
+                    << "\n";
+
       fhMsgsCntEvo->AddBinContent( fdMsTime - fdStartTime, uNbMessages );
       fhReadMsgsCntEvo->AddBinContent( fdMsTime - fdStartTime, PsdReader.GetTotalGbtWordsRead() );
       fhLostMsgsCntEvo->AddBinContent( fdMsTime - fdStartTime, uNbMessages - PsdReader.GetTotalGbtWordsRead() );
@@ -551,6 +596,13 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ProcessMs( const fles::Timeslice& ts, size_t u
 
    }//if(uSize != 0)
 
+   if(fdPrevMsTime < 0.) fdPrevMsTime = fdMsTime;
+   else
+   {
+      fhMsLengthEvo->Fill( fdMsTime - fdStartTime, 1e9* (fdMsTime - fdPrevMsTime));
+      fdPrevMsTime = fdMsTime;
+   }
+
    /// Fill histograms
    FillHistograms();
 
@@ -560,7 +612,7 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ProcessMs( const fles::Timeslice& ts, size_t u
 Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms()
 {
    std::string sFolder = "MoniPsd";
-
+   std::string sFitFolder = "PronyFit";
    LOG(info) << "create Histos for PSD monitoring ";
 
    /// Logarithmic bining
@@ -601,6 +653,9 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms()
    fhAdcTimeEvo     = new TH2I( "hAdcTimeEvo", "Evolution of ADC time vs time in run; Time in run [s]; Adc time *12.5[ns]",
                         fuHistoryHistoSize, 0, fuHistoryHistoSize, 500, 0, 9000 );
 
+   fhMsLengthEvo    = new TH2I( "hMsLengthEvo", "Evolution of MS length vs time in run; Time in run [s]; MS length [ns]",
+                        fuHistoryHistoSize, 0, fuHistoryHistoSize, (Int_t)1e2, 0, 1e8);
+
    fhMsgsCntPerMsEvo     = new TH2I( "hMsgsCntPerMsEvo",
          "Evolution of TotalMsgs counts, per MS vs time in run; Time in run [s]; TotalMsgs Count/MS []; MS",
          fuHistoryHistoSize, 0, fuHistoryHistoSize,
@@ -633,6 +688,7 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms()
    AddHistoToVector( fhReadEvtsCntEvo, sFolder );
 
    AddHistoToVector( fhAdcTimeEvo, sFolder );
+   AddHistoToVector( fhMsLengthEvo, sFolder );
 
    AddHistoToVector( fhMsgsCntPerMsEvo, sFolder );
    AddHistoToVector( fhReadMsgsCntPerMsEvo, sFolder );
@@ -682,6 +738,15 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms()
             Form( "hHitWfmChan%03u", uChan ),
             Form( "HitWfmChan%03u", uChan ),
             8, 0, 8);
+      fvhHitWfmChan[ uChan ]->SetMarkerStyle(31);
+      fvhHitWfmChan[ uChan ]->SetMarkerSize(0.5);
+
+      fvhHitFitWfmChan[ uChan ] = new TH1I(
+            Form( "hHitFitWfmChan%03u", uChan ),
+            Form( "HitFitWfmChan%03u", uChan ),
+            8, 0, 8);
+      fvhHitFitWfmChan[ uChan ]->SetLineColor(kRed);
+      fvhHitFitWfmChan[ uChan ]->SetLineWidth(2);
 
       for( UInt_t uWfmRangeIter = 0; uWfmRangeIter < kuNbWfmRanges; uWfmRangeIter ++)
       {
@@ -696,6 +761,23 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms()
          }// for( UInt_t uWfmRangeIter = 0; uWfmRangeIter < kuNbWfmRanges; uWfmRangeIter ++)
       } // for( UInt_t uWfmExampleIter = 0; uWfmExampleIter < kuNbWfmExamples; uWfmExampleIter ++)
 
+      fvhFitHarmonic1Chan[ uChan ] = new TH2I(
+            Form( "hFitHarmonic1Chan%03u", uChan ),
+            Form( "Waveform fit harmonic 1 for channel %03u; Real part []; Imag part []", uChan ),
+            400, -2, 2, 200, -1, 1 );
+      fvhFitHarmonic1Chan[ uChan ]->SetMarkerColor(kRed);
+
+      fvhFitHarmonic2Chan[ uChan ] = new TH2I(
+            Form( "hFitHarmonic2Chan%03u", uChan ),
+            Form( "Waveform fit harmonic 2 for channel %03u; Real part []; Imag part []", uChan ),
+            400, -2, 2, 200, -1, 1 );
+      fvhFitHarmonic2Chan[ uChan ]->SetMarkerColor(kBlue);
+
+      fvhFitQaChan[ uChan ] = new TH2I(
+            Form( "hFitQaChan%03u", uChan ),
+            Form( "Waveform fit QA for channel %03u;  Integral [adc counts]; R2 []", uChan ),
+            fviHistoChargeArgs.at(0), fviHistoChargeArgs.at(1), fviHistoChargeArgs.at(2), 500, 0, 1 );
+
 
       /// Add pointers to the vector with all histo for access by steering class
       AddHistoToVector( fvhHitCntEvoChan[ uChan ], sFolder );
@@ -706,10 +788,13 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms()
       AddHistoToVector( fvhHitChargeByWfmChan[ uChan ], sFolder );
       AddHistoToVector( fvhHitChargeEvoChan[ uChan ], sFolder );
 
+      AddHistoToVector( fvhFitHarmonic1Chan[ uChan ], sFitFolder );
+      AddHistoToVector( fvhFitHarmonic2Chan[ uChan ], sFitFolder );
+      AddHistoToVector( fvhFitQaChan[ uChan ], sFitFolder );
+
    } // for( UInt_t uChan = 0; uChan < kuNbChanPsd; ++uChan )
 
-   /// Cleanup array of log bins
-//   delete dBinsLog;
+
 
    /*******************************************************************/
 
@@ -766,6 +851,13 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms()
    gPad->SetLogz();
    fhHitChargeMap->Draw("colz");
 
+   fcSummary->cd( 4 );
+   gPad->SetGridx();
+   gPad->SetGridy();
+   gPad->SetLogy();
+   gPad->SetLogz();
+   fhMsLengthEvo->Draw("colz");
+
    AddCanvasToVector( fcSummary, "canvases" );
    /*******************************************************************/
 
@@ -871,7 +963,8 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms()
    for( UInt_t uChan = 0; uChan < kuNbChanPsd; uChan ++)
    {
       fcWfmsAllChannels->cd( 1 + uChan );
-      fvhHitWfmChan[ uChan ]->Draw("HIST LP");
+      fvhHitWfmChan[ uChan ]->Draw("HIST P");
+      fvhHitFitWfmChan[ uChan ]->Draw("L SAME");
    } // for( UInt_t uChan = 0; uChan < kuNbChanPsd; uChan ++)
 
    AddCanvasToVector( fcWfmsAllChannels, "waveforms" );
@@ -901,6 +994,26 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms()
 
    /*******************************************************************/
 
+   fcPronyFit = new TCanvas( "cPronyFit", "Prony wfm fitting", w, h);
+   fcPronyFit->Divide( 2 );
+
+   fcPronyFit->cd( 1 );
+   for( UInt_t uChan = 0; uChan < kuNbChanPsd; uChan ++)
+   {
+      fvhFitHarmonic1Chan[ uChan ]->Draw( "same" );
+      fvhFitHarmonic2Chan[ uChan ]->Draw( "same" );
+   }
+
+   fcPronyFit->cd( 2 );
+   for( UInt_t uChan = 0; uChan < kuNbChanPsd; uChan ++)
+   {
+      fvhFitQaChan[ uChan ]->Draw( "same" );
+   }
+
+   AddCanvasToVector( fcPronyFit, "PronyFit" );
+
+   /*******************************************************************/
+
    return kTRUE;
 }
 
@@ -938,6 +1051,11 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ResetHistograms()
       fvhHitChargeByWfmChan[ uChan ]->Reset();
       fvhHitChargeEvoChan[ uChan ]->Reset();
       fvhHitWfmChan[ uChan ]->Reset();
+      fvhHitFitWfmChan[ uChan ]->Reset();
+
+      fvhFitHarmonic1Chan[ uChan ]->Reset();
+      fvhFitHarmonic2Chan[ uChan ]->Reset();
+      fvhFitQaChan[ uChan ]->Reset();
    } // for( UInt_t uChan = 0; uChan < kuNbChanPsd; ++uChan )
 
    for( UInt_t uFlatIndex = 0; uFlatIndex < kuNbChanPsd*kuNbWfmRanges*kuNbWfmExamples; ++uFlatIndex )
@@ -961,6 +1079,7 @@ Bool_t CbmMcbm2018MonitorAlgoPsd::ResetHistograms()
    fhReadEvtsCntEvo->Reset();
 
    fhAdcTimeEvo->Reset();
+   fhMsLengthEvo->Reset();
 
    fhMsgsCntPerMsEvo->Reset();
    fhReadMsgsCntPerMsEvo->Reset();
diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.h b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.h
index b049a12aec03118d6430d089250caeac904d69d6..7bb3657c4b2877d2da6430845cb9d41aad81a918 100644
--- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.h
+++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoPsd.h
@@ -14,6 +14,7 @@
 // Data
 #include "PsdGbtReader.h"
 #include "CbmPsdDigi.h"
+#include "PronyFitter.h"
 
 // CbmRoot
 
@@ -25,10 +26,6 @@
 #include <map>
 
 class CbmMcbm2018PsdPar;
-/*
-class TCanvas;
-class THttpServer;
-*/
 class TH1;
 class TH2;
 class TProfile;
@@ -68,13 +65,13 @@ class CbmMcbm2018MonitorAlgoPsd : public CbmStar2019Algo<CbmPsdDigi>
 
 
    private:
-      /// Control flags
+         /// Control flags
       Bool_t fbMonitorMode;      //! Switch ON the filling of a minimal set of histograms
       Bool_t fbDebugMonitorMode; //! Switch ON the filling of a additional set of histograms
       std::vector< Bool_t >    fvbMaskedComponents;
       Bool_t fbFirstPackageError;
 
-      /// Settings from parameter file
+         /// Settings from parameter file
       CbmMcbm2018PsdPar* fUnpackPar;      //!
          /// Readout chain dimensions and mapping
       UInt_t fuNrOfGdpbs;           //! Total number of GDPBs in the system
@@ -83,19 +80,20 @@ class CbmMcbm2018MonitorAlgoPsd : public CbmStar2019Algo<CbmPsdDigi>
       UInt_t fuNrOfChannelsPerFee;  //! Number of channels in each FEE
       UInt_t fuNrOfChannelsPerGdpb; //! Number of channels per GDPB
 
-      /// Constants
+         /// Constants
       static const Int_t    kiMaxNbFlibLinks  = 32;
       static const UInt_t   kuBytesPerMessage =  8;
-      static const UInt_t   kuNbChanPsd = 32;
+      static const UInt_t   kuNbChanPsd = 10;
 
       static constexpr UInt_t GetNbChanPsd()  { return kuNbChanPsd; }
-      /// Running indices
+         /// Running indices
          /// TS/MS info
       ULong64_t             fulCurrentTsIdx;
       ULong64_t             fulCurrentMsIdx;
       Double_t              fdTsStartTime;         //! Time in ns of current TS from the index of the first MS first component
       Double_t              fdTsStopTimeCore;      //! End Time in ns of current TS Core from the index of the first MS first component
       Double_t              fdMsTime;              //! Start Time in ns of current MS from its index field in header
+      Double_t              fdPrevMsTime;          //! Start Time in ns of previous MS from its index field in header
       UInt_t                fuMsIndex;             //! Index of current MS within the TS
 
          /// Current data properties
@@ -115,13 +113,13 @@ class CbmMcbm2018MonitorAlgoPsd : public CbmStar2019Algo<CbmPsdDigi>
       Double_t              fdStartTimeMsSz;       /** Time of first microslice, used as reference for evolution plots**/
       std::chrono::steady_clock::time_point ftStartTimeUnix; /** Time of run Start from UNIX system, used as reference for long evolution plots against reception time **/
 
-      /// Histograms related variables
+         /// Histograms related variables
       UInt_t   fuHistoryHistoSize; /** Size in seconds of the evolution histograms **/
       std::vector< Int_t > fviHistoChargeArgs; /** Charge histogram arguments in adc counts **/
       std::vector< Int_t > fviHistoAmplArgs;   /** Amplitude histogram arguments in adc counts **/
       std::vector< Int_t > fviHistoZLArgs;     /** ZeroLevel histogram arguments in adc counts **/
 
-      /// Histograms
+         /// Histograms
       UInt_t                fuReadEvtCnt;
       UInt_t                fuMsgsCntInMs;
       UInt_t                fuReadMsgsCntInMs;
@@ -140,6 +138,7 @@ class CbmMcbm2018MonitorAlgoPsd : public CbmStar2019Algo<CbmPsdDigi>
       std::vector< TH1      * > fvhHitChargeByWfmChan;
       std::vector< TH2      * > fvhHitChargeEvoChan;
       std::vector< TH1      * > fvhHitWfmChan;
+      std::vector< TH1      * > fvhHitFitWfmChan;
 
       static const UInt_t kuNbWfmRanges = 8;
       static const UInt_t kuNbWfmExamples = 8;
@@ -172,13 +171,19 @@ class CbmMcbm2018MonitorAlgoPsd : public CbmStar2019Algo<CbmPsdDigi>
       TH1      * fhReadEvtsCntEvo;
 
       TH2      * fhAdcTimeEvo;
+      TH2      * fhMsLengthEvo;
 
       TH2      * fhMsgsCntPerMsEvo;
       TH2      * fhReadMsgsCntPerMsEvo;
       TH2      * fhLostMsgsCntPerMsEvo;
       TH2      * fhReadEvtsCntPerMsEvo;
 
-      /// Canvases
+         /// Waveform fitting
+      std::vector< TH2      * > fvhFitHarmonic1Chan;
+      std::vector< TH2      * > fvhFitHarmonic2Chan;
+      std::vector< TH2      * > fvhFitQaChan;
+
+         /// Canvases
       TCanvas * fcSummary;
       TCanvas * fcHitMaps;
       TCanvas * fcChargesFPGA;
@@ -189,6 +194,7 @@ class CbmMcbm2018MonitorAlgoPsd : public CbmStar2019Algo<CbmPsdDigi>
       TCanvas * fcSpillCountsHori;
       TCanvas * fcWfmsAllChannels;
       std::vector< TCanvas  * > fvcWfmsChan;
+      TCanvas * fcPronyFit;
 
       CbmMcbm2018MonitorAlgoPsd(const CbmMcbm2018MonitorAlgoPsd&);
       CbmMcbm2018MonitorAlgoPsd operator=(const CbmMcbm2018MonitorAlgoPsd&);
diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoT0.cxx b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoT0.cxx
index bde6d476e756b1aecb37625309384fbd630ed0b1..5a44a44c01081cfd60dd82fbc388c27fccab57c2 100644
--- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoT0.cxx
+++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoT0.cxx
@@ -368,9 +368,9 @@ Bool_t CbmMcbm2018MonitorAlgoT0::ProcessMs( const fles::Timeslice& ts, size_t uM
                             static_cast<unsigned int>(msDescriptor.hdr_id),
                             static_cast<unsigned int>(msDescriptor.hdr_ver), msDescriptor.eq_id, msDescriptor.flags,
                             static_cast<unsigned int>(msDescriptor.sys_id),
-                            static_cast<unsigned int>(msDescriptor.sys_ver), 
+                            static_cast<unsigned int>(msDescriptor.sys_ver),
                             static_cast<unsigned long>(msDescriptor.idx), msDescriptor.crc,
-                            msDescriptor.size, 
+                            msDescriptor.size,
                             static_cast<unsigned long>(msDescriptor.offset) );
    } // if( fulCurrentTsIdx < 10 && 0 == uMsIdx )
 /*
@@ -424,6 +424,7 @@ Bool_t CbmMcbm2018MonitorAlgoT0::ProcessMs( const fles::Timeslice& ts, size_t uM
             fuCurrentSpillIdx++;
             fuCurrentSpillPlot = ( fuCurrentSpillPlot + 1 ) % kuNbSpillPlots;
             fdStartTimeSpill = fdMsTime;
+            fvhDpbMapSpill[ fuCurrentSpillPlot ]->Reset();
             fvhChannelMapSpill[ fuCurrentSpillPlot ]->Reset();
          } // if( fbSpillOn && fuCountsLastSecond < fuOffSpillCountLimit )
          else if( fuOffSpillCountLimit < fuCountsLastSecond  )
@@ -513,8 +514,10 @@ Bool_t CbmMcbm2018MonitorAlgoT0::ProcessMs( const fles::Timeslice& ts, size_t uM
                   UInt_t uTot     = mess.getGdpbHit32Tot();
                   if( uTot < fuMinTotPulser || fuMaxTotPulser < uTot )
                   {
+                     fhDpbMap->Fill( fuCurrDpbIdx );
                      fhChannelMap->Fill( uChannelT0 );
 
+                     fvhDpbMapSpill[ fuCurrentSpillPlot ]->Fill( fuCurrDpbIdx );
                      fvhChannelMapSpill[ fuCurrentSpillPlot ]->Fill( fuDiamChanMap[ uChannelT0 ] );
                      fhHitsPerSpill->Fill( fuCurrentSpillIdx );
                   } // if( uTot < fuMinTotPulser || fuMaxTotPulser < uTot )
@@ -879,14 +882,16 @@ Bool_t CbmMcbm2018MonitorAlgoT0::CreateHistograms()
    uint32_t iNbBinsLog = 0;
       /// Parameters are NbDecadesLog, NbStepsDecade, NbSubStepsInStep
    std::vector<double> dBinsLogVector = GenerateLogBinArray( 4, 9, 1, iNbBinsLog );
-   double* dBinsLog = dBinsLogVector.data();                     
+   double* dBinsLog = dBinsLogVector.data();
 //   double * dBinsLog = GenerateLogBinArray( 4, 9, 1, iNbBinsLog );
 
    /*******************************************************************/
+   fhDpbMap = new TH1I( "hDpbMap", "Map of hits on T0 detector; DPB; Hits Count []",
+                           fuNrOfGdpbs, -0.5, fuNrOfGdpbs - 0.5 );
    fhChannelMap = new TH1I( "hChannelMap", "Map of hits on T0 detector; Strip; Hits Count []",
-                           kuNbChanDiamond, 0., kuNbChanDiamond);
+                           kuNbChanDiamond, -0.5, kuNbChanDiamond - 0.5 );
    fhHitMapEvo = new TH2I( "hHitMapEvo", "Map of hits on T0 detector vs time in run; Chan; Time in run [s]; Hits Count []",
-                           kuNbChanDiamond, 0., kuNbChanDiamond,
+                           kuNbChanDiamond, -0.5, kuNbChanDiamond - 0.5,
                            fuHistoryHistoSize, 0, fuHistoryHistoSize );
    fhHitTotEvo = new TH2I( "hHitTotEvo", "Evolution of TOT in T0 detector vs time in run; Time in run [s]; TOT [ bin ]; Hits Count []",
                            fuHistoryHistoSize, 0, fuHistoryHistoSize,
@@ -896,9 +901,12 @@ Bool_t CbmMcbm2018MonitorAlgoT0::CreateHistograms()
                            fuHistoryHistoSize, 0, fuHistoryHistoSize );
    for( UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill ++)
    {
+      fvhDpbMapSpill.push_back( new TH1I( Form("hDpbMapSpill%02u", uSpill),
+                                     Form("Map of hits on T0 detector in current spill %02u; DPB; Hits Count []", uSpill),
+                              fuNrOfGdpbs, -0.5, fuNrOfGdpbs - 0.5) );
       fvhChannelMapSpill.push_back( new TH1I( Form("hChannelMapSpill%02u", uSpill),
                                      Form("Map of hits on T0 detector in current spill %02u; Strip; Hits Count []", uSpill),
-                              kuNbChanDiamond, 0., kuNbChanDiamond) );
+                              kuNbChanDiamond, -0.5, kuNbChanDiamond - 0.5) );
    } // for( UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill ++)
    fhHitsPerSpill = new TH1I( "hHitsPerSpill", "Hit count per spill; Spill; Hits Count []",
                            2000, 0., 2000);
@@ -954,12 +962,16 @@ Bool_t CbmMcbm2018MonitorAlgoT0::CreateHistograms()
                            fuHistoryHistoSize, 0, fuHistoryHistoSize );
 
    /// Add pointers to the vector with all histo for access by steering class
+   AddHistoToVector( fhDpbMap, sFolder );
    AddHistoToVector( fhChannelMap, sFolder );
    AddHistoToVector( fhHitMapEvo, sFolder );
    AddHistoToVector( fhHitTotEvo, sFolder );
    AddHistoToVector( fhChanHitMapEvo, sFolder );
    for( UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill ++)
+   {
+      AddHistoToVector( fvhDpbMapSpill[ uSpill ], sFolder );
       AddHistoToVector( fvhChannelMapSpill[ uSpill ], sFolder );
+   } // for( UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill ++)
    AddHistoToVector( fhHitsPerSpill, sFolder );
 
    AddHistoToVector( fhMsgCntEvo, sFolder );
@@ -1204,6 +1216,30 @@ Bool_t CbmMcbm2018MonitorAlgoT0::CreateHistograms()
    AddCanvasToVector( fcSpillCountsHori, "canvases" );
    /*******************************************************************/
 
+   /*******************************************************************/
+   /// General summary: Hit maps, Hit rate vs time in run, error fraction vs time un run
+   fcSpillDpbCountsHori = new TCanvas( "cSpillDpbCountsHori", "Counts in DPB per spill, last 5 spills including current one", w, h);
+   fcSpillDpbCountsHori->Divide( kuNbSpillPlots );
+
+   for( UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill ++)
+   {
+      fcSpillDpbCountsHori->cd( 1 + uSpill );
+      gPad->SetGridx();
+      gPad->SetGridy();
+      gPad->SetLogy();
+      fvhDpbMapSpill[ uSpill ]->Draw();
+      gPad->Update();
+      TPaveStats* st = (TPaveStats *)fvhDpbMapSpill[ uSpill ]->FindObject( "stats" );
+      st->SetOptStat( 110 );
+      st->SetX1NDC( 0.25 );
+      st->SetX2NDC( 0.95 );
+      st->SetY1NDC( 0.90 );
+      st->SetY2NDC( 0.95 );
+   } // for( UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill ++)
+
+   AddCanvasToVector( fcSpillDpbCountsHori, "canvases" );
+   /*******************************************************************/
+
    return kTRUE;
 }
 Bool_t CbmMcbm2018MonitorAlgoT0::FillHistograms()
@@ -1253,7 +1289,7 @@ Bool_t CbmMcbm2018MonitorAlgoT0::FillHistograms()
 
    return kTRUE;
 }
-Bool_t CbmMcbm2018MonitorAlgoT0::ResetHistograms(  Bool_t bResetTime )
+Bool_t CbmMcbm2018MonitorAlgoT0::ResetHistograms( Bool_t bResetTime )
 {
    for( UInt_t uChan = 0; uChan < kuNbChanDiamond; ++uChan )
    {
@@ -1278,10 +1314,14 @@ Bool_t CbmMcbm2018MonitorAlgoT0::ResetHistograms(  Bool_t bResetTime )
 
    fuCurrentSpillIdx = 0;
    fuCurrentSpillPlot = 0;
+   fhDpbMap->Reset();
    fhChannelMap->Reset();
    fhHitMapEvo->Reset();
    for( UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill ++)
+   {
+      fvhDpbMapSpill[ uSpill ]->Reset();
       fvhChannelMapSpill[ uSpill ]->Reset();
+   } // for( UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill ++)
    fhHitsPerSpill->Reset();
 
    fhMsgCntEvo->Reset();
diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoT0.h b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoT0.h
index be5240a7da8a15858d76b18080095b11d69683eb..0a4be5baf4f829a1811d7ce158f4b7bf26d1b4ad 100644
--- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoT0.h
+++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoT0.h
@@ -165,10 +165,12 @@ class CbmMcbm2018MonitorAlgoT0 : public CbmStar2019Algo<CbmTofDigi>
       static const UInt_t kuNbSpillPlots = 5;
 //      UInt_t  kuDiamChanMap[ kuNbChanDiamond ] = { 2, 3, 4, 5, 0, 1, 6, 7 }; //! Map from electronics channel to Diamond strip
       UInt_t  fuDiamChanMap[ kuNbChanDiamond ] = { 0, 1, 2, 3, 4, 5, 6, 7 }; //! Map from electronics channel to Diamond strip
+      TH1      * fhDpbMap = nullptr;
       TH1      * fhChannelMap;
       TH2      * fhHitMapEvo;
       TH2      * fhHitTotEvo;
       TH2      * fhChanHitMapEvo;
+      std::vector< TH1      * > fvhDpbMapSpill = {};
       std::vector< TH1      * > fvhChannelMapSpill;
       TH1      * fhHitsPerSpill;
          /// Global Rate
@@ -196,6 +198,7 @@ class CbmMcbm2018MonitorAlgoT0 : public CbmStar2019Algo<CbmTofDigi>
       TCanvas * fcGenCntsPerMs;
       TCanvas * fcSpillCounts;
       TCanvas * fcSpillCountsHori;
+      TCanvas * fcSpillDpbCountsHori = nullptr;
 
 /*
       void ProcessEpochCycle( uint64_t ulCycleData );
diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoTof.cxx b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoTof.cxx
index 77a45d89eb18526636521c4e14c420f0f0309d93..b6b3f5da850e821d002d7caa84dd9b7d30ae8db9 100644
--- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoTof.cxx
+++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoTof.cxx
@@ -19,6 +19,7 @@
 #include "FairRuntimeDb.h"
 #include "FairRunOnline.h"
 
+#include "TProfile2D.h"
 #include "TROOT.h"
 #include "TList.h"
 #include "TString.h"
@@ -101,6 +102,7 @@ CbmMcbm2018MonitorAlgoTof::CbmMcbm2018MonitorAlgoTof() :
    fhGdpbEpochMissEvo( nullptr ),
    fhGdpbEndMsBufferNotEmpty( nullptr ),
    fhGdpbEndMsDataLost( nullptr ),
+   fhGdpbHitRate( nullptr ),
    fvhGdpbGet4MessType(),
    fvhGdpbGet4ChanScm(),
    fvhGdpbGet4ChanErrors(),
@@ -121,6 +123,7 @@ CbmMcbm2018MonitorAlgoTof::CbmMcbm2018MonitorAlgoTof() :
    fvhRemapTot_gDPB(),
    fvhRemapChCount_gDPB(),
    fvhRemapChRate_gDPB(),
+   fvhRemapChErrFract_gDPB(),
    fuNbMissmatchPattern(),
    fhNbMissPatternPerMs( nullptr ),
    fhPatternMissmatch( nullptr ),
@@ -448,12 +451,13 @@ Bool_t CbmMcbm2018MonitorAlgoTof::ProcessMs( const fles::Timeslice& ts, size_t u
 
    /// Save start time of first valid MS )
    if( fdStartTime < 0 )
-      fdStartTime = fdMsTime;
+      fdStartTime = ( fbUseAbsoluteTime ? 0.0 : fdMsTime );
    /// Reset the histograms if reached the end of the evolution histos range
    else if( fuHistoryHistoSize < fdMsTime - fdStartTime )
    {
       ResetEvolutionHistograms();
-      fdStartTime = fdMsTime;
+      fdStartTime = ( fbUseAbsoluteTime ? fuHistoryHistoSize * static_cast< uint32_t >( fdMsTime / fuHistoryHistoSize ) :
+                                          fdMsTime);
    } // else if( fuHistoryHistoSize < fdMsTime - fdStartTime )
 /*
       /// In Run rate evolution
@@ -522,6 +526,7 @@ Bool_t CbmMcbm2018MonitorAlgoTof::ProcessMs( const fles::Timeslice& ts, size_t u
                else
                {
                   /// Histogramming
+                  fhGdpbHitRate->Fill( fdMsTime - fdStartTime, fuCurrDpbIdx );
                   fhGet4MessType->Fill( fuGet4Nr, 0 );
                   fvhGdpbGet4MessType[ fuCurrDpbIdx ]->Fill( fuGet4Id, 0 );
 
@@ -822,6 +827,8 @@ void CbmMcbm2018MonitorAlgoTof::ProcessHit( gdpbv100::FullMessage mess )
    if (0 <= fdStartTime)
    {
       fvhRemapChRate_gDPB[ fuCurrDpbIdx ]->Fill( 1e-9 * dHitTime - fdStartTime, uRemappedChannelNr );
+      if( kTRUE == fbDebugMonitorMode )
+            fvhRemapChErrFract_gDPB[ fuCurrDpbIdx ]->Fill( 1e-9 * dHitTime - fdStartTime, uRemappedChannelNr, 0 );
 //      fvhFeeRate_gDPB[(fuCurrDpbIdx * fuNrOfFeePerGdpb) + uFeeNr]->Fill( 1e-9 * (dHitTime - fdStartTime));
 //      fvhFeeErrorRatio_gDPB[(fuCurrDpbIdx * fuNrOfFeePerGdpb) + uFeeNr]->Fill( 1e-9 * (dHitTime - fdStartTime), 0, 1);
    } // if (0 <= fdStartTime)
@@ -923,6 +930,14 @@ void CbmMcbm2018MonitorAlgoTof::ProcessError( gdpbv100::FullMessage mess )
    } // if (0 <= fdStartTime)
 */
    Int_t dGdpbChId =  fuGet4Id * fuNrOfChannelsPerGet4 + mess.getGdpbSysErrChanId();
+   UInt_t uChannelNrInFee    = (fuGet4Id % fuNrOfGet4PerFee) * fuNrOfChannelsPerGet4 + mess.getGdpbSysErrChanId();
+   UInt_t uFeeNr             = (fuGet4Id / fuNrOfGet4PerFee);
+//   UInt_t uFeeNrInSys        = fuCurrDpbIdx * fuNrOfFeePerGdpb + uFeeNr;
+   UInt_t uRemappedChannelNr = uFeeNr * fuNrOfChannelsPerFee + fUnpackPar->Get4ChanToPadiChan( uChannelNrInFee );
+      /// Diamond FEE have straight connection from Get4 to eLink and from PADI to GET4
+   if( 0x90 == fuCurrentMsSysId )
+      uRemappedChannelNr = uFeeNr * fuNrOfChannelsPerFee + uChannelNrInFee;
+
    Int_t dFullChId =  fuGet4Nr * fuNrOfChannelsPerGet4 + mess.getGdpbSysErrChanId();
 
    switch( uErrorType )
@@ -1009,42 +1024,56 @@ void CbmMcbm2018MonitorAlgoTof::ProcessError( gdpbv100::FullMessage mess )
       {
          fhGet4ChanErrors->Fill(dFullChId, 13);
          fvhGdpbGet4ChanErrors[ fuCurrDpbIdx ]->Fill( dGdpbChId, 13 );
+         if( kTRUE == fbDebugMonitorMode )
+            fvhRemapChErrFract_gDPB[ fuCurrDpbIdx ]->Fill( fdMsTime - fdStartTime, uRemappedChannelNr, 1 );
          break;
       } // case gdpbv100::GET4_V2X_ERR_TOT_OVERWRT:
       case gdpbv100::GET4_V2X_ERR_TOT_RANGE:
       {
          fhGet4ChanErrors->Fill(dFullChId, 14);
          fvhGdpbGet4ChanErrors[ fuCurrDpbIdx ]->Fill( dGdpbChId, 14 );
+         if( kTRUE == fbDebugMonitorMode )
+            fvhRemapChErrFract_gDPB[ fuCurrDpbIdx ]->Fill( fdMsTime - fdStartTime, uRemappedChannelNr, 1 );
          break;
       } // case gdpbv100::GET4_V2X_ERR_TOT_RANGE:
       case gdpbv100::GET4_V2X_ERR_EVT_DISCARD:
       {
          fhGet4ChanErrors->Fill(dFullChId, 15);
          fvhGdpbGet4ChanErrors[ fuCurrDpbIdx ]->Fill( dGdpbChId, 15 );
+         if( kTRUE == fbDebugMonitorMode )
+            fvhRemapChErrFract_gDPB[ fuCurrDpbIdx ]->Fill( fdMsTime - fdStartTime, uRemappedChannelNr, 1 );
          break;
       } // case gdpbv100::GET4_V2X_ERR_EVT_DISCARD:
       case gdpbv100::GET4_V2X_ERR_ADD_RIS_EDG:
       {
          fhGet4ChanErrors->Fill(dFullChId, 16);
          fvhGdpbGet4ChanErrors[ fuCurrDpbIdx ]->Fill( dGdpbChId, 16 );
+         if( kTRUE == fbDebugMonitorMode )
+            fvhRemapChErrFract_gDPB[ fuCurrDpbIdx ]->Fill( fdMsTime - fdStartTime, uRemappedChannelNr, 1 );
          break;
       } // case gdpbv100::GET4_V2X_ERR_ADD_RIS_EDG:
       case gdpbv100::GET4_V2X_ERR_UNPAIR_FALL:
       {
          fhGet4ChanErrors->Fill(dFullChId, 17);
          fvhGdpbGet4ChanErrors[ fuCurrDpbIdx ]->Fill( dGdpbChId, 17 );
+         if( kTRUE == fbDebugMonitorMode )
+            fvhRemapChErrFract_gDPB[ fuCurrDpbIdx ]->Fill( fdMsTime - fdStartTime, uRemappedChannelNr, 1 );
          break;
       } // case gdpbv100::GET4_V2X_ERR_UNPAIR_FALL:
       case gdpbv100::GET4_V2X_ERR_SEQUENCE_ER:
       {
          fhGet4ChanErrors->Fill(dFullChId, 18);
          fvhGdpbGet4ChanErrors[ fuCurrDpbIdx ]->Fill( dGdpbChId, 18 );
+         if( kTRUE == fbDebugMonitorMode )
+            fvhRemapChErrFract_gDPB[ fuCurrDpbIdx ]->Fill( fdMsTime - fdStartTime, uRemappedChannelNr, 1 );
          break;
       } // case gdpbv100::GET4_V2X_ERR_SEQUENCE_ER:
       case gdpbv100::GET4_V2X_ERR_EPOCH_OVERF:
       {
          fhGet4ChanErrors->Fill(dFullChId, 19);
          fvhGdpbGet4ChanErrors[ fuCurrDpbIdx ]->Fill( dGdpbChId, 19 );
+         if( kTRUE == fbDebugMonitorMode )
+            fvhRemapChErrFract_gDPB[ fuCurrDpbIdx ]->Fill( fdMsTime - fdStartTime, uRemappedChannelNr, 1 );
          break;
       } // case gdpbv100::GET4_V2X_ERR_EPOCH_OVERF:
       case gdpbv100::GET4_V2X_ERR_UNKNOWN:
@@ -1506,6 +1535,10 @@ Bool_t CbmMcbm2018MonitorAlgoTof::CreateHistograms()
                                   fuNrOfGdpbs, dGdpbMin, dGdpbMax,
                                   iNbBinsLog, dBinsLog );
 
+   fhGdpbHitRate = new TH2D( "fhGdpbHitRate", "Hit rate per second and gDPB; Time[s];  gDPB #; HITS Nb",
+                                  fuHistoryHistoSize, 0, fuHistoryHistoSize,
+                                  fuNrOfGdpbs, dGdpbMin, dGdpbMax );
+
    if( kTRUE == fbDebugMonitorMode )
    {
       fhNbMissPatternPerMs = new TH2I( "hNbMissPatternPerMs",
@@ -1544,6 +1577,7 @@ Bool_t CbmMcbm2018MonitorAlgoTof::CreateHistograms()
    AddHistoToVector( fhGdpbEpochMissEvo, sFolder );
    AddHistoToVector( fhGdpbEndMsBufferNotEmpty, sFolder );
    AddHistoToVector( fhGdpbEndMsDataLost, sFolder );
+   AddHistoToVector( fhGdpbHitRate, sFolder );
          /// Pattern Messages
             /// Pattern messages per gDPB
    if( kTRUE == fbDebugMonitorMode )
@@ -1647,6 +1681,13 @@ Bool_t CbmMcbm2018MonitorAlgoTof::CreateHistograms()
                fuHistoryHistoSize, 0, fuHistoryHistoSize,
                fuNrOfFeePerGdpb * fuNrOfChannelsPerFee, 0, fuNrOfFeePerGdpb * fuNrOfChannelsPerFee ) );
 
+      if( kTRUE == fbDebugMonitorMode )
+         fvhRemapChErrFract_gDPB.push_back( new TProfile2D(
+               Form("RemapChErrFract_gDPB_%02u", uGdpbIndex),
+               Form("PADI channel error fraction gDPB %02u; Time in run [s]; PADI channel; Fraction []", uGdpbIndex),
+               18000, 0, 180,
+               fuNrOfFeePerGdpb * fuNrOfChannelsPerFee, 0, fuNrOfFeePerGdpb * fuNrOfChannelsPerFee ) );
+
       /// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ///
       if( kTRUE == fbDebugMonitorMode )
       {
@@ -1792,6 +1833,7 @@ Bool_t CbmMcbm2018MonitorAlgoTof::CreateHistograms()
       AddHistoToVector( fvhRemapChRate_gDPB[ uGdpb ],  sFolderGdpb );
       if( kTRUE == fbDebugMonitorMode )
       {
+         AddHistoToVector( fvhRemapChErrFract_gDPB[ uGdpb ],  sFolderGdpb );
                /// Per MS in gDPB
          AddHistoToVector( fvhGdpbPatternMissmatchEvo[ uGdpb ], sFolderGdpbPatt );
          AddHistoToVector( fvhGdpbPatternEnableEvo[ uGdpb ],    sFolderGdpbPatt );
@@ -2147,6 +2189,7 @@ Bool_t CbmMcbm2018MonitorAlgoTof::ResetHistograms( Bool_t bResetTime )
    fhGdpbEpochMissEvo   ->Reset();
    fhGdpbEndMsBufferNotEmpty->Reset();
    fhGdpbEndMsDataLost  ->Reset();
+   fhGdpbHitRate        ->Reset();
    if( kTRUE == fbDebugMonitorMode )
    {
       fhNbMissPatternPerMs->Reset();
@@ -2170,6 +2213,7 @@ Bool_t CbmMcbm2018MonitorAlgoTof::ResetHistograms( Bool_t bResetTime )
       fvhRemapChRate_gDPB[ uGdpb ]        ->Reset();
       if( kTRUE == fbDebugMonitorMode )
       {
+         fvhRemapChErrFract_gDPB[ uGdpb ]    ->Reset();
          fvhGdpbPatternMissmatchEvo[ uGdpb ] ->Reset();
          fvhGdpbPatternEnableEvo[ uGdpb ]    ->Reset();
          fvhGdpbPatternResyncEvo[ uGdpb ]    ->Reset();
@@ -2218,6 +2262,7 @@ void CbmMcbm2018MonitorAlgoTof::ResetEvolutionHistograms()
       fvhRemapChRate_gDPB[ uGdpb ]->Reset();
       if( kTRUE == fbDebugMonitorMode )
       {
+         fvhRemapChErrFract_gDPB[ uGdpb ]->Reset();
 //         fvhGdpbPatternMissmatchEvo[ uGdpb ] ->Reset();
 //         fvhGdpbPatternEnableEvo[ uGdpb ]    ->Reset();
 //         fvhGdpbPatternResyncEvo[ uGdpb ]    ->Reset();
diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoTof.h b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoTof.h
index 5b8c6e27496e043e4013275e4883fd827cda473a..5ca84c0372b4f00216640bea70d1e8571f92a12b 100644
--- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoTof.h
+++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorAlgoTof.h
@@ -27,6 +27,7 @@ class CbmMcbm2018TofPar;
 class TH1;
 class TH2;
 class TProfile;
+class TProfile2D;
 
 class CbmMcbm2018MonitorAlgoTof : public CbmStar2019Algo<CbmTofDigi>
 {
@@ -62,12 +63,15 @@ class CbmMcbm2018MonitorAlgoTof : public CbmStar2019Algo<CbmTofDigi>
 
       inline void SetGdpbIndex( Int_t iGdpb = -1 ) { fiGdpbIndex = iGdpb; }
 
+      inline void UseAbsoluteTime( Bool_t bFlagIn = kTRUE) { fbUseAbsoluteTime = bFlagIn; }
+
    private:
       /// Control flags
       Bool_t fbDebugMonitorMode; //! Switch ON the filling of a additional set of histograms
       Bool_t fbIgnoreCriticalErrors; //! If ON not printout at all for critical errors
       std::vector< Bool_t >    fvbMaskedComponents;
       Int_t  fiGdpbIndex;
+      Bool_t fbUseAbsoluteTime = kFALSE;  //! Switch ON the usage of abolute time scale for the evo histo (no start time)
 
       /// Settings from parameter file
       CbmMcbm2018TofPar* fUnpackPar;      //!
@@ -161,6 +165,7 @@ class CbmMcbm2018MonitorAlgoTof : public CbmStar2019Algo<CbmTofDigi>
       TH2* fhGdpbEpochMissEvo;                                          //!
       TH1* fhGdpbEndMsBufferNotEmpty;                                   //!
       TH2* fhGdpbEndMsDataLost;                                         //!
+      TH2* fhGdpbHitRate;                                              //!
             /// Per GET4 in gDPB
       std::vector< TH2* > fvhGdpbGet4MessType;                          //!
       std::vector< TH2* > fvhGdpbGet4ChanScm;                           //!
@@ -184,6 +189,7 @@ class CbmMcbm2018MonitorAlgoTof : public CbmStar2019Algo<CbmTofDigi>
       std::vector< TH2      * > fvhRemapTot_gDPB;                       //!
       std::vector< TH1      * > fvhRemapChCount_gDPB;                   //!
       std::vector< TH2      * > fvhRemapChRate_gDPB;                    //!
+      std::vector< TProfile2D * > fvhRemapChErrFract_gDPB;                //!
          /// Pattern Messages
             /// Pattern messages per gDPB
       std::vector< UInt_t > fuNbMissmatchPattern;
diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorMuchLite.cxx b/fles/mcbm2018/monitor/CbmMcbm2018MonitorMuchLite.cxx
index 2a30c98b4cacd042e28d53e55980c5cce3e5fb65..f2df917161f38d887a27f367ee09e88778668d6a 100644
--- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorMuchLite.cxx
+++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorMuchLite.cxx
@@ -70,7 +70,7 @@ CbmMcbm2018MonitorMuchLite::CbmMcbm2018MonitorMuchLite() :
    fUnpackParMuch->GetNbChanPerAsic()(0),
    fuNbFebs(0),
    */
-   fsHistoFileFullname( "data/SetupHistos.root" ),
+   fsHistoFileFullname( "data/HistosMonitorMuch.root" ),
    fbPrintMessages( kFALSE ),
    fPrintMessCtrl( stsxyter::MessagePrintMask::msg_print_Human ),
    fulCurrentTsIdx( 0 ),
@@ -237,6 +237,10 @@ Bool_t CbmMcbm2018MonitorMuchLite::InitMuchParameters()
       } // for( UInt_t uCrobIdx = 0; uCrobIdx < fUnpackParMuch->GetNbCrobsPerDpb(); ++uCrobIdx )
    } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
 
+   if( fbBinningFw )
+      LOG(info) << "Unpacking data in bin sorter FW mode";
+      else LOG(info) << "Unpacking data in full time sorter FW mode (legacy)";
+
    // Internal status initialization
    fvulCurrentTsMsb.resize( fuNrOfDpbs );
    fvuCurrentTsMsbCycle.resize( fuNrOfDpbs );
@@ -489,6 +493,12 @@ void CbmMcbm2018MonitorMuchLite::CreateHistograms()
    title = "Rate in kHz with Adc cut";
    fhRateAdcCut = new TH1I(sHistName, title, 10000, -0.5, 9999.5);
 
+
+   sHistName = "hFEBcount";
+   title = "Count vs FEB number; FEB Number; Count";
+   fhFEBcount = new TH1I(sHistName, title, 40, -0.5, 39.5);
+
+
    sHistName = "hSysMessTypePerDpb";
    title = "Nb of system message of each type for each DPB; DPB; System Type";
    fhMuchSysMessTypePerDpb = new TH2I(sHistName, title, fuNrOfDpbs, 0, fuNrOfDpbs, 17, 0., 17.);
@@ -579,6 +589,22 @@ void CbmMcbm2018MonitorMuchLite::CreateHistograms()
       //fhMuchFebChanCntRawGood.push_back( new TH1I(sHistName, title,
       //                          fUnpackParMuch->GetNbChanPerFeb(), -0.5, fUnpackParMuch->GetNbChanPerFeb() - 0.5 ) );
 
+      sHistName = Form( "fhMuchFebSpill_%03u", uFebIdx );
+      title = Form( "Time distribution of hits, FEB #%03u; Time ; Counts ", uFebIdx );
+      fhMuchFebSpill.push_back( new TH1I(sHistName, title, 1000,0,1000 ) );
+
+
+      sHistName = Form( "hMuchChannelTime_FEB%03u", uFebIdx );
+      title = Form( "Time vs Channel, FEB #%03u; TIME(s) ; CHANNEL ", uFebIdx );
+      fhMuchChannelTime.push_back( new TH2I(sHistName, title, 1000,0,1000, 129, -0.5 , 128.5 ) );
+
+
+
+      sHistName = Form( "hMuchFebADC_%03u", uFebIdx );
+      title = Form( "CHANNEL vs ADC, FEB #%03u; CHANNEL ; ADC ", uFebIdx );
+      fhMuchFebADC.push_back( new TH2I(sHistName, title, 129,-0.5,128.5, 34, -0.5, 33.5 ) );
+
+
       /// Raw Adc Distribution
       sHistName = Form( "hMuchFebChanAdcRaw_%03u", uFebIdx );
       title = Form( "Raw Adc distribution per channel, FEB #%03u; Channel []; Adc []; Hits []", uFebIdx );
@@ -682,6 +708,10 @@ void CbmMcbm2018MonitorMuchLite::CreateHistograms()
 
    } // for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx )
 
+///++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++///
+   fhDpbMsErrors = new TH2I( "fhDpbMsErrors", "; DPB []; Error type []; Counts []",
+       fuNrOfDpbs, 0, fuNrOfDpbs,
+         4, -0.5,    3.5 );
 ///++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++///
 
   // Miscroslice properties histos
@@ -697,18 +727,19 @@ void CbmMcbm2018MonitorMuchLite::CreateHistograms()
    {
      for( UInt_t uModuleId = 0; uModuleId < 2; ++uModuleId )
      {
-      server->Register("/MuchRaw", fHistPadDistr[uModuleId] );
-      server->Register("/MuchRaw", fRealHistPadDistr[uModuleId] );
-      server->Register("/MuchFeb", fhMuchFebDuplicateHitProf[uModuleId] );
+     // server->Register("/MuchRaw", fHistPadDistr[uModuleId] );
+     // server->Register("/MuchRaw", fRealHistPadDistr[uModuleId] );
+     // server->Register("/MuchFeb", fhMuchFebDuplicateHitProf[uModuleId] );
      }
 
-      server->Register("/MuchRaw", fhRate );
-      server->Register("/MuchRaw", fhRateAdcCut );
+    //  server->Register("/MuchRaw", fhRate );
+    //  server->Register("/MuchRaw", fhRateAdcCut );
+      server->Register("/MuchRaw", fhFEBcount );
       server->Register("/MuchRaw", fhMuchMessType );
-      server->Register("/MuchRaw", fhMuchSysMessType );
+     // server->Register("/MuchRaw", fhMuchSysMessType );
       server->Register("/MuchRaw", fhMuchMessTypePerDpb );
       server->Register("/MuchRaw", fhMuchSysMessTypePerDpb );
-      server->Register("/MuchRaw", fhStatusMessType );
+     // server->Register("/MuchRaw", fhStatusMessType );
       server->Register("/MuchRaw", fhMsStatusFieldType );
       server->Register("/MuchRaw", fhMuchHitsElinkPerDpb );
       server->Register("/MuchRaw", fhMuchFebChanAdcRaw_combined );
@@ -717,19 +748,23 @@ void CbmMcbm2018MonitorMuchLite::CreateHistograms()
          if( kTRUE == fUnpackParMuch->IsFebActive( uFebIdx ) )
          {
             server->Register("/MuchFeb", fhMuchFebChanCntRaw[ uFebIdx ] );
+            server->Register( "/MuchFeb",fhMuchFebSpill[ uFebIdx ] );
+            server->Register( "/MuchFeb",fhMuchFebADC[ uFebIdx ] );
+            server->Register( "/MuchFeb",fhMuchChannelTime[ uFebIdx ] );
+
             //server->Register("/MuchFeb", fhMuchFebChanCntRawGood[ uFebIdx ] );
-            server->Register("/MuchFeb", fhMuchFebChanAdcRaw[ uFebIdx ] );
-            server->Register("/MuchFeb", fhMuchFebChanAdcRawProf[ uFebIdx ] );
+         ////   server->Register("/MuchFeb", fhMuchFebChanAdcRaw[ uFebIdx ] );
+          //  server->Register("/MuchFeb", fhMuchFebChanAdcRawProf[ uFebIdx ] );
             //server->Register("/MuchFeb", fhMuchFebChanAdcCal[ uFebIdx ] );
             //server->Register("/MuchFeb", fhMuchFebChanAdcCalProf[ uFebIdx ] );
-            server->Register("/MuchFeb", fhMuchFebChanRawTs[ uFebIdx ] );
-            server->Register("/MuchFeb", fhMuchFebChanHitRateEvo[ uFebIdx ] );
-            server->Register("/MuchFeb", fhMuchFebChanHitRateProf[ uFebIdx ] );
+           //// server->Register("/MuchFeb", fhMuchFebChanRawTs[ uFebIdx ] );
+            //server->Register("/MuchFeb", fhMuchFebChanHitRateEvo[ uFebIdx ] );
+           // server->Register("/MuchFeb", fhMuchFebChanHitRateProf[ uFebIdx ] );
             //server->Register("/MuchFeb", fhMuchFebAsicHitRateEvo[ uFebIdx ] );
-            server->Register("/MuchFeb", fhMuchFebHitRateEvo[ uFebIdx ] );
-            server->Register("/MuchFeb", fhMuchFebHitRateEvo_mskch[ uFebIdx ] );
-            server->Register("/MuchFeb", fhMuchFebHitRateEvo_mskch_adccut[ uFebIdx ] );
-            server->Register("/MuchFeb", fhMuchFebHitRateEvo_WithoutDupli[ uFebIdx ] );
+           // server->Register("/MuchFeb", fhMuchFebHitRateEvo[ uFebIdx ] );
+          ////  server->Register("/MuchFeb", fhMuchFebHitRateEvo_mskch[ uFebIdx ] );
+           // server->Register("/MuchFeb", fhMuchFebHitRateEvo_mskch_adccut[ uFebIdx ] );
+           // server->Register("/MuchFeb", fhMuchFebHitRateEvo_WithoutDupli[ uFebIdx ] );
    	    LOG(debug)<< "Initialized fhMuchFebHitRateEvo_WithoutDupli number "<< uFebIdx;
             /*server->Register("/MuchFeb", fhMuchFebChanHitRateEvoLong[ uFebIdx ] );
             server->Register("/MuchFeb", fhMuchFebAsicHitRateEvoLong[ uFebIdx ] );
@@ -737,6 +772,7 @@ void CbmMcbm2018MonitorMuchLite::CreateHistograms()
             server->Register("/MuchFeb", fhMuchFebChanDistT[ uFebIdx ] );*/
 
 	 } // if( kTRUE == fUnpackParMuch->IsFebActive( uFebIdx ) )
+      server->Register("/MuchRaw", fhDpbMsErrors );
       } // for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx )
 
       LOG(debug)<< "Initialized FEB  8th Histo";
@@ -753,56 +789,79 @@ void CbmMcbm2018MonitorMuchLite::CreateHistograms()
    Double_t w = 10;
    Double_t h = 10;
    LOG(debug)<< "Initialized 7th Histo before Summary per FEB";
+
+    TCanvas* cChannel = new TCanvas( Form("CHANNELS"),
+                                       Form("CHANNELS") ); //,
+//                                          w, h);
+    cChannel->Divide( 4, 9 );
       // Summary per FEB
    for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx )
    {
       if( kTRUE == fUnpackParMuch->IsFebActive( uFebIdx ) )
       {
-         TCanvas* cMuchSumm = new TCanvas( Form("cMuchSum_%03u", uFebIdx ),
-                                          Form("Summary plots for FEB %03u", uFebIdx ),
-                                          w, h);
-         cMuchSumm->Divide( 2, 2 );
-
-         cMuchSumm->cd(1);
-         gPad->SetGridx();
-         gPad->SetGridy();
+         cChannel->cd(uFebIdx+1);
+        //// gPad->SetGridx();
+        // gPad->SetGridy();
          gPad->SetLogy();
          fhMuchFebChanCntRaw[ uFebIdx ]->Draw();
 
-         cMuchSumm->cd(2);
-         gPad->SetGridx();
-         gPad->SetGridy();
-         gPad->SetLogy();
-         fhMuchFebChanHitRateProf[ uFebIdx ]->Draw( "e0" );
-
-         cMuchSumm->cd(3);
-         gPad->SetGridx();
-         gPad->SetGridy();
-         gPad->SetLogz();
-         fhMuchFebChanAdcRaw[ uFebIdx ]->Draw( "colz" );
-
-         cMuchSumm->cd(4);
-         gPad->SetGridx();
-         gPad->SetGridy();
-	 //      gPad->SetLogy();
-         fhMuchFebChanAdcRawProf[ uFebIdx ]->Draw();
-
-         /*cMuchSumm->cd(5);
-         gPad->SetGridx();
-         gPad->SetGridy();
-         gPad->SetLogz();
-         //fhMuchFebChanAdcCal[ uFebIdx ]->Draw( "colz" );
-
-         cMuchSumm->cd(6);
-         gPad->SetGridx();
-         gPad->SetGridy();
-	 //      gPad->SetLogy();
-         //fhMuchFebChanAdcCalProf[ uFebIdx ]->Draw();*/
-
       } // if( kTRUE == fUnpackParMuch->IsFebActive( uFebIdx ) )
    } // for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx )
 
+    server->Register("/canvases", cChannel);
+   //All Feb hit rate together on one Canvas
+
+  TCanvas* cspill = new TCanvas(  Form("SPILLS"),Form("SPILLS") ); //,w, h);
+  cspill->Divide( 4, 9 );
+
+   for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx )
+   {
+      if( kTRUE == fUnpackParMuch->IsFebActive( uFebIdx ) )
+      {
+	UInt_t flPad = 1+ uFebIdx;
+         cspill->cd(flPad);
+         //gPad->SetGridx();
+         //gPad->SetGridy();
+	 // gPad->SetLogy();
+         fhMuchFebSpill[ uFebIdx ]->Draw();
+      }
+   // server->Register("/canvases", cspill);
+    }
+   server->Register("/canvases", cspill);
+
+  TCanvas* cadc = new TCanvas(  Form("ADC"),Form("ADC"),w, h);
+   cadc->Divide( 4, 9 );
+
+   for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx )
+   {
+      if( kTRUE == fUnpackParMuch->IsFebActive( uFebIdx ) )
+      {
+	UInt_t flPad = 1+ uFebIdx;
+         cadc->cd(flPad);
+         //gPad->SetGridx();
+         //gPad->SetGridy();
+         //gPad->SetLogy();
+         fhMuchFebADC[ uFebIdx ]->Draw("colz");
+      }
+    }
+   server->Register("/canvases", cadc);
+
+  TCanvas* cChanneltime = new TCanvas(  Form("ChannelvsTime"),Form("ChannelvsTime"),w, h);
+   cChanneltime->Divide( 4, 9 );
 
+   for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx )
+   {
+      if( kTRUE == fUnpackParMuch->IsFebActive( uFebIdx ) )
+      {
+	UInt_t flPad = 1+ uFebIdx;
+         cChanneltime->cd(flPad);
+         //gPad->SetGridx();
+         //gPad->SetGridy();
+         //gPad->SetLogy();
+         fhMuchChannelTime[ uFebIdx ]->Draw("colz");
+      }
+    }
+   server->Register("/canvases", cChanneltime);
   //====================================================================//
      LOG(debug)<< "Initialized Last Histo before exiting CreateHistograms";
   //====================================================================//
@@ -812,9 +871,10 @@ void CbmMcbm2018MonitorMuchLite::CreateHistograms()
   fcMsSizeAll = dynamic_cast<TCanvas *>( gROOT->FindObject( "cMsSizeAll" ) );
   if( NULL == fcMsSizeAll )
   {
-     fcMsSizeAll = new TCanvas("cMsSizeAll", "Evolution of MS size in last 300 s", w, h);
-     fcMsSizeAll->Divide( 4, 4 );
+     fcMsSizeAll = new TCanvas("cMsSizeAll", "Evolution of MS size in last 300 s"); //, w, h);
+     fcMsSizeAll->Divide( 1, 8 );
       LOG(info) << "Created MS size canvas in Much monitor";
+      server->Register("/canvases",fcMsSizeAll);
   } // if( NULL == fcMsSizeAll )
       else LOG(info) << "Recovered MS size canvas in Much monitor";
 //====================================================================//
@@ -951,6 +1011,15 @@ Bool_t CbmMcbm2018MonitorMuchLite::DoUnpack(const fles::Timeslice& ts, size_t co
              * static_cast<ULong64_t>( fvulCurrentTsMsb[fuCurrDpbIdx])
              + static_cast<ULong64_t>( stsxyter::kulTsCycleNbBins )
              * static_cast<ULong64_t>( fvuCurrentTsMsbCycle[fuCurrDpbIdx] );
+
+         /// => Quick and dirty hack for binning FW!!!
+         if( kTRUE == fbBinningFw )
+            dTsMsbTime =
+                     static_cast<ULong64_t>( stsxyter::kuHitNbTsBinsBinning )
+                   * static_cast<ULong64_t>( fvulCurrentTsMsb[fuCurrDpbIdx])
+                   + static_cast<ULong64_t>( stsxyter::kulTsCycleNbBinsBinning )
+                   * static_cast<ULong64_t>( fvuCurrentTsMsbCycle[fuCurrDpbIdx] )
+                   ;
          dTsMsbTime *= stsxyter::kdClockCycleNs * 1e-9;
 
          LOG(info) << "End of TS " << std::setw(7) << ts.index()
@@ -1083,6 +1152,13 @@ Bool_t CbmMcbm2018MonitorMuchLite::ProcessMuchMs( const fles::Timeslice& ts, siz
    UInt_t uTsMsbCycleHeader = std::floor( fulCurrentMsIdx /
                                           ( stsxyter::kulTsCycleNbBins * stsxyter::kdClockCycleNs ) )
                               - fvuInitialTsMsbCycleHeader[ fuCurrDpbIdx ];
+
+   /// => Quick and dirty hack for binning FW!!!
+   if( kTRUE == fbBinningFw )
+      uTsMsbCycleHeader = std::floor( fulCurrentMsIdx /
+                                      ( stsxyter::kulTsCycleNbBinsBinning * stsxyter::kdClockCycleNs ) )
+                           - fvuInitialTsMsbCycleHeader[ fuCurrDpbIdx ];
+
    if( kFALSE == fvuInitialHeaderDone[ fuCurrDpbIdx ] )
    {
       fvuInitialTsMsbCycleHeader[ fuCurrDpbIdx ] = uTsMsbCycleHeader;
@@ -1132,8 +1208,8 @@ Bool_t CbmMcbm2018MonitorMuchLite::ProcessMuchMs( const fles::Timeslice& ts, siz
 */
       stsxyter::MessType typeMess = mess.GetMessType();
       fmMsgCounter[ typeMess ] ++;
-      fhMuchMessType->Fill( static_cast< uint16_t > (typeMess) );
-      fhMuchMessTypePerDpb->Fill( fuCurrDpbIdx, static_cast< uint16_t > (typeMess) );
+     // fhMuchMessType->Fill( static_cast< uint16_t > (typeMess) );
+     // fhMuchMessTypePerDpb->Fill( fuCurrDpbIdx, static_cast< uint16_t > (typeMess) );
 
       switch( typeMess )
       {
@@ -1141,6 +1217,10 @@ Bool_t CbmMcbm2018MonitorMuchLite::ProcessMuchMs( const fles::Timeslice& ts, siz
          {
             // Extract the eLink and Asic indices => Should GO IN the fill method now that obly hits are link/asic specific!
             UShort_t usElinkIdx = mess.GetLinkIndex();
+            /// => Quick and dirty hack for binning FW!!!
+            if( kTRUE == fbBinningFw )
+               usElinkIdx = mess.GetLinkIndexHitBinning();
+
             UInt_t   uCrobIdx   = usElinkIdx / fUnpackParMuch->GetNbElinkPerCrob();
             Int_t   uFebIdx    = fUnpackParMuch->ElinkIdxToFebIdx( usElinkIdx );
 //            if(usElinkIdx!=0)
@@ -1190,7 +1270,7 @@ Bool_t CbmMcbm2018MonitorMuchLite::ProcessMuchMs( const fles::Timeslice& ts, siz
 
             UShort_t usStatusField = mess.GetStatusStatus();
 
-            fhStatusMessType->Fill( uAsicIdx, usStatusField );
+           // fhStatusMessType->Fill( uAsicIdx, usStatusField );
             /// Always print status messages... or not?
             if( fbPrintMessages )
             {
@@ -1205,6 +1285,14 @@ Bool_t CbmMcbm2018MonitorMuchLite::ProcessMuchMs( const fles::Timeslice& ts, siz
 //                   FillTsMsbInfo( mess );
             break;
          } // case stsxyter::MessType::Empty :
+         case stsxyter::MessType::EndOfMs :
+         {
+            if( mess.IsMsErrorFlagOn() )
+            {
+               fhDpbMsErrors->Fill( fuCurrDpbIdx, mess.GetMsErrorType() );
+            } // if( pMess[uIdx].IsMsErrorFlagOn() )
+            break;
+         } // case stsxyter::MessType::EndOfMs :
          case stsxyter::MessType::Dummy :
          {
             break;
@@ -1232,12 +1320,17 @@ void CbmMcbm2018MonitorMuchLite::FillHitInfo( stsxyter::Message mess, const USho
    //Below FebID is according to FEB Position in Module GEM A or Module GEM B (Carefully write MUCH Par file)
    Int_t FebId = fUnpackParMuch->GetFebId(uAsicIdx);
 
+   /// => Quick and dirty hack for binning FW!!!
+   if( kTRUE == fbBinningFw )
+      usRawTs  = mess.GetHitTimeBinning();
+
 //   UInt_t uFebIdx    = uAsicIdx / fUnpackParMuch->GetNbAsicsPerFeb();
 	//For MUCH each FEB has one StsXyter
    UInt_t uFebIdx    = uAsicIdx;
 //   UInt_t uCrobIdx   = usElinkIdx / fUnpackParMuch->GetNbElinkPerCrob();
 //   UInt_t uAsicInFeb = uAsicIdx % fUnpackParMuch->GetNbAsicsPerFeb();
    UInt_t uChanInFeb = usChan + fUnpackParMuch->GetNbChanPerAsic() * (uAsicIdx % fUnpackParMuch->GetNbAsicsPerFeb());
+   Int_t ModuleNr = fUnpackParMuch->GetModule(uAsicIdx);
    Int_t sector  = fUnpackParMuch->GetPadXA(FebId, usChan);
    Int_t channel = fUnpackParMuch->GetPadYA(FebId, usChan);
 
@@ -1251,26 +1344,27 @@ void CbmMcbm2018MonitorMuchLite::FillHitInfo( stsxyter::Message mess, const USho
 	ActualX = 1000-ActualX;
         channel = 96 - channel;
 
-   Int_t ModuleNr = fUnpackParMuch->GetModule(uAsicIdx);
-
    LOG(debug)<< "Module Nr " << ModuleNr << " Sector Nr "<< sector <<" Channel Nr "<<channel << "Actual X "<< ActualX << "Actual Y " <<ActualY << "uAsicIdx "<<uAsicIdx;
 
 
-   fHistPadDistr[ModuleNr]->Fill(sector, channel);
-   fRealHistPadDistr[ModuleNr]->Fill(ActualY, ActualX);
+//   fHistPadDistr[ModuleNr]->Fill(sector, channel);
+//   fRealHistPadDistr[ModuleNr]->Fill(ActualY, ActualX);
 
    //Double_t dCalAdc = fvdFebAdcOffs[ fuCurrDpbIdx ][ uCrobIdx ][ uFebIdx ]
    //                  + (usRawAdc - 1)* fvdFebAdcGain[ fuCurrDpbIdx ][ uCrobIdx ][ uFebIdx ];
-
+   fhFEBcount->Fill(uFebIdx);
+//   fhMuchFebSpill[uFebIdx] ->Fill(usRawTs);
    fhMuchFebChanCntRaw[  uFebIdx ]->Fill( uChanInFeb );
-   fhMuchFebChanAdcRaw[  uFebIdx ]->Fill( uChanInFeb, usRawAdc );
-   fhMuchFebChanAdcRawProf[  uFebIdx ]->Fill( uChanInFeb, usRawAdc );
+//   fhMuchFebChanAdcRaw[  uFebIdx ]->Fill( uChanInFeb, usRawAdc );
+ //  fhMuchFebChanAdcRawProf[  uFebIdx ]->Fill( uChanInFeb, usRawAdc );
    //fhMuchFebChanAdcCal[  uFebIdx ]->Fill(     uChanInFeb, dCalAdc );
    //fhMuchFebChanAdcCalProf[  uFebIdx ]->Fill( uChanInFeb, dCalAdc );
-   fhMuchFebChanRawTs[   uFebIdx ]->Fill( usChan, usRawTs );
+  // fhMuchFebChanRawTs[   uFebIdx ]->Fill( usChan, usRawTs );
    //fhMuchFebChanMissEvt[ uFebIdx ]->Fill( usChan, mess.IsHitMissedEvts() );
-   fhMuchFebChanAdcRaw_combined->Fill(usRawAdc);
+ //  fhMuchFebChanAdcRaw_combined->Fill(usRawAdc);
 
+
+   fhMuchFebADC[uFebIdx]->Fill(usChan,usRawAdc);
    // Compute the Full time stamp
    ULong64_t ulOldHitTime = fvulChanLastHitTime[ uAsicIdx ][ usChan ];
 //   Long64_t dOldHitTime  = fvdChanLastHitTime[ uAsicIdx ][ usChan ];
@@ -1285,6 +1379,15 @@ void CbmMcbm2018MonitorMuchLite::FillHitInfo( stsxyter::Message mess, const USho
              * static_cast<ULong64_t>( fvuCurrentTsMsbCycle[fuCurrDpbIdx] )
              ;
 
+   /// => Quick and dirty hack for binning FW!!!
+   if( kTRUE == fbBinningFw )
+      fvulChanLastHitTime[ uAsicIdx ][ usChan ] = usRawTs +
+               static_cast<ULong64_t>( stsxyter::kuHitNbTsBinsBinning )
+             * static_cast<ULong64_t>( fvulCurrentTsMsb[fuCurrDpbIdx])
+             + static_cast<ULong64_t>( stsxyter::kulTsCycleNbBinsBinning )
+             * static_cast<ULong64_t>( fvuCurrentTsMsbCycle[fuCurrDpbIdx] )
+             ;
+
 
    // Convert the Hit time in bins to Hit time in ns
    Long64_t dHitTimeNs = fvulChanLastHitTime[ uAsicIdx ][ usChan ] * stsxyter::kdClockCycleNs;
@@ -1293,10 +1396,11 @@ void CbmMcbm2018MonitorMuchLite::FillHitInfo( stsxyter::Message mess, const USho
    fvdChanLastHitTime[ uAsicIdx ][ usChan ] = fvulChanLastHitTime[ uAsicIdx ][ usChan ] * stsxyter::kdClockCycleNs;
    // For StsXyter2.0 Duplicate Hit Error
    //Int_t ModuleNr = fUnpackParMuch->GetModule(uAsicIdx);
+/*
    fhMuchFebDuplicateHitProf[ModuleNr]->Fill(FebId,0);
    if( ulOldHitTime == fvulChanLastHitTime[uAsicIdx][usChan] )
   		     fhMuchFebDuplicateHitProf[ModuleNr]->Fill(FebId,1);
-
+*/
 
 /*
    LOG(info) << " Asic " << std::setw( 2 ) << uAsicIdx
@@ -1330,8 +1434,8 @@ void CbmMcbm2018MonitorMuchLite::FillHitInfo( stsxyter::Message mess, const USho
 	}
 	else
 	{
-		fhRate->Fill(Counter);
-                fhRateAdcCut->Fill(Counter1);
+		//fhRate->Fill(Counter);
+               // fhRateAdcCut->Fill(Counter1);
 		Counter=0;
                 Counter1=0;
 	        prevtime_new = fvdChanLastHitTime[ uAsicIdx ][ usChan ];
@@ -1345,15 +1449,19 @@ void CbmMcbm2018MonitorMuchLite::FillHitInfo( stsxyter::Message mess, const USho
    fviFebCountsSinceLastRateUpdate[uFebIdx]++;
    fvdFebChanCountsSinceLastRateUpdate[uFebIdx][uChanInFeb] += 1;
 
-   fhMuchFebChanHitRateEvo[ uFebIdx ]->Fill( dTimeSinceStartSec, uChanInFeb );
+  // fhMuchFebChanHitRateEvo[ uFebIdx ]->Fill( dTimeSinceStartSec, uChanInFeb );
    //fhMuchFebAsicHitRateEvo[ uFebIdx ]->Fill( dTimeSinceStartSec, uAsicInFeb );
-   fhMuchFebHitRateEvo[ uFebIdx ]->Fill( dTimeSinceStartSec );
-   fhMuchFebHitRateEvo_mskch[ uFebIdx ]->Fill( dTimeSinceStartSec );
-   if(usRawAdc>1)fhMuchFebHitRateEvo_mskch_adccut[ uFebIdx ]->Fill(     dTimeSinceStartSec );
+  // fhMuchFebHitRateEvo[ uFebIdx ]->Fill( dTimeSinceStartSec );
+  // fhMuchFebHitRateEvo_mskch[ uFebIdx ]->Fill( dTimeSinceStartSec );
+  // if(usRawAdc>1)fhMuchFebHitRateEvo_mskch_adccut[ uFebIdx ]->Fill(     dTimeSinceStartSec );
    //fhMuchFebChanHitRateEvoLong[ uFebIdx ]->Fill( dTimeSinceStartMin, uChanInFeb, 1.0/60.0 );
    //fhMuchFebAsicHitRateEvoLong[ uFebIdx ]->Fill( dTimeSinceStartMin, uAsicInFeb,   1.0/60.0 );
    //fhMuchFebHitRateEvoLong[ uFebIdx ]->Fill(     dTimeSinceStartMin,             1.0/60.0 );
 
+  fhMuchFebSpill[uFebIdx] ->Fill(dTimeSinceStartSec);
+   fhMuchFebChanCntRaw[  uFebIdx ]->Fill( usChan );
+ fhMuchChannelTime[uFebIdx]->Fill(dTimeSinceStartSec,usChan);
+
    /*
    if( mess.IsHitMissedEvts() )
    {
@@ -1369,7 +1477,7 @@ void CbmMcbm2018MonitorMuchLite::FillHitInfo( stsxyter::Message mess, const USho
    }
    else
    {
-     fhMuchFebHitRateEvo_WithoutDupli[ uFebIdx ]->Fill( dTimeSinceStartSec );
+    // fhMuchFebHitRateEvo_WithoutDupli[ uFebIdx ]->Fill( dTimeSinceStartSec );
    }
    prevTime = fvdChanLastHitTime[ uAsicIdx ][ usChan ];
    prevChan = usChan;
@@ -1379,6 +1487,10 @@ void CbmMcbm2018MonitorMuchLite::FillHitInfo( stsxyter::Message mess, const USho
 void CbmMcbm2018MonitorMuchLite::FillTsMsbInfo( stsxyter::Message mess, UInt_t /*uMessIdx*/, UInt_t /*uMsIdx*/ )
 {
    UInt_t uVal    = mess.GetTsMsbVal();
+   /// => Quick and dirty hack for binning FW!!!
+   if( kTRUE == fbBinningFw )
+      uVal = mess.GetTsMsbValBinning();
+
    // Update Status counters
    if( uVal < fvulCurrentTsMsb[fuCurrDpbIdx] )
    {
@@ -1442,20 +1554,22 @@ void CbmMcbm2018MonitorMuchLite::SaveAllHistos( TString sFileName )
 
    for( UInt_t uModuleId = 0; uModuleId < 2; ++uModuleId )
    {
-	   fHistPadDistr[uModuleId]->Write();
-	   fRealHistPadDistr[uModuleId]->Write();
-	   fhMuchFebDuplicateHitProf[uModuleId]->Write();
+	 //  fHistPadDistr[uModuleId]->Write();
+	  // fRealHistPadDistr[uModuleId]->Write();
+	  // fhMuchFebDuplicateHitProf[uModuleId]->Write();
    }
-   fhRate->Write();
-   fhRateAdcCut->Write();
-   fhMuchMessType->Write();
-   fhMuchSysMessType->Write();
-   fhMuchMessTypePerDpb->Write();
-   fhMuchSysMessTypePerDpb->Write();
-   fhStatusMessType->Write();
+ //  fhRate->Write();
+ //  fhRateAdcCut->Write();
+   fhFEBcount->Write();
+//   fhMuchMessType->Write();
+ //  fhMuchSysMessType->Write();
+//   fhMuchMessTypePerDpb->Write();
+ //  fhMuchSysMessTypePerDpb->Write();
+  // fhStatusMessType->Write();
    fhMsStatusFieldType->Write();
    fhMuchHitsElinkPerDpb->Write();
-   fhMuchFebChanAdcRaw_combined->Write();
+  // fhMuchFebChanAdcRaw_combined->Write();
+  fhDpbMsErrors->Write();
    gDirectory->cd("..");
    /***************************/
 
@@ -1467,18 +1581,21 @@ void CbmMcbm2018MonitorMuchLite::SaveAllHistos( TString sFileName )
       if( kTRUE == fUnpackParMuch->IsFebActive( uFebIdx ) )
       {
          fhMuchFebChanCntRaw[ uFebIdx ]->Write();
+         fhMuchFebSpill[ uFebIdx ]->Write();
+         fhMuchChannelTime[ uFebIdx ]->Write();
+         fhMuchFebADC[ uFebIdx ]->Write();
          //fhMuchFebChanCntRawGood[ uFebIdx ]->Write();
-         fhMuchFebChanAdcRaw[ uFebIdx ]->Write();
-         fhMuchFebChanAdcRawProf[ uFebIdx ]->Write();
+        // fhMuchFebChanAdcRaw[ uFebIdx ]->Write();
+        // fhMuchFebChanAdcRawProf[ uFebIdx ]->Write();
          //fhMuchFebChanAdcCal[ uFebIdx ]->Write();
          //fhMuchFebChanAdcCalProf[ uFebIdx ]->Write();
-         fhMuchFebChanRawTs[ uFebIdx ]->Write();
-         fhMuchFebChanHitRateProf[ uFebIdx ]->Write();
+        // fhMuchFebChanRawTs[ uFebIdx ]->Write();
+        // fhMuchFebChanHitRateProf[ uFebIdx ]->Write();
          //fhMuchFebAsicHitRateEvo[ uFebIdx ]->Write();
-         fhMuchFebHitRateEvo[ uFebIdx ]->Write();
-         fhMuchFebHitRateEvo_mskch[ uFebIdx ]->Write();
-         fhMuchFebHitRateEvo_mskch_adccut[ uFebIdx ]->Write();
-         fhMuchFebHitRateEvo_WithoutDupli[ uFebIdx ]->Write();
+        // fhMuchFebHitRateEvo[ uFebIdx ]->Write();
+        // fhMuchFebHitRateEvo_mskch[ uFebIdx ]->Write();
+        // fhMuchFebHitRateEvo_mskch_adccut[ uFebIdx ]->Write();
+        // fhMuchFebHitRateEvo_WithoutDupli[ uFebIdx ]->Write();
          /*fhMuchFebChanHitRateEvoLong[ uFebIdx ]->Write();
          fhMuchFebAsicHitRateEvoLong[ uFebIdx ]->Write();
          fhMuchFebHitRateEvoLong[ uFebIdx ]->Write();
@@ -1525,39 +1642,44 @@ void CbmMcbm2018MonitorMuchLite::ResetAllHistos()
 
    for( UInt_t uModuleId = 0; uModuleId < 2; ++uModuleId )
    {
-   fHistPadDistr[uModuleId]->Reset();
-   fRealHistPadDistr[uModuleId]->Reset();
+   //fHistPadDistr[uModuleId]->Reset();
+   //fRealHistPadDistr[uModuleId]->Reset();
    fhMuchFebDuplicateHitProf[uModuleId]->Reset();
    }
-   fhRate->Reset();
-   fhRateAdcCut->Reset();
-   fhMuchMessType->Reset();
-   fhMuchSysMessType->Reset();
-   fhMuchMessTypePerDpb->Reset();
-   fhMuchSysMessTypePerDpb->Reset();
-   fhStatusMessType->Reset();
+  // fhRate->Reset();
+  // fhRateAdcCut->Reset();
+   fhFEBcount->Reset();
+  // fhMuchMessType->Reset();
+  // fhMuchSysMessType->Reset();
+  // fhMuchMessTypePerDpb->Reset();
+  // fhMuchSysMessTypePerDpb->Reset();
+  // fhStatusMessType->Reset();
    fhMsStatusFieldType->Reset();
    fhMuchHitsElinkPerDpb->Reset();
-   fhMuchFebChanAdcRaw_combined->Reset();
+  // fhMuchFebChanAdcRaw_combined->Reset();
+  fhDpbMsErrors->Reset();
 
    for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx )
    {
       if( kTRUE == fUnpackParMuch->IsFebActive( uFebIdx ) )
       {
          fhMuchFebChanCntRaw[ uFebIdx ]->Reset();
+         fhMuchFebSpill[ uFebIdx ] ->Reset();
+         fhMuchChannelTime[ uFebIdx ]->Reset();
+         fhMuchFebADC[ uFebIdx ] ->Reset();
          //fhMuchFebChanCntRawGood[ uFebIdx ]->Reset();
-         fhMuchFebChanAdcRaw[ uFebIdx ]->Reset();
-         fhMuchFebChanAdcRawProf[ uFebIdx ]->Reset();
+        //// fhMuchFebChanAdcRaw[ uFebIdx ]->Reset();
+         //fhMuchFebChanAdcRawProf[ uFebIdx ]->Reset();
          //fhMuchFebChanAdcCal[ uFebIdx ]->Reset();
          //fhMuchFebChanAdcCalProf[ uFebIdx ]->Reset();
-         fhMuchFebChanRawTs[ uFebIdx ]->Reset();
-         fhMuchFebChanHitRateEvo[ uFebIdx ]->Reset();
-         fhMuchFebChanHitRateProf[ uFebIdx ]->Reset();
+         ////fhMuchFebChanRawTs[ uFebIdx ]->Reset();
+     //    fhMuchFebChanHitRateEvo[ uFebIdx ]->Reset();
+        // fhMuchFebChanHitRateProf[ uFebIdx ]->Reset();
          //fhMuchFebAsicHitRateEvo[ uFebIdx ]->Reset();
-         fhMuchFebHitRateEvo[ uFebIdx ]->Reset();
-         fhMuchFebHitRateEvo_mskch[ uFebIdx ]->Reset();
-         fhMuchFebHitRateEvo_mskch_adccut[ uFebIdx ]->Reset();
-         fhMuchFebHitRateEvo_WithoutDupli[ uFebIdx ]->Reset();
+        //// fhMuchFebHitRateEvo[ uFebIdx ]->Reset();
+        // fhMuchFebHitRateEvo_mskch[ uFebIdx ]->Reset();
+       //  fhMuchFebHitRateEvo_mskch_adccut[ uFebIdx ]->Reset();
+      //   fhMuchFebHitRateEvo_WithoutDupli[ uFebIdx ]->Reset();
          /*fhMuchFebChanHitRateEvoLong[ uFebIdx ]->Reset();
          fhMuchFebAsicHitRateEvoLong[ uFebIdx ]->Reset();
          fhMuchFebHitRateEvoLong[ uFebIdx ]->Reset();
diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorMuchLite.h b/fles/mcbm2018/monitor/CbmMcbm2018MonitorMuchLite.h
index 3fc9768e151e07beb48cb4f014a751969587a194..1de2cc170eaf9556106c8d77c5f52a701b7ca200 100644
--- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorMuchLite.h
+++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorMuchLite.h
@@ -80,11 +80,18 @@ public:
 
 //   void SetTimeBin( size_t uTimeBin );
    void UseDaqBuffer(Bool_t) {}; //Virtual function in Mother Class, Need to update accordingly. VS
+
+   /// => Quick and dirty hack for binning FW!!!
+   void SetBinningFwFlag( Bool_t bEnable = kTRUE ) { fbBinningFw = bEnable; }
+
 private:
    // Parameters
       // Control flags
    Bool_t fbMuchMode;
    std::vector< Bool_t >    fvbMaskedComponents;
+         /// => Quick and dirty hack for binning FW!!!
+   Bool_t                fbBinningFw = kFALSE;
+
       // FLES containers
    std::vector< size_t >    fvMsComponentsList; //!
    size_t                   fuNbCoreMsPerTs; //!
@@ -185,6 +192,7 @@ private:
 
    TH1* fhRate;
    TH1* fhRateAdcCut;
+   TH1* fhFEBcount = nullptr;
   // std::vector<TH1 *>     fhMuchFebChanRateEvo;
 
       /// Plots per FEB-8
@@ -195,12 +203,15 @@ private:
 
    //Double_t fdFebChanCoincidenceLimit; // ns
    std::vector<TH1 *>     fhMuchFebChanCntRaw;
+   std::vector<TH1 *>   fhMuchFebSpill = {};
+   std::vector<TH2 *>   fhMuchFebADC = {};
    //std::vector<TH1 *>     fhMuchFebChanCntRawGood;
    std::vector<TH2 *>     fhMuchFebChanAdcRaw;
    std::vector<TProfile*> fhMuchFebChanAdcRawProf;
    //std::vector<TH2 *>     fhMuchFebChanAdcCal;
    //std::vector<TProfile*> fhMuchFebChanAdcCalProf;
    std::vector<TH2*>      fhMuchFebChanRawTs;
+   std::vector<TH2*>      fhMuchChannelTime = {};
    //std::vector<TH2*>      fhMuchFebChanMissEvt;
    //std::vector<TH2*>      fhMuchFebChanMissEvtEvo;
    //std::vector<TH2*>      fhMuchFebAsicMissEvtEvo;
@@ -221,6 +232,9 @@ private:
    //std::vector< std::vector<TH2*> > fhMuchFebChanCoinc;
    std::vector<TProfile*> fhMuchFebDuplicateHitProf;
 
+   /// Binning FW error flag
+   TH2* fhDpbMsErrors = nullptr;
+
    TCanvas*  fcMsSizeAll;
    TH1*      fhMsSz[kiMaxNbFlibLinks];
    TProfile* fhMsSzTime[kiMaxNbFlibLinks];
diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorSts.cxx b/fles/mcbm2018/monitor/CbmMcbm2018MonitorSts.cxx
index 718217709a515a4888a3d7c303b454c4ad685d38..0d21f4164d76150963043c1c3a4fb4bf483b6b25 100644
--- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorSts.cxx
+++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorSts.cxx
@@ -353,6 +353,10 @@ Bool_t CbmMcbm2018MonitorSts::InitStsParameters()
       } // for( UInt_t uCrobIdx = 0; uCrobIdx < fUnpackParSts->GetNbCrobsPerDpb(); ++uCrobIdx )
    } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
 
+   if( fbBinningFw )
+      LOG(info) << "Unpacking data in bin sorter FW mode";
+      else LOG(info) << "Unpacking data in full time sorter FW mode (legacy)";
+
    // Internal status initialization
    fvulCurrentTsMsb.resize( fuNrOfDpbs );
    fvuCurrentTsMsbCycle.resize( fuNrOfDpbs );
@@ -971,6 +975,10 @@ void CbmMcbm2018MonitorSts::CreateHistograms()
       } // for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx )
    } // if( kTRUE == fbEnableCheckBugSmx20 )
 ///------------------------------------------------------------------///
+
+   fhMsErrorsEvo = new TH2I( "fhMsErrorsEvo", "; MS index [s]; Error type []; Counts []",
+       600,  0.0,  600.0,
+         4, -0.5,    3.5 );
 ///++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++///
 
    // Miscroslice properties histos
@@ -1039,6 +1047,8 @@ void CbmMcbm2018MonitorSts::CreateHistograms()
             } // if( kTRUE == fbEnableCheckBugSmx20 )
          } // if( kTRUE == fUnpackParSts->IsFebActive( uFebIdx ) )
       } // for( UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx )
+
+      server->Register("/StsRaw", fhMsErrorsEvo );
 /*
       for( UInt_t uModIdx = 0; uModIdx < fuNbModules; ++ uModIdx )
       {
@@ -1893,8 +1903,23 @@ Bool_t CbmMcbm2018MonitorSts::ProcessStsMs( const fles::Timeslice& ts, size_t uM
    if( kFALSE == fvuInitialHeaderDone[ fuCurrDpbIdx ] )
    {
       fvuInitialTsMsbCycleHeader[ fuCurrDpbIdx ] = uTsMsbCycleHeader;
+      fvulCurrentTsMsb[fuCurrDpbIdx] = 0;
       fvuInitialHeaderDone[ fuCurrDpbIdx ] = kTRUE;
    } // if( kFALSE == fvuInitialHeaderDone[ fuCurrDpbIdx ] )
+   else if( 0 == uMsIdx )
+   {
+      if( uTsMsbCycleHeader != fvuCurrentTsMsbCycle[ fuCurrDpbIdx ] )
+         LOG(info) << " TS " << std::setw( 12 ) << fulCurrentTsIdx
+                   << " MS " << std::setw( 12 ) << fulCurrentMsIdx
+                   << " MS Idx " << std::setw( 4 ) << uMsIdx
+                   << " Msg Idx " << std::setw( 5 ) << 0
+                   << " DPB " << std::setw( 2 ) << fuCurrDpbIdx
+                   << " Old TsMsb " << std::setw( 5 ) << fvulCurrentTsMsb[fuCurrDpbIdx]
+                   << " Old MsbCy " << std::setw( 5 ) << fvuCurrentTsMsbCycle[fuCurrDpbIdx]
+                   << " New MsbCy " << uTsMsbCycleHeader;
+      fvuCurrentTsMsbCycle[ fuCurrDpbIdx ] = uTsMsbCycleHeader;
+      fvulCurrentTsMsb[fuCurrDpbIdx] = 0;
+   } // if( 0 == uMsIdx )
    else if( uTsMsbCycleHeader != fvuCurrentTsMsbCycle[ fuCurrDpbIdx ] &&
             4194303 != fvulCurrentTsMsb[fuCurrDpbIdx] )
    {
@@ -1906,6 +1931,30 @@ Bool_t CbmMcbm2018MonitorSts::ProcessStsMs( const fles::Timeslice& ts, size_t uM
                     << " VS " << uTsMsbCycleHeader;
       fvuCurrentTsMsbCycle[ fuCurrDpbIdx ] = uTsMsbCycleHeader;
    }
+   else if( uTsMsbCycleHeader != fvuCurrentTsMsbCycle[ fuCurrDpbIdx ] )
+   {
+      if( 4194303 == fvulCurrentTsMsb[fuCurrDpbIdx] )
+      {
+         LOG(info) << " TS " << std::setw( 12 ) << fulCurrentTsIdx
+                   << " MS " << std::setw( 12 ) << fulCurrentMsIdx
+                   << " MS Idx " << std::setw( 4 ) << uMsIdx
+                   << " Msg Idx " << std::setw( 5 ) << 0
+                   << " DPB " << std::setw( 2 ) << fuCurrDpbIdx
+                   << " Old TsMsb " << std::setw( 5 ) << fvulCurrentTsMsb[fuCurrDpbIdx]
+                   << " Old MsbCy " << std::setw( 5 ) << fvuCurrentTsMsbCycle[fuCurrDpbIdx]
+                   << " New MsbCy " << uTsMsbCycleHeader;
+      }
+         else
+         {
+            LOG(warning) << "TS MSB cycle from MS header does not match current cycle from data "
+                          << "for TS " << std::setw( 12 ) << fulCurrentTsIdx
+                          << " MS " << std::setw( 12 ) << fulCurrentMsIdx
+                          << " MsInTs " << std::setw( 3 ) << uMsIdx
+                          << " ====> " << fvuCurrentTsMsbCycle[ fuCurrDpbIdx ]
+                          << " (cnt) VS " << uTsMsbCycleHeader << " (header)";
+         } // else of if( 4194303 == fvulCurrentTsMsb[fuCurrDpbIdx] )
+      fvuCurrentTsMsbCycle[ fuCurrDpbIdx ] = uTsMsbCycleHeader;
+   } // else if( uTsMsbCycleHeader != fvuCurrentTsMsbCycle[ fuCurrDpbIdx ] )
 
    // If not integer number of message in input buffer, print warning/error
    if( 0 != ( uSize % kuBytesPerMessage ) )
@@ -1947,6 +1996,10 @@ Bool_t CbmMcbm2018MonitorSts::ProcessStsMs( const fles::Timeslice& ts, size_t uM
          {
             // Extract the eLink and Asic indices => Should GO IN the fill method now that obly hits are link/asic specific!
             UShort_t usElinkIdx = mess.GetLinkIndex();
+            /// => Quick and dirty hack for binning FW!!!
+            if( kTRUE == fbBinningFw )
+               usElinkIdx = mess.GetLinkIndexHitBinning();
+
             fhStsMessTypePerElink->Fill( fuCurrDpbIdx * fUnpackParSts->GetNbElinkPerDpb() + usElinkIdx,
                                          static_cast< uint16_t > (typeMess) );
             fhStsHitsElinkPerDpb->Fill( fuCurrDpbIdx, usElinkIdx );
@@ -2031,6 +2084,20 @@ Bool_t CbmMcbm2018MonitorSts::ProcessStsMs( const fles::Timeslice& ts, size_t uM
 //                   FillTsMsbInfo( mess );
             break;
          } // case stsxyter::MessType::Empty :
+         case stsxyter::MessType::EndOfMs :
+         {
+//            ++vNbMessType[5];
+//            sMessPatt += " En";
+//            bError = pMess[uIdx].IsMsErrorFlagOn();
+
+//            fhStsMessTypePerElink->Fill( fuCurrDpbIdx * fUnpackPar->GetNbElinkPerDpb(), static_cast< uint16_t > (typeMess) );
+//                   FillTsMsbInfo( pMess[uIdx] );
+            if( mess.IsMsErrorFlagOn() )
+            {
+               fhMsErrorsEvo->Fill( 1e-9 * fulCurrentMsIdx, mess.GetMsErrorType() );
+            } // if( pMess[uIdx].IsMsErrorFlagOn() )
+            break;
+         } // case stsxyter::MessType::EndOfMs :
          case stsxyter::MessType::Dummy :
          {
             fhStsMessTypePerElink->Fill( fuCurrDpbIdx * fUnpackParSts->GetNbElinkPerDpb(), static_cast< uint16_t > (typeMess) );
@@ -2269,7 +2336,11 @@ void CbmMcbm2018MonitorSts::FillTsMsbInfo( stsxyter::Message mess, UInt_t uMessI
    } // if( uVal < fvulCurrentTsMsb[fuCurrDpbIdx] )
    if( uVal != fvulCurrentTsMsb[fuCurrDpbIdx] + 1 &&
        0 != uVal && 4194303 != fvulCurrentTsMsb[fuCurrDpbIdx] &&
-       1 != uMessIdx )
+       1 != uMessIdx && /// First TS_MSB in MS may jump if TS dropped by DAQ
+       !( 0 == uVal && 0 == fvulCurrentTsMsb[fuCurrDpbIdx] && 2 == uMessIdx ) && /// case with cycle et edge of 2 MS
+       !( uVal == fvulCurrentTsMsb[fuCurrDpbIdx] && 2 == uMessIdx ) && /// Msg 1 and 2 will be same TS_MSB if data in 1st bin
+       uVal < fvulCurrentTsMsb[fuCurrDpbIdx]  /// New FW introduced TS_MSB suppression + large TS_MSB => warning only if value not increasing
+     )
    {
       LOG(info) << "TS MSb Jump in "
                 << " TS " << std::setw( 12 ) << fulCurrentTsIdx
diff --git a/fles/mcbm2018/monitor/CbmMcbm2018MonitorSts.h b/fles/mcbm2018/monitor/CbmMcbm2018MonitorSts.h
index 91d96e6ccff90a8e99847edcccbdf5ef97eeead4..e0ef8878165c256d06ba7154ea977dfb21aab2a2 100644
--- a/fles/mcbm2018/monitor/CbmMcbm2018MonitorSts.h
+++ b/fles/mcbm2018/monitor/CbmMcbm2018MonitorSts.h
@@ -264,6 +264,9 @@ private:
    std::vector< TProfile *>   fhStsFebSmxErrRatioCopySameAdcEvo;
    std::vector< TProfile2D *> fhStsFebSmxErrRatioCopySameAdcEvoAsic;
 
+   /// Binning FW error flag
+   TH2* fhMsErrorsEvo = nullptr;
+
       /// Canvases
    std::vector< TCanvas * > fvcStsSumm;
    std::vector< TCanvas * > fvcStsSmxErr;
diff --git a/fles/mcbm2018/parameter/CbmMcbm2018PsdPar.cxx b/fles/mcbm2018/parameter/CbmMcbm2018PsdPar.cxx
index d6a10c0f5d5a51a5be3fef31e0602bc1a62068d2..2cff87afd2b6729d89ad06da05f979b8661df091 100644
--- a/fles/mcbm2018/parameter/CbmMcbm2018PsdPar.cxx
+++ b/fles/mcbm2018/parameter/CbmMcbm2018PsdPar.cxx
@@ -30,9 +30,6 @@ CbmMcbm2018PsdPar::CbmMcbm2018PsdPar(const char* name,
     fiNbMsTot(0),
     fiNbMsOverlap(0),
     fdSizeMsInNs(0.0),
-    fdStarTriggerDeadtime(),
-    fdStarTriggerDelay(),
-    fdStarTriggerWinSize(),
     fdTsDeadtimePeriod(0.0)
 {
    detName="Psd";
@@ -71,9 +68,6 @@ void CbmMcbm2018PsdPar::putParams(FairParamList* l)
    l->add("NbMsTot",             fiNbMsTot);
    l->add("NbMsOverlap",         fiNbMsOverlap);
    l->add("SizeMsInNs",          fdSizeMsInNs);
-   l->add("StarTriggerDeadtime", fdStarTriggerDeadtime);
-   l->add("StarTriggerDelay",    fdStarTriggerDelay);
-   l->add("StarTriggerWinSize",  fdStarTriggerWinSize);
    l->add("TsDeadtimePeriod",    fdTsDeadtimePeriod);
 }
 
@@ -103,12 +97,6 @@ Bool_t CbmMcbm2018PsdPar::getParams(FairParamList* l) {
    if ( ! l->fill("NbMsOverlap", &fiNbMsOverlap) ) return kFALSE;
    if ( ! l->fill("SizeMsInNs",  &fdSizeMsInNs) ) return kFALSE;
 
-   fdStarTriggerDeadtime.Set(fiNrOfGdpb);
-   fdStarTriggerDelay.Set(fiNrOfGdpb);
-   fdStarTriggerWinSize.Set(fiNrOfGdpb);
-   if ( ! l->fill("StarTriggerDeadtime", &fdStarTriggerDeadtime) ) return kFALSE;
-   if ( ! l->fill("StarTriggerDelay",    &fdStarTriggerDelay) ) return kFALSE;
-   if ( ! l->fill("StarTriggerWinSize",  &fdStarTriggerWinSize) ) return kFALSE;
    if ( ! l->fill("TsDeadtimePeriod",  &fdTsDeadtimePeriod) ) return kFALSE;
 
    return kTRUE;
diff --git a/fles/mcbm2018/parameter/CbmMcbm2018PsdPar.h b/fles/mcbm2018/parameter/CbmMcbm2018PsdPar.h
index 5c5d1f74297b328f3f83b140d708406dd2728012..cc336d8ae5ed4fd247688bd3254b5d6777ead044 100644
--- a/fles/mcbm2018/parameter/CbmMcbm2018PsdPar.h
+++ b/fles/mcbm2018/parameter/CbmMcbm2018PsdPar.h
@@ -63,9 +63,6 @@ class CbmMcbm2018PsdPar : public FairParGenericSet
    inline Int_t    GetNbMsOverlap() { return fiNbMsOverlap;}
    inline Double_t GetSizeMsInNs() { return fdSizeMsInNs;}
 
-   Double_t GetStarTriggDeadtime( UInt_t uGdpb );
-   Double_t GetStarTriggDelay( UInt_t uGdpb );
-   Double_t GetStarTriggWinSize( UInt_t uGdpb );
    Double_t GetTsDeadtimePeriod();// { return fdTsDeadtimePeriod;}
 
 
@@ -101,9 +98,6 @@ class CbmMcbm2018PsdPar : public FairParGenericSet
    Int_t    fiNbMsOverlap; // Number of overlap MS per TS
    Double_t fdSizeMsInNs; // Size of the MS in ns, needed for MS border detection
 
-   TArrayD  fdStarTriggerDeadtime; // STAR: Array to hold for each gDPB the deadtime between triggers in ns
-   TArrayD  fdStarTriggerDelay; // STAR: Array to hold for each gDPB the Delay in ns to subtract when looking for beginning of coincidence of data with trigger window
-   TArrayD  fdStarTriggerWinSize; // STAR: Array to hold for each gDPB the Size of the trigger window in ns
    Double_t fdTsDeadtimePeriod; // Period (ns) in the first MS of each TS where events with missing triggers should be built using the overlap MS of previous TS (overlap events)
 
    ClassDef(CbmMcbm2018PsdPar,1);