diff --git a/src/RdhUtils.cxx b/src/RdhUtils.cxx
index 1d7aba69..6363aa58 100644
--- a/src/RdhUtils.cxx
+++ b/src/RdhUtils.cxx
@@ -9,10 +9,12 @@ RdhHandle::~RdhHandle(){
 void RdhHandle::dumpRdh() {
   printf("RDH @ 0x%p\n",(void *)rdhPtr);
   printf("Version       = 0x%02X\n",(int)getHeaderVersion());
-  printf("Block length  = %d bytes\n",(int)getBlockLength());
+  printf("Header size   = %d\n",(int)getHeaderSize());
+  printf("Block length (link) = %d bytes\n",(int)getBlockLength());
+  printf("Block length (memory) = %d bytes\n",(int)getMemorySize());
   printf("FEE Id        = %d\n",(int)getFeeId());
   printf("Link Id       = %d\n",(int)getLinkId());
-  printf("Header size   = %d\n",(int)getHeaderSize());
+  printf("Next block    = %d\n",(int)getOffsetNextPacket());
   //printf("%04X %04X %04X %04X\n",rdhPtr->word3,rdhPtr->word2,rdhPtr->word1,rdhPtr->word0);
 }
 
@@ -42,3 +44,69 @@ int RdhHandle::validateRdh(std::string &err) {
   // check FEE Id ?  
   return retCode;
 }
+
+
+RdhBlockHandle::RdhBlockHandle(void *ptr, size_t size) : blockPtr(ptr), blockSize(size) {
+}
+
+RdhBlockHandle::~RdhBlockHandle() {
+}
+
+int RdhBlockHandle::printSummary() {
+  printf("\n\n************************\n");
+  printf("Start of page %p (%d bytes)\n\n",blockPtr,blockSize);
+  
+  // intialize start of block
+  uint8_t *ptr=(uint8_t *)(blockPtr);
+  size_t bytesLeft=blockSize;
+  
+  int rdhcount=0;
+  
+  for (;;) {
+ 
+    // check enough space for RDH
+    if (bytesLeft<sizeof(o2::Header::RAWDataHeader)) {
+      printf("page too small, %d bytes left! need at least %d bytes for RDH\n",bytesLeft,(int)sizeof(o2::Header::RAWDataHeader));
+      return -1;
+    }
+
+    rdhcount++;
+    int offset=ptr-(uint8_t*)blockPtr;
+    printf("*** RDH #%d @ 0x%04X = %d\n",rdhcount,offset,offset);
+
+    // print raw bytes
+    //printf("Raw bytes dump (32-bit words):\n");
+    for (int i=0;i<sizeof(o2::Header::RAWDataHeader)/sizeof(int32_t);i++) {
+      if (i%8==0) {printf("\n");}
+      printf("%08X ",(int)(((uint32_t*)ptr)[i]));
+    }  
+    printf("\n\n");
+
+    RdhHandle rdh(ptr);
+    rdh.dumpRdh();
+    printf("\n");
+
+    int next=rdh.getOffsetNextPacket(); // next RDH
+    if (next==0) {
+      break;
+    }
+    
+    // check enough space to go to next offset
+    if (bytesLeft<next) {
+      printf("page too small, %d bytes left! need at least %d bytes for next offset\n",bytesLeft,(int)rdh.getOffsetNextPacket());
+      return -1;     
+    }
+    
+
+    bytesLeft-=next;
+    ptr+=next;
+    if (bytesLeft==0) {
+      break;
+    }
+  }
+  
+  printf("End of page %p (%d bytes)",blockPtr,blockSize);
+  printf("\n************************\n\n");
+    
+  return 0;
+}
diff --git a/src/RdhUtils.h b/src/RdhUtils.h
index 960cddf9..79c037aa 100644
--- a/src/RdhUtils.h
+++ b/src/RdhUtils.h
@@ -41,8 +41,35 @@ class RdhHandle {
   }
   inline uint32_t getHbOrbit() {
     return (uint32_t) rdhPtr->heartbeatOrbit;
-  }  
-  
+  }
+  inline uint16_t getMemorySize() {
+    return (uint16_t) rdhPtr->memorySize;
+  }
+  inline uint16_t getOffsetNextPacket() {
+    return (uint16_t) rdhPtr->offsetNextPacket;
+  }
+  inline bool getStopBit() {
+    return (bool) rdhPtr->stopBit;
+  }
   private:
   o2::Header::RAWDataHeader *rdhPtr;  // pointer to RDH in memory
 };
+
+
+// Utility class to access/parse/check the content of a contiguous memory block consisting of RDH+data
+class RdhBlockHandle {
+  public:
+  // create a handle to the block, providing pointer and size
+  RdhBlockHandle(void *blockPtr, size_t size);
+
+  // destructor
+  ~RdhBlockHandle();
+  
+  // print summary
+  // return 0 on success, an error code if the block is invalid
+  int printSummary();
+  
+  private:
+  void *blockPtr; // pointer to beginning of memory block
+  size_t blockSize; // size of memory block
+};
diff --git a/src/ReadoutEquipmentRORC.cxx b/src/ReadoutEquipmentRORC.cxx
index 87ecb407..b00c0e2e 100644
--- a/src/ReadoutEquipmentRORC.cxx
+++ b/src/ReadoutEquipmentRORC.cxx
@@ -362,6 +362,15 @@ DataBlockContainerReference ReadoutEquipmentRORC::getNextBlock() {
         // checks to do:
         // - HB clock consistent in all RDHs
         // - increasing counters
+	if (cfgRdhDumpEnabled) {
+	  RdhBlockHandle b(d->getData()->data,d->getData()->header.dataSize);
+	  if (b.printSummary()) {
+	    printf("errors detected, suspending RDH dump\n");
+	    cfgRdhDumpEnabled=0;
+	  } else {
+  	    cfgRdhDumpEnabled++; //if value positive, it continues... but negative, it stops on zero, to limit number of dumps
+	  }
+	}
 
         if (cfgRdhCheckEnabled) {
           std::string errorDescription;