---

/var/pcce/usera/hill/rcc_1.2/RodDaq/RodCrate/RodModule.cxx

Go to the documentation of this file.

//File: RodModule.cxx
// $Header: /afs/cern.ch/user/s/sctpixel/private/cvsroot/RodDaq/RodCrate/RodModule.cxx,v 1.7 2002/12/19 16:22:25 tmeyer Exp $

#include "RodModule.h"

//! Namespace for the common routines for SCT and PIXEL ROD software. 
namespace SctPixelRod {

// Flag to force endian-ness swap before calls to HPI registers.  This should be
// a temporary patch.
// JCH 7 Jan 2003. Change swap from 1 to 0.
static long endianSwap = 0;
static const long rodInitTimeout = 1;

//******************************Class HpiException**************************
//
// Description:
//  This class is thrown if an error in an HPI read/write operation is detected.
//   
//  Author(s):
//    Tom Meyer (meyer@iastate.edu) - originator

//      Constructors. Use defaults for destructor, copy, and assignment.

HpiException::HpiException( std::string descriptor, unsigned long calcAddr,
                            unsigned long readAddr) {
  m_descriptor = descriptor;
  m_calcAddr = calcAddr;
  m_readAddr = readAddr;
  }
  
//***************************Class RodException**************************
//
// Description:
//  This class is thrown if an error in a ROD operation is detected.
//   
//  Author(s):
//    Tom Meyer (meyer@iastate.edu) - originator

//      Constructors. Use defaults for destructor, copy, and assignment.

RodException::RodException( std::string descriptor) {
  m_descriptor = descriptor;
  m_numData = 0;
  m_data1 = m_data2 = 0;
  }
RodException::RodException( std::string descriptor, unsigned long data1) {
  m_descriptor = descriptor;
  m_numData = 1;
  m_data1 = data1;
  m_data2 = 0;
  }
RodException::RodException( std::string descriptor, unsigned long data1,
                            unsigned long data2) {
  m_descriptor = descriptor;
  m_numData = 2;
  m_data1 = data1;
  m_data2 = data2;
  }
  
//********************************Class RodModule***************************
//
// Description:
//  This is a derived class providing the software interface for VME ROD modules.
//   
//  Author(s):
//    Tom Meyer (meyer@iastate.edu) - originator

//---------------------------------Constructor------------------------------                                    
/*
This is the only constructor to use.
*/

RodModule::RodModule( unsigned long baseAddr, unsigned long mapSize, 
     VmeInterface & ourInterface, long numSlaves) throw (RodException&,
     VmeException&) :
     VmeModule(baseAddr, mapSize, ourInterface) {
  m_slot = baseAddr>>24;
  m_serialNumber = 0xFFFFFFFF;  // Will be overwritten during init
  m_numSlaves = numSlaves; 
  m_finBufferSize = 4096; 
  m_masterImageName = std::string("");
  try {
    m_myVmePort = new VmePort(m_baseAddress, m_mapSize, VmeInterface::A32, 
                  m_ourInterface); 
  }
  catch (std::bad_alloc & ba) {
    throw RodException("Failed to get VME Port.");
  }
  for (long i=0; i<4; i++) {
    m_slaveEmifName[i]= std::string("");
    m_slaveIpramName[i]= std::string("");
    m_slaveIdramName[i]= std::string("");
    m_slaveExtName[i]= std::string("");
  }
  for (long i=0; i<N_TXT_BUFFS; i++) {
    m_textBuff[i] = 0;
  };
  m_myTextState = TEXT_IDLE;
  m_myPrimState = PRIM_IDLE;
  m_textType = TEXT_UNDEF;
}

//---------------------------------Destructor------------------------------                                    
/*
Be sure to delete all VME Ports.
*/

RodModule::~RodModule() {
  delete(m_myVmePort);
  m_myVmePort = 0;
  return;
}

//  Member methods

//--------------------------------initialize---------------------------------                                 

/* This method performs all actions necessary to place a properly loaded ROD 
in its initialized state, except for initializing the slave DSPs. This must be done
separately using initSlaveDsp().

Activities:
    Reset the ROD
    Read ROD serial number
    Load 0x000l000l into Master DSP HPIC register. (Says low order 16-bit word
                                                    comes first)
    Read back HPIC to verify
    Retrieve pointers to text buffer structs
    Initialize PrimList and TextBuff state variables
*/
void RodModule::initialize() throw (RodException &, VmeException &) {

  unsigned long hpicReadback;   // for debugging
  const unsigned long rodResetValue = 0x000000c0;
  unsigned long rodReset;
  unsigned long rodRegValue;
  
// Reset the ROD so it starts in a known state
  rodRegValue = readRodStatusReg(0);
  if (endianSwap) {
    rodReset = endianReverse32(rodResetValue);
  }
  else {
    rodReset = rodResetValue;
  }
  m_myVmePort->write32(FPGA_CONTROL_REG_REL_ADDR[2], rodReset);
  sleep(1000);
  rodRegValue = readRodStatusReg(0);

// Read ROD serial number 
  m_serialNumber = m_myVmePort->read32(FPGA_STATUS_REG_REL_ADDR[6]);
  if (endianSwap) m_serialNumber = endianReverse32(m_serialNumber); // Temporary (I hope)
  m_serialNumber = m_serialNumber & 0x3ff;   // Mask to get 10 least significant bits
   
//      Initialize Master HPIC register to set half-word order

  unsigned long hpicValue = 0x00010001;

  hpiLoad(HPIC, hpicValue);
  hpicReadback = hpiFetch(HPIC);         // for debugging
  sleep(100);

// Wait for MasterDSP init
  for (long i=0; ; ++i) {
    if (readRodStatusBit(0, SR_RUNNING)) {
      break;
    }
    if (i>rodInitTimeout*10) throw RodException("Master DSP init timed out. Tries, Limit:", i,
        rodInitTimeout);
    sleep(100);
  }

  for (int i=0; i< N_TXT_BUFFS; i++) {
    m_textBuff[i] = (unsigned long *)mdspSingleRead(REPLY_BUFF_BASE + 4*i);
  }

//  Reinitialize state variables
  m_myTextState = TEXT_IDLE;
  m_myPrimState = PRIM_IDLE;

return;
}

//---------------------------------reset------------------------------------                                

/* This method resets the ROD.
*/

void RodModule::reset() throw (RodException&, VmeException &) {
  // Reset all FPGAs and DSPs (bit 7 = 0x80)
  const unsigned long rodResetValue = 0x000000c0;
  unsigned long rodReset;
  
  if (endianSwap) {
    rodReset = endianReverse32(rodResetValue);
  }
  else {
    rodReset = rodResetValue;
  }
  m_myVmePort->write32(FPGA_CONTROL_REG_REL_ADDR[2], rodReset);
  sleep(10000);
   
  // Clear IDRAM
  unsigned long * buff;
  try {
    buff = new unsigned long[IDRAM_SZ/sizeof(long)]={0};//Allocate a buffer of zeros
  }
  catch (std::bad_alloc & ba) {
    throw RodException("Reset() failed to allocate buffer. Size=",
                                  IDRAM_SZ/sizeof(long));
  }
  mdspBlockWrite(IDRAM_BASE, buff, IDRAM_SZ/sizeof(long));
  delete buff;
  
  // Reset all DSPs
  resetMasterDsp();
  sleep(50);
  for (long i=0; i<m_numSlaves; i++) {
    resetSlaveDsp(i);
    sleep(50);
  };
  
  //  Reinitialize state variables
  m_myTextState = TEXT_IDLE;
  m_myPrimState = PRIM_IDLE;
  
return;
}

//---------------------------------status-----------------------------------                                

/* This method reports the status of the ROD.
For now, it simply prints to standard output.
*/
void RodModule::status() throw() {
    cout << "Slot: " << m_slot;
    cout << "Serial Number:" << m_serialNumber;
    cout << "Number of slave DSPs: " << m_numSlaves;
    cout << endl;
    hex(cout);
    cout << "Status registers[0-2]: ";
    try {
      for (int i=0; i<3; i++) {
        cout << readRodStatusReg(i) << " " ;
      }
    }
    catch (VmeException &) {
      cout << "status() can read ROD status registers." << flush;
    }
    cout << endl;
    
    cout << "Command registers[0-1]: ";
    try {
      for (int i=0; i<2; i++) {
        cout << readRodCommandReg(i) << " " ;
      }
    }
    catch (VmeException &) {
      cout << "status() can read ROD command registers." << flush;
    }

    dec(cout);
    cout << "Primitive state: " << getPrimState() << " Text State: " << 
          getTextState();
    cout << endl;
return;
}

//--------------------------------initSlaveDsp-------------------------------                       
void RodModule::initSlaveDsp(const std::string & emifFile, const std::string & ipramFile,
     const std::string & idramFile,const std::string & extFile,
     const long slaveNumber) throw (RodException&, NoImageFile&, VmeException &) {

  unsigned long readBack;
  unsigned long hpicValue = 0x00010001;
 
  if ((slaveNumber < 0) || (slaveNumber >= m_numSlaves)) throw RodException(
       "Slave Number out of Range. slaveNumber, m_numSlaves:", slaveNumber, 
       m_numSlaves);
      
// Set HPIC registers to make first halfword the most significant
  slvHpiLoad(SLAVE_HPIC_BASE, hpicValue, slaveNumber);
  readBack = slvHpiFetch(SLAVE_HPIC_BASE, slaveNumber);
  
// Load the memory images and remember the file names
  loadSlaveImage(emifFile, SLAVE_EMIF_ADDR, slaveNumber);
  m_slaveEmifName[slaveNumber] = emifFile;
  loadSlaveImage(ipramFile, SLAVE_IPRAM_ADDR, slaveNumber);
  m_slaveIpramName[slaveNumber] = ipramFile;
  loadSlaveImage(idramFile, SLAVE_IDRAM_ADDR, slaveNumber);
  m_slaveIdramName[slaveNumber] = idramFile;
  loadSlaveImage(extFile, SLAVE_CE2_ADDR, slaveNumber);
  m_slaveExtName[slaveNumber] = extFile;
  
// Send the START_SLAVE_EXECUTING primitive. Do the primList dialog synchronously
  startSlave(slaveNumber);
  return;
}


//--------------------------------loadSlaveImage-------------------------------                       
void RodModule::loadSlaveImage(const std::string & fileName, const unsigned long address,
     const long slaveNum, char opt='n') throw (NoImageFile&, RodException&, 
                                               VmeException &) {
  
  long numWords;   
  int fileSize;
  ifstream fin;
  fin.open(fileName.c_str(),ios::binary);
  if (fin.is_open()) {
  
// Get size of file
    fin.seekg(0, ios::end);  // go to end of file
    fileSize = fin.tellg();  // file size is current location
    fin.seekg(0, ios::beg);  // go back to beginning of file
    
// Create buffer and fill it with file contents
    char * buffer; 
    try {
      buffer = new char[fileSize];
    }
    catch (std::bad_alloc & ba) {
      throw RodException(
                  "loadSlaveImage buffer failed to allocate. buffer, fileSize:",
                  (unsigned long)buffer, (unsigned long)fileSize);
    }
    fin.read(buffer, fileSize);

// Use slvBlockWrite to transfer buffer into memory
    numWords = (fileSize+3)/4;
    slvBlockWrite(address, (unsigned long*) buffer, numWords, slaveNum);
    
// Read back buffer for verification if 'v' option was given
    if (opt=='v') {
      char* buffer2;
      try {
        buffer2 = new char[fileSize];
      }
      catch (std::bad_alloc & ba) {
        throw RodException(
                  "loadSlaveImage buffer2 failed to allocate. buffer, fileSize:",
                  (unsigned long)buffer, (unsigned long)fileSize);
      }
      slvBlockRead(address, (unsigned long*)buffer2, numWords, slaveNum);
   
      for (int i=0; i<fileSize; i++) {
        if (buffer[i] != buffer2[i]) {
          delete [] buffer;
          delete [] buffer2;
          fin.close();
          char message[] = "loadSlaveImage buffer readback invalid for file, slavenum, index: ";
          throw RodException( *message+fileName.c_str(), slaveNum, i);
        }
      } 
    }
    
// Close the file and delete the buffer    
    fin.close();
    delete [] buffer;
  }
  else {
    throw NoImageFile(fileName);
  }
  return;
}

//--------------------------------startSlave-------------------------------                       
// Starts slave executing
// The default way is to have the master DSP run the START_SLAVE_EXECUTING
// primitive. This is what should normally be used.
// A quick "back door" way is to set the slave's DSPINT bit directly.

void RodModule::startSlave(const long slaveNumber, char mode='s') 
                                            throw(VmeException &) {
  const unsigned long dspint = 0x2;

  if (mode == 'q') {             // The quick way: just set DSPINT directly
    slvHpiLoad(SLAVE_HPIC_BASE, dspint, slaveNumber);
  }

  else {                         // The slow way, a master primitive (default)
  long primData[4]={slaveNumber, 1, 2, 0x200000};
  RodPrimitive * startSlaveExec;
  try {
    startSlaveExec = new RodPrimitive(8, 1, START_SLAVE_EXECUTING, 
       R_START_SLAVE_EXECUTING, primData);
  }
  catch (std::bad_alloc & ba) {
    throw RodException(
      "startSlave unable to allocate startSlaveExec. slaveNumber:", slaveNumber); 
  }
  synchSendPrim(*startSlaveExec); 
  delete startSlaveExec;
  }
  
  return;
}

/*---------------------------------synchSendPrim------------------------------                           
This version writes to cout. This needs to be changed.
*/
void RodModule::synchSendPrim(RodPrimitive & prim) throw (RodException&, 
                                                         VmeException &) {
  RodPrimList primList(1);  // Private primList (local to this routine)
  long myTextLength;                            // Actual length of text message
  TEXT_BUFFER_TYPE myTextType;                  // Buffer type for latest message
  PrimState returnPState;
  TextBuffState returnTState;

// Create a text buffer in case of error message
    char * myTextBuffer;
    try {
      myTextBuffer = new char[TEXT_BUFF_SIZE];
    }
    catch (std::bad_alloc & ba) {
      throw RodException(
          "synchSendPrim failed to allocate text. Size=", TEXT_BUFF_SIZE);
    }
    primList.insert(primList.begin(), prim);
    try {
      primList.bufferBuild();
    }
    catch (PrimListException &p) {
//      throw (RodException(p.getDescriptor,p.getData1(), p.getData2());
      cout << p.getDescriptor() << " ";
      cout << p.getData1() << ", " << p.getData2() << "\n";
    };
    try {
      this->sendPrimList(&primList);
    }
    catch (HpiException &h) {
      hex(cout);
//      throw (RodException(h.getDescriptor,h.getCalcAddr1(), h.getReadAddr());
      cout << h.getDescriptor() << '\n';
      cout << "calcAddr: " << h.getCalcAddr() << ", readAddr: " << 
              h.getReadAddr() << '\n';
      dec(cout);
    };

// Wait for ROD to begin executing and then wait for it to finish executing
// Check for error messages in text buffer and read them out if they exist.
// Note: this is the synchronous way to do it. In general, it is better to do it
// asynchronously.
    do {
      returnPState = this->primHandler();
      returnTState = this->textHandler();
      if (returnTState == TEXT_RQ_SET) {
        do {
          returnTState = this->textHandler();
        } while (returnTState != TEXT_READOUT);
        this->getTextBuffer(myTextBuffer, myTextLength, myTextType);
        this->clearTextBuffer();
        for (int i=0; i<myTextLength; i++) {
          cout << myTextBuffer[i];
          if (0==(i+1)%64) cout << endl;
          }
        cout << endl; 
      }
    } while (returnPState != PRIM_EXECUTING); 
    do {
       try {
         returnPState = this->primHandler();
       }
       catch (RodException &r) {
       cout << r.getDescriptor() <<", " << r.getData1() << ", " << r.getData2()
               << '\n';
       }
    } while (returnPState != PRIM_WAITING); 
    delete myTextBuffer;

  return;
}
  
//---------------------------------sendPrimList-------------------------------                           

void RodModule::sendPrimList(RodPrimList *l) throw(VmeException &) {

  unsigned long * buffAddr;
  long buffCount;

  if (!l->getBuffer()) {
    l->bufferBuild();
  };
  buffCount = l->numWords();
  buffAddr = l->getBuffer();
  mdspBlockWrite(PRIM_BUFF_BASE, buffAddr, buffCount);
  m_myPrimState = PRIM_LOADED;

  return;  
}  

//---------------------------------primHandler-------------------------------                           

PrimState RodModule::primHandler() throw(RodException &, VmeException &) {
long wordCount;
unsigned long status;
unsigned long* buffptr;
unsigned long replyBuffer;
  switch (m_myPrimState) {
    case PRIM_LOADED: {
      if (0==getDspAck()) {
        setInListReady();
        m_myPrimState = PRIM_EXECUTING;
      };
    break;
    };
    case PRIM_EXECUTING: {
      status = readRodStatusReg(0);
      if (1==getDspAck()) {
        if (status >> TEXT_BUFF_NOT_EMPTY[0]) {
//        throw RodException ("Error buffer not empty in primHandler(PRIM_EXECUTING)");
        }
        if (1==readRodStatusBit(0,OUTLIST_READY)) {
          // read buffer size
          hpiLoad(HPIA, REPLY_BUFF_BASE);
          wordCount = hpiFetch(HPID_NOAUTO);

          // create new OutList object
          RodOutList* outList;
          try {
            outList = new RodOutList(wordCount);
          }
          catch (std::bad_alloc & ba) {
            throw RodException("Outlist creation failed. WordCount=", 
                                              wordCount);
          }
          if (0==outList->getBody()) throw RodException(
                 "Outlist failed to allocate body array.WordCount=", wordCount);
          this->setOutList(outList);
          
          // fill OutList object
          buffptr = m_myOutList->getBody();
          replyBuffer = REPLY_BUFF_BASE;
          mdspBlockRead(replyBuffer, buffptr, wordCount);
          m_myPrimState = PRIM_WAITING;
          
          // clear inListReady bit
          clearVmeCommandRegBit(INLISTRDY);
        }
        else m_myPrimState = PRIM_IDLE;
      }
    break;
    };
    default: {
    break;
    };
  };
  return m_myPrimState;
};

//--------------------------------deleteOutList--------------------------------

  void RodModule::deleteOutList() throw() {
  delete m_myOutList;
  m_myOutList = 0;
  return;
  };

//---------------------------------textHandler-------------------------------                           

TextBuffState RodModule::textHandler() throw(VmeException &) {
  unsigned long regValue;
  unsigned long dataPtr;
  long txtLength, txtLength1, txtLength2, txtWords;
  switch (m_myTextState) {
    case TEXT_IDLE: {
      regValue = readRodStatusReg(0) & SR_TEXT_MASK;
      if (0==regValue) return m_myTextState;         // Quick return if no text
      for (long i=0; i<4; i++) {
        if (regValue & SR_TEXT_BIT_MASK[i]) {
          m_textType = (TEXT_BUFFER_TYPE)i;
        };
        setVmeCommandRegBit(TEXT_BUFF_READ_REQ[m_textType]);
        m_myTextState = TEXT_RQ_SET;
        return m_myTextState;
      }
      break;
    };
    case TEXT_RQ_SET: {
      if (0==readRodStatusReg(0) & SR_TEXT_BIT_MASK[m_textType]) {
        return m_myTextState;
      };
      hpiLoad( HPIA, (unsigned long)m_textBuff[m_textType]);
      m_txtBuffer.dataEnd = hpiFetch(HPID_AUTO);
      m_txtBuffer.readIndx = hpiFetch(HPID_AUTO);
      m_txtBuffer.writeIndx = hpiFetch(HPID_AUTO);
      m_txtBuffer.mode = hpiFetch(HPID_AUTO);
      m_txtBuffer.overwrite = hpiFetch(HPID_AUTO);
      m_txtBuffer.overflow = hpiFetch(HPID_AUTO);
      m_txtBuffer.wrap = hpiFetch(HPID_AUTO);
      m_txtBuffer.occupied = hpiFetch(HPID_AUTO);
      m_txtBuffer.data = (char *)hpiFetch(HPID_AUTO);
      dataPtr = (unsigned long)m_txtBuffer.data;
      
// If there was a wrap-around we need to read two blocks, otherwise only one
      if (m_txtBuffer.readIndx < m_txtBuffer.writeIndx) {           // No wrap
        txtLength = m_txtBuffer.writeIndx - m_txtBuffer.readIndx;
        txtWords = (txtLength+3)/4;     // Convert char count to words
        mdspBlockRead(dataPtr, (unsigned long*)m_textData, txtWords);
      }
      else {                                                         // Wrap
        txtLength1 = TEXT_BUFF_SIZE - m_txtBuffer.readIndx;
        txtWords = (txtLength1+3)/4;
        mdspBlockRead(dataPtr+4*m_txtBuffer.readIndx, (unsigned long*)m_textData, txtWords);
        txtLength2 = m_txtBuffer.writeIndx;
        txtWords = (txtLength2+3)/4;
        mdspBlockRead(dataPtr, (unsigned long*)(m_textData+4*txtLength1), txtWords);
        txtLength = txtLength1 + txtLength2;
      };
      m_myTextState = TEXT_READOUT;
      m_txtBuffer.occupied = txtLength;
      return m_myTextState;
      break;
    };
    default: {
      return m_myTextState;
      break;
    };
  };

  return m_myTextState;
};


//-----------------------------getTextBuffer-------------------------------                                

  void RodModule::getTextBuffer(char * buffer, long & length, 
         TEXT_BUFFER_TYPE & type) throw() {
    length = m_txtBuffer.occupied;
    type = (TEXT_BUFFER_TYPE)m_textType;
    for (int i=0; i<m_txtBuffer.occupied; i++) {
      buffer[i] = m_textData[i];
    };
    return;
  };
  
//--------------------------------clearTextBuffer------------------------------

void RodModule::clearTextBuffer() throw() {
  m_textType = TEXT_UNDEF;
  m_txtBuffer.occupied = 0;
  m_myTextState = TEXT_IDLE;
  return;
};

//----------------------------------hpiLoad------------------------------------                                

void RodModule::hpiLoad(unsigned long hpiReg, unsigned long hpiValue) 
     throw(VmeException &) {

  if (endianSwap) hpiValue = endianReverse32(hpiValue); 
  m_myVmePort->write32(hpiReg, hpiValue);
};

//--------------------------------hpiFetch-------------------------------------                                

unsigned long RodModule::hpiFetch(unsigned long hpiReg) 
              throw(VmeException &){

unsigned long hpiValue;

  hpiValue=m_myVmePort->read32(hpiReg);
  if (endianSwap) hpiValue = endianReverse32(hpiValue);
  
  return hpiValue;
};

//-----------------------------mdspSingleRead---------------------------------                                

unsigned long RodModule::mdspSingleRead(const unsigned long dspAddr) 
              throw(VmeException &) {
  unsigned long value; 

//  Load the DSP address into the HPIA register 
  hpiLoad(HPIA, dspAddr);

//      Do the read 
  value = m_myVmePort->read32(HPID_NOAUTO);
  if (endianSwap) {
    value = endianReverse32(value);
  }
  return value;
};

//------------------------------mdspSingleWrite------------------------------------                                   

void RodModule::mdspSingleWrite(unsigned long dspAddr, unsigned long buffer) 
     throw(VmeException &) { 

//  Load the HPID address into the HPIA register 
  hpiLoad(HPIA, dspAddr);

//      Do the write 
  if (endianSwap) {
      buffer = endianReverse32(buffer);
  }

  m_myVmePort->write32(HPID_NOAUTO, buffer);

  return;
};

//-----------------------------mdspBlockRead---------------------------------                                


void RodModule::mdspBlockRead(const unsigned long dspAddr, unsigned long buffer[],
       const long wordCount, HpidMode mode=DYNAMIC) throw (HpiException &, 
       VmeException &) {
  unsigned long hpidAddr; 
  long myCount, blockWordCount, wordIncr;

// Determine the HPI mode to use.
  switch (mode) {
    case AUTO:
      hpidAddr= HPID_AUTO;
      break;
    case NO_AUTO:
      hpidAddr = HPID_NOAUTO; 
      break;
    case DYNAMIC:
    default:
      if (wordCount == 1){
        hpidAddr = HPID_NOAUTO;
      } 
      else { 
        hpidAddr = HPID_AUTO;
      };
      break;
  };

//  Load the DSP address into the HPIA register 
  hpiLoad(HPIA, dspAddr);

// Check to see that we don't access too large a block. HPID has 20 bits of 
// address space available. MAX_HPID_WORD_ELEMENTS is defined in RodVmeAddresses.h

  if (wordCount>MAX_HPID_WORD_ELEMENTS) {
    blockWordCount = MAX_HPID_WORD_ELEMENTS;
  }     else { 
    blockWordCount = wordCount;
  }

//      Set up the transfer as a series of block transfers 
  for (myCount=wordCount, wordIncr=0; myCount>0;
                    myCount-=blockWordCount, wordIncr+=blockWordCount) {

//      Recheck each block 
    if (wordCount>MAX_HPID_WORD_ELEMENTS) {
      blockWordCount=MAX_HPID_WORD_ELEMENTS;
    }   
    else { 
      blockWordCount = myCount;
    }

//      Do the transfer for this block 
// Block reads seem to have a problem, use single word reads for now.
//    m_myVmePort->blockRead32(hpidAddr, buffer+2*wordIncr, blockWordCount*4);
    for (int i=0; i<blockWordCount; i++) {
      buffer[2*wordIncr+i] = m_myVmePort->read32(hpidAddr);
    }

    if (endianSwap) {
      for (int i=0; i<blockWordCount; i++) {
        buffer[2*wordIncr+i] = endianReverse32(buffer[2*wordIncr+i]);
      }
    }
  }
  return;
};

//------------------------------mdspBlockWrite-----------------------------------  

void RodModule::mdspBlockWrite(unsigned long dspAddr, unsigned long buffer[], 
       long wordCount, HpidMode mode=DYNAMIC) throw (HpiException &, 
       VmeException &) { 

  unsigned long hpidAddr;
  long myCount, blockWordCount, wordIncr;

//  Load the initial dsp address into the HPIA register 
  hpiLoad(HPIA, dspAddr);

// Determine the HPI mode to use.
  switch (mode) {
    case AUTO:
      hpidAddr= HPID_AUTO;
      break;
    case NO_AUTO:
      hpidAddr = HPID_NOAUTO; 
      break;
    case DYNAMIC:
    default:
      if (wordCount == 1){
        hpidAddr = HPID_NOAUTO;
      } 
      else { 
        hpidAddr = HPID_AUTO;
      };
      break;
  };

// Check to see that we don't access too large a block. HPID has 20 bits of 
// address space available. MAX_HPID_WORD_ELEMENTS is defined in vmeAddressMap.h

  if (wordCount>MAX_HPID_WORD_ELEMENTS) {
    blockWordCount = MAX_HPID_WORD_ELEMENTS;
  }     
  else { 
    blockWordCount = wordCount;
  }

//      Set up the transfer as a series of block transfers 
  for (myCount=wordCount, wordIncr=0; myCount>0;
                    myCount-=blockWordCount, wordIncr+=blockWordCount) {

//      Recheck each block 
    if (wordCount>MAX_HPID_WORD_ELEMENTS) {
      blockWordCount=MAX_HPID_WORD_ELEMENTS;
    }   
    else { 
      blockWordCount = myCount;
    }
  
//      Do the transfer for this block 
  if (endianSwap) {
    for (int i=0; i<blockWordCount; i++) {
      buffer[2*wordIncr+i] = endianReverse32(buffer[2*wordIncr+i]);
    }
  }

// blockWrite32 doesn't work reliably and write32 doesn't increment HPIA as it should.
// Use single word writes and manually increment HPIA for now.
//    m_myVmePort->blockWrite32(hpidAddr, &buffer[2*wordIncr], blockWordCount*4);

    for (int i=0; i<blockWordCount; i++) {
      m_myVmePort->write32(hpidAddr, buffer[2*wordIncr+i]);
    }
  }
  return;
};

//-----------------------------mdspBlockDump--------------------------------                                

void RodModule::mdspBlockDump(const unsigned long firstAddress, 
       const unsigned long lastAddress,
       const std::string & fileName) throw(RodException &, VmeException &) {
       
  long numBytes;
  ofstream fout;
  numBytes = lastAddress - firstAddress + 1;
  fout.open(fileName.c_str(), ios::binary);
  if (fout.is_open()) {
    unsigned long * buffer;
    try {
      buffer = new unsigned long[numBytes];
    }
    catch (std::bad_alloc & ba) {
      throw RodException(
       "mdspBlockDump failed to allocate buffer; buffer size in bytes=", numBytes);
    }   
    mdspBlockRead(firstAddress, buffer, numBytes/4);
    fout.write(buffer, numBytes);
    fout.close();
    delete [] buffer;
  }
  else {
    throw RodException("mdspBlockDump failed to open file");
  }
  return;                    
}

//--------------------------------slvHpiLoad-----------------------------------                                

void RodModule::slvHpiLoad(unsigned long hpiReg, unsigned long hpiValue,
                           long slaveNum) throw(VmeException &) {

  unsigned long address;
  address = hpiReg + slaveNum*SLAVE_HPI_OFFSET;
  
  mdspSingleWrite(address, hpiValue);
};

//------------------------------slvHpiFetch------------------------------------

unsigned long RodModule::slvHpiFetch(unsigned long hpiReg, long slaveNum) 
              throw(VmeException &) {

  unsigned long hpiValue;
  unsigned long address;
  address = hpiReg + slaveNum*SLAVE_HPI_OFFSET;
  
    hpiValue=mdspSingleRead(address);

  return hpiValue;
};

//-------------------------------slvSingleRead---------------------------------
unsigned long RodModule::slvSingleRead(unsigned long dspAddr, long slaveNum ) 
              throw(VmeException &) {

  unsigned long slvHpia, slvHpid;
  unsigned long value;
  slvHpia = SLAVE_HPIA_BASE + slaveNum*SLAVE_HPI_OFFSET;
  slvHpid = SLAVE_HPID_NOAUTO_BASE * slaveNum*SLAVE_HPI_OFFSET;

//  Load the DSP address into the HPIA register 
  mdspSingleWrite(slvHpia, dspAddr);

//      Do the read 
  value = mdspSingleRead(slvHpid);

  return value;
};

//------------------------------slvSingleWrite------------------------------------                                   

void RodModule::slvSingleWrite(unsigned long dspAddr, unsigned long buffer, 
                 long slaveNum) throw(VmeException &) { 

  unsigned long slvHpia, slvHpid;
  slvHpia = SLAVE_HPIA_BASE + slaveNum*SLAVE_HPI_OFFSET;
  slvHpid = SLAVE_HPID_NOAUTO_BASE * slaveNum*SLAVE_HPI_OFFSET;

  mdspSingleWrite(slvHpia, dspAddr);

//      Do the write 
  mdspSingleWrite(slvHpid, buffer);

  return;
};

//-----------------------------slvBlockRead---------------------------------                                

void RodModule::slvBlockRead(const unsigned long dspAddr, unsigned long buffer[],
                const long wordCount, long slaveNum, HpidMode mode=DYNAMIC) 
                throw (HpiException &, VmeException &) {
                
  unsigned long hpidAddr, dspAddrLocal, hpiaAfterFetch, hpiaAfterCalc; 
  long myCount, blockWordCount, wordIncr;
  unsigned long slvHpia, slvHpidAuto, slvHpidNoAuto;
  slvHpia = SLAVE_HPIA_BASE + slaveNum*SLAVE_HPI_OFFSET;
  slvHpidAuto = SLAVE_HPID_AUTO_BASE + slaveNum*SLAVE_HPI_OFFSET;
  slvHpidNoAuto = SLAVE_HPID_NOAUTO_BASE + slaveNum*SLAVE_HPI_OFFSET;


// Determine the HPI mode to use.
  switch (mode) {
    case AUTO:
      hpidAddr= slvHpidAuto;
      break;
    case NO_AUTO:
      hpidAddr = slvHpidNoAuto; 
      break;
    case DYNAMIC:
    default:
      if (wordCount == 1){
        hpidAddr = slvHpidNoAuto;
      } 
      else { 
        hpidAddr = slvHpidAuto;
      };
      break;
  };

//  Load the DSP address into the HPIA register 
  mdspSingleWrite(slvHpia, dspAddr);

// Check to see that we don't access too large a block. HPID has 20 bits of 
// address space available. MAX_HPID_WORD_ELEMENTS is defined in RodVmeAddresses.h

  if (wordCount>MAX_HPID_WORD_ELEMENTS) {
    blockWordCount = MAX_HPID_WORD_ELEMENTS;
  }     else { 
    blockWordCount = wordCount;
  }

//      Set up the transfer as a series of block transfers 
  for (myCount=wordCount, wordIncr=0; myCount>0;
                    myCount-=blockWordCount, wordIncr+=blockWordCount) {

//      Recheck each block 
    if (wordCount>MAX_HPID_WORD_ELEMENTS) {
      blockWordCount=MAX_HPID_WORD_ELEMENTS;
    }   
    else { 
      blockWordCount = myCount;
    }

//      Do the transfer for this block 
    dspAddrLocal = dspAddr+ (4*wordIncr);
    mdspBlockRead(hpidAddr, &buffer[2*wordIncr], blockWordCount, NO_AUTO);
  }

//  Check HPID after transfer 
  hpiaAfterFetch = mdspSingleRead(slvHpia);
  if (wordCount == 1) {
    hpiaAfterCalc = dspAddr;
  }     else  {
    hpiaAfterCalc = dspAddr+wordCount*4;
  }
/*  if (hpiaAfterFetch != hpiaAfterCalc) {
    throw HpiException("mslvBlockRead address check failed", hpiaAfterCalc, 
                       hpiaAfterFetch);
  }
*/
  return;
};

//------------------------------slvBlockWrite-----------------------------------  

void RodModule::slvBlockWrite(unsigned long dspAddr, unsigned long buffer[], 
         long wordCount, long slaveNum, HpidMode mode=DYNAMIC) 
         throw (HpiException &, VmeException &) { 

  unsigned long hpidAddr, dspAddrLocal, hpiaAfterFetch, hpiaAfterCalc;
  long myCount, blockWordCount, wordIncr;
  unsigned long slvHpia, slvHpidAuto, slvHpidNoAuto;
  slvHpia = SLAVE_HPIA_BASE + slaveNum*SLAVE_HPI_OFFSET;
  slvHpidAuto = SLAVE_HPID_AUTO_BASE + slaveNum*SLAVE_HPI_OFFSET;
  slvHpidNoAuto = SLAVE_HPID_NOAUTO_BASE + slaveNum*SLAVE_HPI_OFFSET;

//  Load the initial dsp address into the HPIA register 
  mdspSingleWrite(slvHpia, dspAddr);

// Determine the HPI mode to use.
  switch (mode) {
    case AUTO:
      hpidAddr= slvHpidAuto;
      break;
    case NO_AUTO:
      hpidAddr = slvHpidNoAuto; 
      break;
    case DYNAMIC:
    default:
      if (wordCount == 1){
        hpidAddr = slvHpidNoAuto;
      } 
      else { 
        hpidAddr = slvHpidAuto;
      };
      break;
  };

// Check to see that we don't access too large a block. HPID has 20 bits of 
// address space available. MAX_HPID_WORD_ELEMENTS is defined in vmeAddressMap.h

  if (wordCount>MAX_HPID_WORD_ELEMENTS) {
    blockWordCount = MAX_HPID_WORD_ELEMENTS;
  }     
  else { 
    blockWordCount = wordCount;
  }

//      Set up the transfer as a series of block transfers 
  for (myCount=wordCount, wordIncr=0; myCount>0;
                    myCount-=blockWordCount, wordIncr+=blockWordCount) {

//      Recheck each block 
    if (wordCount>MAX_HPID_WORD_ELEMENTS) {
      blockWordCount=MAX_HPID_WORD_ELEMENTS;
    }   
    else { 
      blockWordCount = myCount;
    }
  
//      Do the transfer for this block 
  dspAddrLocal = dspAddr+ (4*wordIncr);
    mdspBlockWrite(hpidAddr, &buffer[2*wordIncr], blockWordCount, NO_AUTO);
  }
  
//  Check HPID after transfer 
  hpiaAfterFetch = mdspSingleRead(slvHpia);
        
  if (wordCount == 1) {
    hpiaAfterCalc = dspAddr;
  }     
  else  {
    hpiaAfterCalc = dspAddr+wordCount*4-4;
  }
  
/*  if (hpiaAfterFetch != hpiaAfterCalc) {
    throw HpiException("mdspBlockWrite address check failed", hpiaAfterCalc, 
                        hpiaAfterFetch);
  }
*/      
  return;
};

//------------------------------resetMasterDsp--------------------------------                                

void RodModule::resetMasterDsp() throw(VmeException &) {
  unsigned long value=0;
  unsigned long rodRegValue;
  
  rodRegValue = readRodStatusReg(0);
  setBit(&value, 1);
  if (endianSwap) {
    value = endianReverse32(value);
  }
  m_myVmePort->write32(FPGA_CONTROL_REG_REL_ADDR[2], value);
  sleep(1000);
  rodRegValue = readRodStatusReg(0);
  
  return;
};

//------------------------------resetSlaveDsp--------------------------------                                

void RodModule::resetSlaveDsp(long slaveNumber) throw(VmeException &) {
  unsigned long value=0;
  
  setBit(&value, 2+slaveNumber);
  if (endianSwap) {
    value = endianReverse32(value);
  }
  m_myVmePort->write32(FPGA_CONTROL_REG_REL_ADDR[2], value);
  sleep(1000);
  
  return;
};


//------------------------------resetAllDsps--------------------------------                                

void RodModule::resetAllDsps() throw(VmeException &) {
  unsigned long value=0;
  
  setBit(&value, 6);
  if (endianSwap) {
    value = endianReverse32(value);
  }
  m_myVmePort->write32(FPGA_CONTROL_REG_REL_ADDR[2], value);
  sleep(1000);
  
  return;
};

//-------------------------------chipEraseHpi---------------------------------

void RodModule::chipEraseHpi() throw(VmeException &) {
  unsigned long value = 0x10;
  
// Commands 1 to 5
  commonEraseCommandsHpi(MDSP_FLASH_BOTTOM);
  
// Command 6
  mdspSingleWrite(MDSP_FLASH_BOTTOM+(0x5555<<2), value);
  
// Wait for operation to complete
  sleep(CHIP_ERASE_TIME_MS);
  return;
};
  
//--------------------------------sectorErase---------------------------------

void RodModule::sectorErase(unsigned long sectorBaseAddress) 
                            throw(RodException &, VmeException &) {
  unsigned long flashBaseAddress;

// Get flash base address
  if ((sectorBaseAddress<FPGA_FLASH_0_BOTTOM)||
            (sectorBaseAddress>FPGA_FLASH_2_BOTTOM+FLASH_MEMORY_SIZE)) {
    throw RodException("Flash sector base addr out of range, sectorBaseAddress=",
    sectorBaseAddress);
  }
  if (sectorBaseAddress<FPGA_FLASH_1_BOTTOM) {
    flashBaseAddress = FPGA_FLASH_1_BOTTOM;
  }
  else {
    flashBaseAddress = FPGA_FLASH_2_BOTTOM;
  }
  
// Commands 1 to 5
  commonEraseCommands(flashBaseAddress);
  
// Set write bit
  vmeWriteElementFlash(0x30, sectorBaseAddress, WRITE_COMMAND_HANDSHAKE_BIT);
  
// Wait for operation to complete
  sleep(SECTOR_ERASE_TIME_MS);

  return;
};
  
//---------------_-------------writeByteToFlash-------------------------------

void RodModule::writeByteToFlash(unsigned long address, UINT8 data) 
                            throw (RodException &, VmeException &) {
  UINT8 readData;
  clock_t startTime;   // start time for DQ7 data polling, in seconds
  long updateAddress;
  
  if (data!=0xFF) {   // if erased, don't rewrite. 0xFF is default after erasing
// write data
    vmeWriteElementFlash(data, address, WRITE_DATA_HANDSHAKE_BIT);
    updateAddress = 0;
  }
  else {
    updateAddress = 1;
  }
  
// Wait for operation to complete - data polling
  startTime = clock();
  while(1) {
    readData = readByteFromFlash(address, updateAddress);
    if (readData == data) return;
    else if((clock()-startTime)*CLOCKS_PER_SEC > FLASH_TIMEOUT) {
      throw RodException("Flash timeout in writeByteToFlash, FLASH_TIMEOUT=",
      (long)FLASH_TIMEOUT);
    }
  }
  return;
};

//----------------------------writeBlockToFlash-------------------------------

void RodModule::writeBlockToFlash(unsigned long address, UINT8 *data, 
                               unsigned long numBytes) throw(VmeException &) {
  unsigned long index;
  for (index=0; index<numBytes; ++index) {
    if ((index%FLASH_SECTOR_SIZE)==0) {
      sectorErase(address+index);
    }
    writeByteToFlash(address+index, *(data+index));
  } 
  return;
};
  
//---------------------------writeBlockToFlashHpi-----------------------------

void RodModule::writeBlockToFlashHpi(unsigned long address, UINT8 *data, 
     unsigned long numBytes) throw (RodException &, VmeException &) {
  unsigned long index, sectorAddr;
  const unsigned long eraseData=0x30;
  const unsigned long data1=0xAA;
  const unsigned long data2=0x55;
  const unsigned long data3=0xA0;
  const unsigned long addr1=MDSP_FLASH_BOTTOM+(0x5555<<2);
  const unsigned long addr2=MDSP_FLASH_BOTTOM+(0x2AAA<<2);
  unsigned long byteRelAddr;
  long words;
  
  for (index=0; index<numBytes; ++index) {
    if ((index%FLASH_SECTOR_SIZE)==0) {
// implement sectorEraseHpi(address+index) inline.
//    commands 1 to 5
      commonEraseCommandsHpi(MDSP_FLASH_BOTTOM);
// 6th command
      sectorAddr = MDSP_FLASH_BOTTOM+
                  ((address+index-MDSP_FLASH_BOTTOM)<<2);
      mdspSingleWrite(sectorAddr, eraseData);
// Wait for operation to complete
      sleep(SECTOR_ERASE_TIME_MS);
    };
  };
  
// implement writeByteToFlashHpi(address+index, *(data+index)) inline.
  byteRelAddr = address+index-MDSP_FLASH_BOTTOM;
  if (*(data+index) !=0xFF) {
    mdspSingleWrite(addr1, (unsigned long)data1);  // 1st command
    mdspSingleWrite(addr2, (unsigned long)data2);  // 2nd command
    mdspSingleWrite(addr1, (unsigned long)data3);  // 3rd command
    mdspSingleWrite(MDSP_FLASH_BOTTOM+(byteRelAddr<<2),(unsigned long)(data+index));
  };
  
// Verification
  words = (numBytes+3)/4;       // round up
  UINT8 *buffer;
  try {
    buffer = new UINT8[words*4];
  }
  catch (std::bad_alloc & ba) {
    throw RodException("writeBlockToFlashHpi unable to get buffer.");
  }
  m_myVmePort->blockRead32(address+index, (unsigned long*)buffer, words*4);
  for (index=0; index<numBytes; ++index) {
    if(*(data+index)!=*(buffer+index)) {
      delete [] buffer;
      throw RodException("writeBlockToFlashHpi verify failed. index, data:", index,
                 *(data+index));
    };
    delete [] buffer;
  }
  return;
};
  
//-----------------------------readByteFromFlash------------------------------

UINT8 RodModule::readByteFromFlash(unsigned long address, long updateAddress) 
                 throw (RodException &, VmeException &){
  UINT8 dataByte;
  unsigned long commandReg;
  clock_t startTime;
  unsigned long handshakeBitValue = 0;
  unsigned long valueD32;
  
  if (updateAddress) {
    m_myVmePort->write32(FPGA_CONTROL_REG_REL_ADDR[4], address);
  }
// Set rd bit
    setBit(&handshakeBitValue, READ_HANDSHAKE_BIT);
    m_myVmePort->write32(FPGA_CONTROL_REG_REL_ADDR[3], handshakeBitValue);
    
// Wait for valid data
    startTime = clock();
    while (1) {
      commandReg = m_myVmePort->read32(FPGA_CONTROL_REG_REL_ADDR[3]);
      if (0==readBit(commandReg, READ_HANDSHAKE_BIT)) break;
      if ((clock()-startTime)>FLASH_TIMEOUT) throw RodException(
                          "Timeout in readByteFromFlash. Address=", address);
    }
    
// Read valid data
  valueD32 = m_myVmePort->read32(FPGA_STATUS_REG_REL_ADDR[7]); 
  dataByte = (UINT8)(valueD32&0xFF);
  return dataByte;
};
  
//---------------------------vmeWriteElementFlash------------------------------

void RodModule::vmeWriteElementFlash(UINT8 value, unsigned long address, 
           long handshakeBit) throw (RodException &, VmeException &) {
  unsigned long ctrlReg4Val;  // address(23:0) + data(31:24)
  unsigned long commandReg;
  clock_t startTime;
  unsigned long handshakeBitValue=0;
  
  ctrlReg4Val = (value<<24)| address;
  m_myVmePort->write32(FPGA_CONTROL_REG_REL_ADDR[4], ctrlReg4Val);

// Set wr bit
  setBit(&handshakeBitValue, handshakeBit);
  m_myVmePort->write32(FPGA_CONTROL_REG_REL_ADDR[3], handshakeBitValue);

// Wait for ack
  startTime = clock();
  while(1) {
      commandReg = m_myVmePort->read32(FPGA_CONTROL_REG_REL_ADDR[3]);
      if (0==readBit(commandReg, handshakeBit)) break;
      if ((clock()-startTime)>FLASH_TIMEOUT) throw RodException(
                   "Timeout in vmeWriteElementFlash. Address, value=", 
                   address, (unsigned long)value);
  }
  return;   
};

//-----------------------------readBlockFromFlash------------------------------

void RodModule::readBlockFromFlash(unsigned long address, UINT8 *buffer, 
         unsigned long numBytes) throw(VmeException &) {
  unsigned long index;
  for (index=0; index<numBytes; ++index) {
    if (0==(index%FLASH_SECTOR_SIZE)) {
      readByteFromFlash(address+index, (long)(buffer+index));
    }
  }
  return;
};
  
//-----------------------------commonEraseCommands----------------------------

void RodModule::commonEraseCommands(unsigned long flashBaseAddr) 
                                           throw(VmeException &) {

  const unsigned long addr1 = flashBaseAddr+0x5555;
  const unsigned long addr2 = flashBaseAddr+0x2AAA;
  
// 1st command
  vmeWriteElementFlash(0xAA, addr1, WRITE_COMMAND_HANDSHAKE_BIT);
  
// 2nd command
  vmeWriteElementFlash(0x55, addr2, WRITE_COMMAND_HANDSHAKE_BIT);

// 3rd command
  vmeWriteElementFlash(0x80, addr1, WRITE_COMMAND_HANDSHAKE_BIT);
  
// 4th command
  vmeWriteElementFlash(0xAA, addr1, WRITE_COMMAND_HANDSHAKE_BIT);

// 5th command
  vmeWriteElementFlash(0x55, addr2, WRITE_COMMAND_HANDSHAKE_BIT);

  return;
};

//----------------------------commonEraseCommandsHpi--------------------------

void RodModule::commonEraseCommandsHpi(unsigned long flashBaseAddr) 
                                              throw(VmeException &) {

  unsigned long buffer;
  const unsigned long addr1 = flashBaseAddr+(0x5555<<2);
  const unsigned long addr2 = flashBaseAddr+(0x2AAA<<2);
  
// 1st command
  buffer = 0xAA;
  m_myVmePort->write32(addr1, buffer);
  
// 2nd command
  buffer = 0x55;
  m_myVmePort->write32(addr2, buffer);

// 3rd command
  buffer = 0x80;
  m_myVmePort->write32(addr1, buffer);
  
// 4th command
  buffer = 0xAA;
  m_myVmePort->write32(addr1, buffer);

// 5th command
  buffer = 0x55;
  m_myVmePort->write32(addr2, buffer);

  return;
};

//----------------------------------sleep-------------------------------------                                

void RodModule::sleep(const double milliSecs) {
  clock_t start, delay;
  delay = clock_t(milliSecs * CLOCKS_PER_SEC/1000.); //need explicit type cast
                                                     //to avoid warning.
  start = clock();
  while (clock()-start< delay)   // wait until time elapses
     ;
  return;
};
  
//--------------------------------checkSum------------------------------------                                

unsigned long RodModule::checkSum(const unsigned long *sourceArray, const long wordCount) {
  unsigned long result=0;
  long i;
  
  for (i=0; i<wordCount; ++i) {
    result ^= sourceArray[i];
  }
  return result;
};
 
//-----------------------------endianReverse32----------------------------------                                

unsigned long RodModule::endianReverse32(const unsigned long inVal) {
  unsigned long outVal;
  outVal  = (inVal & 0x000000ff) << 24;
  outVal |= (inVal & 0x0000ff00) << 8;
  outVal |= (inVal & 0x00ff0000) >> 8;
  outVal |= (inVal & 0xff000000) >> 24;
  return outVal;
};
  
} //  End namespace SctPixelRod

//---------------------------- Overload operator<< -----------------------------
/* This overloaded operator lets us use cout to print the status of the ROD
*/
  ostream& std::operator<<(ostream& os, SctPixelRod::RodModule& rod) {
    os << "Slot: " << rod.getSlot() << endl;
    os << "Serial Number:" << rod.getSerialNumber() << endl;
    os << "Number of slave DSPs: " << rod.getNumSlaves() << endl;
    os << "Status registers[0-2]: ";
    try {
      for (int i=0; i<3; i++) {
        os << hex << rod.readRodStatusReg(i) << " ";
      }
      os << endl;
    }
    catch (SctPixelRod::VmeException &) {
      os << "VmeException while reading ROD status registers. " << endl;
    }
    
    os << "Command registers[0-1]: ";
    try {
      for (int i=0; i<2; i++) {
        os << hex << rod.readRodCommandReg(i) << " ";
      }
      os << endl;
    }
    catch (SctPixelRod::VmeException &) {
      os << "VmeException while reading ROD command registers. " << endl;
    }

    os << "Primitive state: " << rod.getPrimState() << " Text State: " << 
          rod.getTextState() << endl;
    return os;
  }

---