/* =====================================================================
 *   Container for the Rcu data block to configure one Rcu and the FECs
 *   connected. The Ce header and tailer are optional. The structure is:
 * 
 *    1) FEE_CONFIGURE_32 for CE block
 *    2) Number of words
 *    3) HW_Address
 *    4) Checksum
 * 
 *      5) FEE_CONFIGURE_32 for RCU block
 *      6) Number of words
 *      7) HW_Address
 *      8) Checksum
 * 
 *        9) Payload: Data for 1 RCU and the corresponding Fecs and Altros
 * 
 *       10) RCU_ALTRO_INSTRUCTION_EXECUTE             (optional)
 *       11) CE_CMD_TAILER                             (optional)
 *
 *       12) FEE_VERIFICATION (Rcu Block)              (optional)
 *       13) CE_CMD_TAILER - End of FEE_VERIFICATION   (optional)
 * 
 *     14) FEE_CONFIGURE_END - End of FEE_CONFIGURE_32
 *     15) HW_Address, same as above
 *     16) CE_CMD_TAILER - End of FEE_CONFIGURE_END
 *     17) CE_CMD_TAILER - End of FEE_CONFIGURE_32
 *
 *     18) FEE_VERIFICATION (CE Block)               (optional)
 *     19) CE_CMD_TAILER - End of FEE_VERIFICATION   (optional)
 * 
 *   20) FEE_CONFIGURE_END - End of FEE_CONFIGURE_32
 *   21) HW_Address, same as above
 *   22) CE_CMD_TAILER - End of FEE_CONFIGURE_END
 *   23) CE_CMD_TAILER - End of FEE_CONFIGURE_32
 *
 * =====================================================================
 */

/*
 * Author: C. Lippmann, Christian.Lippmann@cern.ch
 */

#include "RcuContainer.h"

//===========================================================================
RcuContainer::RcuContainer() {
  // Constructor
  fMaxSize = 0xFFFFFFFF;
  fPayload.reserve(65000);
  reset();
}

//===========================================================================
RcuContainer::RcuContainer(uint32_t hardwareAddress) {
  // Constructor
  fMaxSize = 0xFFFFFFFF;
  fPayload.reserve(65000);
  reset();
  fHardwareAddress = hardwareAddress;
}

//===========================================================================
void RcuContainer::setConfigurePhysics1() {
  // Execute the configuration. The feeserver saves the data on the DCS board and
  // in memory for fast reconfiguration
  fOldStyle           = false;  // use STORE/EXECUTE
  fClearMemImem       = true;   // clear the memory (ALTRO and FEC)
  fClearMemRcu        = true;   // clear the memory (RCU registers)
  fStoreMemImem       = true;   // store the data (ALTRO and FEC)
  fStoreMemRcu        = true;   // store the data (RCU registers)
  fWriteMem2FileImem  = true;   // write to file (ALTRO and FEC)
  fWriteMem2FileRcu   = true;   // write to file (RCU registers)
  fReadFile2MemImem   = false;  // read from file (ALTRO and FEC)
  fReadFile2MemRcu    = false;  // read from file (RCU registers)
  fSetFilenameImem    = false;  // filename (ALTRO and FEC) will not be set
  fSetFilenameRcu     = false;  // filename (RCU registers) will not be set
  fExecuteMemImem     = true;   // execute the stored data (ALTRO and FEC)
  fExecuteMemRcu      = false;  // execute the stored data (RCU registers)
  for ( uint32_t i=0; i<25; i++ ) fFec[i].setAltroInstructionStore(fStoreMemImem);
}

//===========================================================================
void RcuContainer::setConfigurePhysics2() {
  // Execute the configuration. The CoCo saves the data on the network
  // for fast reconfiguration. The feeserver saves the data in memory.
  fOldStyle           = false;  // use STORE/EXECUTE
  fClearMemImem       = true;   // clear the memory (ALTRO and FEC)
  fClearMemRcu        = true;   // clear the memory (RCU registers)
  fStoreMemImem       = true;   // store the data (ALTRO and FEC)
  fStoreMemRcu        = true;   // store the data (RCU registers)
  fWriteMem2FileImem  = false;  // dont write to file (ALTRO and FEC)
  fWriteMem2FileRcu   = false;  // dont write to file (RCU registers)
  fReadFile2MemImem   = false;  // dont read from file (ALTRO and FEC)
  fReadFile2MemRcu    = false;  // dont read from file (RCU registers)
  fSetFilenameImem    = false;  // filename (ALTRO and FEC) will not be set
  fSetFilenameRcu     = false;  // filename (RCU registers) will not be set
  fExecuteMemImem     = true;   // execute the stored data (ALTRO and FEC)
  fExecuteMemRcu      = false;  // execute the stored data (RCU registers)
  for ( uint32_t i=0; i<25; i++ ) fFec[i].setAltroInstructionStore(fStoreMemImem);
}

void RcuContainer::setConfigureCalibration() {
  // Execute the configuration, but dont store it in memory nor on DCS
  fOldStyle           = false;  // use STORE/EXECUTE
  fClearMemImem       = true;   // clear the memory (ALTRO and FEC)
  fClearMemRcu        = true;   // clear the memory (RCU registers)
  fStoreMemImem       = true;   // store the data (ALTRO and FEC)
  fStoreMemRcu        = true;   // store the data (RCU registers)
  fWriteMem2FileImem  = false;  // dont write to file (ALTRO and FEC)
  fWriteMem2FileRcu   = false;  // dont write to file (RCU registers)
  fReadFile2MemImem   = false;  // dont read from file (ALTRO and FEC)
  fReadFile2MemRcu    = false;  // dont read from file (RCU registers)
  fSetFilenameImem    = false;  // filename (ALTRO and FEC) will not be set
  fSetFilenameRcu     = false;  // filename (RCU registers) will not be set
  fExecuteMemImem     = true;   // execute the stored data (ALTRO and FEC)
  fExecuteMemRcu      = false;  // execute the stored data (RCU registers)
  for ( uint32_t i=0; i<25; i++ ) fFec[i].setAltroInstructionStore(fStoreMemImem);
}

void RcuContainer::setDoFastSOR1() {
  // Execute a fast start-of-run reconfiguration from the data stored locally in memory
  fOldStyle           = false;  // use STORE/EXECUTE
  fClearMemImem       = false;  // dont clear the memory (ALTRO and FEC)
  fClearMemRcu        = false;  // dont clear the memory (RCU registers)
  fStoreMemImem       = false;  // dont store the data (ALTRO and FEC)
  fStoreMemRcu        = false;  // dont store the data (RCU registers)
  fWriteMem2FileImem  = false;  // dont write to file (ALTRO and FEC)
  fWriteMem2FileRcu   = false;  // dont write to file (RCU registers)
  fReadFile2MemImem   = false;  // dont read from file (ALTRO and FEC)
  fReadFile2MemRcu    = false;  // dont read from file (RCU registers)
  fSetFilenameImem    = false;  // filename (ALTRO and FEC) will not be set
  fSetFilenameRcu     = false;  // filename (RCU registers) will not be set
  fExecuteMemImem     = true;   // execute the stored data (ALTRO and FEC)
  fExecuteMemRcu      = true;   // execute the stored data (RCU registers)
  for ( uint32_t i=0; i<25; i++ ) fFec[i].setAltroInstructionStore(fStoreMemImem);
}

void RcuContainer::setDoFastSOR2() {
  // Execute a fast start-of-run reconfiguration from the data stored locally in memory
  fOldStyle           = false;  // use STORE/EXECUTE
  fClearMemImem       = true;   // clear the memory (ALTRO and FEC)
  fClearMemRcu        = true;   // clear the memory (RCU registers)
  fStoreMemImem       = false;  // dont store the data (ALTRO and FEC)
  fStoreMemRcu        = false;  // dont store the data (RCU registers)
  fWriteMem2FileImem  = false;  // dont write to file (ALTRO and FEC)
  fWriteMem2FileRcu   = false;  // dont write to file (RCU registers)
  fReadFile2MemImem   = true;   // read from file (ALTRO and FEC)
  fReadFile2MemRcu    = true;   // read from file (RCU registers)
  fSetFilenameImem    = true;   // filename (ALTRO and FEC) will be set
  fSetFilenameRcu     = true;   // filename (RCU registers) will be set
  fExecuteMemImem     = true;   // execute the stored data (ALTRO and FEC)
  fExecuteMemRcu      = true;   // execute the stored data (RCU registers)
  for ( uint32_t i=0; i<25; i++ ) fFec[i].setAltroInstructionStore(fStoreMemImem);
}

void RcuContainer::setConfigureOldStyle() {
  // Dont use the new fancy stuff
  fOldStyle           = true;   // use STORE/EXECUTE
  fClearMemImem       = false;  // dont clear the memory (ALTRO and FEC)
  fClearMemRcu        = false;  // dont clear the memory (RCU registers)
  fStoreMemImem       = false;  // dont store the data (ALTRO and FEC)
  fStoreMemRcu        = false;  // dont store the data (RCU registers)
  fWriteMem2FileImem  = false;  // dont write to file (ALTRO and FEC)
  fWriteMem2FileRcu   = false;  // dont write to file (RCU registers)
  fReadFile2MemImem   = false;  // dont read from file (ALTRO and FEC)
  fReadFile2MemRcu    = false;  // dont read from file (RCU registers)
  fSetFilenameImem    = false;  // filename (ALTRO and FEC) will not be set
  fSetFilenameRcu     = false;  // filename (RCU registers) will not be set
  fExecuteMemImem     = false;  // dont execute the stored data (ALTRO and FEC)
  fExecuteMemRcu      = false;  // dont execute the stored data (RCU registers)
  for ( uint32_t i=0; i<25; i++ ) fFec[i].setAltroInstructionStore(fStoreMemImem);
}


//===========================================================================
void RcuContainer::setReadResult(uint32_t size) {
  fRead     = true;
  fReadSize = size;
  for (uint32_t i=0; i<25; i++) fFec[i].setReadResult(true);
}

//===========================================================================
void RcuContainer::reset(){
  //
  // Reset all
  //
  for (uint32_t i=0; i<25; i++) fFec[i].reset();

  fPayload.clear();
  fAppendPayload.clear();
  fRcuPayload.clear();

  fHardwareAddress = 0;
  fCheckSum        = 0;
  fReadSize        = 0;

  fExternalConfiguration = false;  // by default configure only via DCS
  fVerif                 = false;  // by default no verification (not working yet anyway)
  fRead                  = false;  // by default we write only and do not read

  setConfigurePhysics2();
}

//===========================================================================
void RcuContainer::fillAltro(uint32_t branch, uint32_t fec, uint32_t altro, uint32_t data) {
  // fill pseudo altro (IMEM) container
  if ( (branch < 2) && (fec < 13) ) fFec[branch*13+fec].fillAltro(altro, data);
}

//===========================================================================
void RcuContainer::fillAltro(uint32_t branch, uint32_t fec, uint32_t altro, uint64_t data) {
  // fill altro (IMEM) container with two words (64 bit)
  if ( (branch < 2) && (fec < 13) ) fFec[branch*13+fec].fillAltro(altro, data);
}

//===========================================================================
void RcuContainer::fillBc(uint32_t branch, uint32_t fec, uint32_t data) {
  // fill Fec container with one 32bit word, add a tailer
  if ( (branch < 2) && (fec < 13) ) fillBc(branch, fec, data, false);
}

//===========================================================================
void RcuContainer::fillBc(uint32_t branch, uint32_t fec, uint64_t data) {
  // fill Fec container with two words (64 bit), add a tailer
  if ( (branch < 2) && (fec < 13) ) fillBc(branch, fec, data, false);
}

//===========================================================================
void RcuContainer::fillBc(uint32_t branch, uint32_t fec, uint32_t data, bool addTailer) {
  // fill Fec container with one 32bit word, choose if you wish a tailer added
  if ( (branch < 2) && (fec < 13) ) fFec[branch*13+fec].fillBc(data, addTailer);
}

//===========================================================================
void RcuContainer::fillBc(uint32_t branch, uint32_t fec, uint64_t data, bool addTailer) {
  // fill Fec container with two words (64 bit), choose if you wish a tailer added
  if ( (branch < 2) && (fec < 13) ) fFec[branch*13+fec].fillBc(data, addTailer);
}

//===========================================================================
void RcuContainer::fillRcu(uint32_t data) {
  // fill rcu container with one 32bit word, add a tailer
  fillRcu(data, true);
}

//===========================================================================
void RcuContainer::fillRcu(uint32_t data, bool addTailer) {
  // fill rcu container with one 32bit word, choose if you wish a tailer added
  fPayload.push_back(data);
  if (addTailer) fPayload.push_back(fRCUce.sendCE_CMD_TAILER());
}

//===========================================================================
void RcuContainer::fillRcu(uint64_t data) {
  // fill Rcu container with two words (64 bit), add a tailer
  fillRcu(data, true);
}
  
//===========================================================================
void RcuContainer::fillRcu(uint64_t data, bool addTailer) {
  // fill Rcu container with two words (64 bit), choose if you wish a tailer added
  fPayload.push_back(data>>32);
  fPayload.push_back(data&0xFFFFFFFF);
  if (addTailer) fPayload.push_back(fRCUce.sendCE_CMD_TAILER());
}

//===========================================================================
void RcuContainer::fillAtStartRcu(uint32_t data) {
  // add one 32bit word and a tailer at start of rcu container
  fillAtStartRcu(data, true);
}

//===========================================================================
void RcuContainer::fillAtStartRcu(uint32_t data, bool addTailer) {
  // add one 32bit word at start of rcu container, choose if you wish a tailer added
  if (addTailer) fPayload.insert(fPayload.begin(), fRCUce.sendCE_CMD_TAILER());
  fPayload.insert(fPayload.begin(), data);
}

//===========================================================================
void RcuContainer::fillAtStartRcu(uint64_t data) {
  // add two words (64 bit) and a tailer at start of rcu container
  fillAtStartRcu(data, true);
}
  
//===========================================================================
void RcuContainer::fillAtStartRcu(uint64_t data, bool addTailer) {
  // add two words (64 bit) and a tailer at start of rcu container, choose if you wish a tailer added
  if (addTailer) fPayload.insert(fPayload.begin(), fRCUce.sendCE_CMD_TAILER());
  fPayload.insert(fPayload.begin(), data&0xFFFFFFFF);
  fPayload.insert(fPayload.begin(), data>>32);
}

//===========================================================================
void RcuContainer::appendRcu(uint32_t data) {
  // append data to rcu container with one 32bit word, add a tailer
  // this data will appear after the Altro and Fec blocks
  appendRcu(data, true);
}

//===========================================================================
void RcuContainer::appendRcu(uint32_t data, bool addTailer) {
  // append data to rcu container with one 32bit word, choose if you wish a tailer added
  // this data will appear after the Altro and Fec blocks
  fAppendPayload.push_back(data);
  if (addTailer) fAppendPayload.push_back(fRCUce.sendCE_CMD_TAILER());
}

//===========================================================================
void RcuContainer::appendRcu(uint64_t data) {
  // append data to Rcu container with two words (64 bit), add a tailer
  // this data will appear after the Altro and Fec blocks
  appendRcu(data, true);
}

//===========================================================================
void RcuContainer::appendRcu(uint64_t data, bool addTailer) {
  // append Rcu container with two words (64 bit), choose if you wish a tailer added
  // this data will appear after the Altro and Fec blocks
  fAppendPayload.push_back(data>>32);
  fAppendPayload.push_back(data&0xFFFFFFFF);
  if (addTailer) fAppendPayload.push_back(fRCUce.sendCE_CMD_TAILER());
}

//===========================================================================
void RcuContainer::fillRcuBuffer(uint32_t address, uint32_t data) {
  // add two 32bit words (register address and data) to rcu buffer
  fRcuPayload.push_back(address);
  fRcuPayload.push_back(data);
}

//===========================================================================
void RcuContainer::fillRcuBuffer(uint64_t data) {
  // add two 32bit words (64bit) to rcu buffer
  fRcuPayload.push_back(data>>32);
  fRcuPayload.push_back(data&0xFFFFFFFF);
}

//===========================================================================
void RcuContainer::fillRcuBufferAFL(uint32_t data) {
  // Add two 32bit words (AFL register address and data) to rcu buffer
  fRcuPayload.push_back(AFL_REG_ADD);
  fRcuPayload.push_back(data);
}

//===========================================================================
void RcuContainer::fillRcuBufferALTROIF(uint32_t data) {
  // Add two 32bit words (ALTROIF register address and data) to rcu buffer
  fRcuPayload.push_back(ALTROIF_REG_ADD);
  fRcuPayload.push_back(data);
}

//===========================================================================
void RcuContainer::fillRcuBufferTRGCONF(uint32_t data) {
  // Add two 32bit words (TRGCONF register address and data) to rcu buffer
  fRcuPayload.push_back(TRGCONF_REG_ADD);
  fRcuPayload.push_back(data);
}

//===========================================================================
void RcuContainer::fillRcuBufferRDOMOD(uint32_t data) {
  // Add two 32bit words (RDOMOD register address and data) to rcu buffer
  fRcuPayload.push_back(RDOMOD_REG_ADD);
  fRcuPayload.push_back(data);
}

//===========================================================================
void RcuContainer::fillRcuBufferALTROCFG1(uint32_t data) {
  // Add two 32bit words (ALTROCFG1 register address and data) to rcu buffer
  fRcuPayload.push_back(ALTROCFG1_REG_ADD);
  fRcuPayload.push_back(data);
}

//===========================================================================
void RcuContainer::fillRcuBufferALTROCFG2(uint32_t data) {
  // Add two 32bit words (ALTROCFG2 register address and data) to rcu buffer
  fRcuPayload.push_back(ALTROCFG2_REG_ADD);
  fRcuPayload.push_back(data);
}

//===========================================================================
void RcuContainer::fillRcuBufferRCUID(uint32_t data) {
  // Add two 32bit words (RCUID register address and data) to rcu buffer
  fRcuPayload.push_back(RCUID_REG_ADD);
  fRcuPayload.push_back(data);
}

//===========================================================================
void RcuContainer::fillRcuBufferEN_INT_BA(uint32_t data) {
  // Add two 32bit words (EN_INT_BA register address and data) to rcu buffer
  fRcuPayload.push_back(EN_INT_BA_REG_ADD);
  fRcuPayload.push_back(data);
}

//===========================================================================
void RcuContainer::fillRcuBufferTTC_CONTROL(uint32_t data) {
  // Add two 32bit words (TTC_CONTROL register address and data) to rcu buffer
  fRcuPayload.push_back(TTC_CONTROL_REG_ADD);
  fRcuPayload.push_back(data);
}

//===========================================================================
void RcuContainer::fillRcuBufferTTC_L1_LATENCY(uint32_t data) {
  // Add two 32bit words (TTC_L1_LATENCY register address and data) to rcu buffer
  fRcuPayload.push_back(TTC_L1_LATENCY_REG_ADD);
  fRcuPayload.push_back(data);
}

//===========================================================================
void RcuContainer::fillRcuBufferTTC_L2_LATENCY(uint32_t data) {
  // Add two 32bit words (TTC_L2_LATENCY register address and data) to rcu buffer
  fRcuPayload.push_back(TTC_L2_LATENCY_REG_ADD);
  fRcuPayload.push_back(data);
}

//===========================================================================
void RcuContainer::fillRcuBufferTTC_L1_MSG_LATENCY(uint32_t data) {
  // Add two 32bit words (TTC_L1_MSG_LATENCY register address and data) to rcu buffer
  fRcuPayload.push_back(TTC_L1_MSG_LATENCY_REG_ADD);
  fRcuPayload.push_back(data);
}

//===========================================================================
void RcuContainer::finalize() {
  //
  // Finalize the data block, including the header and tailer.
  // NOTE 1: Call this function only once! Otherwise you get each header and tailer twice!
  // NOTE 2: Calling getDataBlock() or size() before finalize() does not make sense!
  //

  uint32_t *mem = 0;
  int size = 0;

  //
  // 0) At this stage fPayload contains only the RCU registers.
  //

  // 1) Insert before everything else command to execute RCU instructions from memory,
  // RCU_REG_CFG_EXECUTE (optional)
  if (!fOldStyle && fExecuteMemRcu) {
    fPayload.insert(fPayload.begin(), fRCUce.sendCE_CMD_TAILER());
    fPayload.insert(fPayload.begin(), fRCUce.sendRCU_REG_CFG_EXECUTE());
  }

  // 2) Insert before everything else the RCU data to be stored on DCS board
  if ( !fOldStyle && !fRcuPayload.empty() ) { // this container is not empty
    size = fRcuPayload.size();
    fRcuPayload.insert(fRcuPayload.begin(), fRCUce.sendRCU_REG_CFG_STORE(size));
    fRcuPayload.push_back(fRCUce.sendCE_CMD_TAILER());
    size = fRcuPayload.size();
    mem  = &fRcuPayload[0];
    fPayload.insert(fPayload.begin(), mem, mem+size);
  }

  // 3) Insert before everything else RCU_REG_CFG_READ_FILE (optional)
  if (!fOldStyle && fReadFile2MemRcu) {
    fPayload.insert(fPayload.begin(), fRCUce.sendCE_CMD_TAILER());
    fPayload.insert(fPayload.begin(), fRCUce.sendRCU_REG_CFG_READ_FILE());
  }

  // 4) Insert before everything else RCU_REG_CFG_FILE_NAME (optional)
  if (!fOldStyle && fSetFilenameRcu) {
    fPayload.insert(fPayload.begin(), fRCUce.sendCE_CMD_TAILER());
    uint32_t size = fDcsRcuCfgFileName.size() + 1; // number of chars + termination
    size = (size+3)/4;
    uint32_t *fname = (uint32_t*)fDcsRcuCfgFileName.c_str();
    for ( int32_t ii=size-1; ii>=0; ii-- ) fPayload.insert(fPayload.begin(), fname[ii]);
    fPayload.insert(fPayload.begin(), fRCUce.sendRCU_REG_CFG_FILE_NAME(size));
  }

  // 5) Insert before everything else RCU_REG_CFG_CLEAR (optional)
  if (!fOldStyle && fClearMemRcu) {
    fPayload.insert(fPayload.begin(), fRCUce.sendCE_CMD_TAILER());
    fPayload.insert(fPayload.begin(), fRCUce.sendRCU_REG_CFG_CLEAR());
  }
  
  // 6) Add RCU_ALTRO_INSTRUCTION_CLEAR (optional)
  if (!fOldStyle && fClearMemImem) {
    fPayload.push_back(fRCUce.sendRCU_ALTRO_INSTRUCTION_CLEAR());
    fPayload.push_back(fRCUce.sendCE_CMD_TAILER());
  }

  // 7) Add RCU_ALTRO_INSTRUCTION_FILE_NAME (optional)
  if (!fOldStyle && fSetFilenameImem) {
    uint32_t size = fDcsImemFileName.size() + 1; // number of chars + termination
    size = (size+3)/4;
    fPayload.push_back(fRCUce.sendRCU_ALTRO_INSTRUCTION_FILE_NAME(size));
    uint32_t *fname = (uint32_t*)fDcsImemFileName.c_str();
    for ( uint32_t ii=0; ii<size; ii++ ) fPayload.push_back(fname[ii]);
    fPayload.push_back(fRCUce.sendCE_CMD_TAILER());
  }

  // 8) Read file into mem (RCU_ALTRO_INSTRUCTION_READ_FILE, optional)
  if (!fOldStyle && fReadFile2MemImem) {
    fPayload.push_back(fRCUce.sendRCU_ALTRO_INSTRUCTION_READ_FILE());
    fPayload.push_back(fRCUce.sendCE_CMD_TAILER());
  }

  // 9) Add FEC and ALTRO data
  try {
    // Add FEC and ALTRO data
    for (uint32_t i=0; i<25; i++) {    // Get and add FEC/ALTRO blocks
      if ( fFec[i].empty() ) continue; // this container is empty
      //int hwAdd = (i>12) ? ((1<<11)+((i-13)<<7)) : (i<<7); 
      fFec[i].finalize();
      mem = fFec[i].getDataBlock();
      fPayload.insert(fPayload.end(), mem, mem+fFec[i].size());
    }
  } catch (TpcException ea) {
    throw TpcException( (string) ea.what());
  }

  // 10) Execute IM data, RCU_ALTRO_INSTRUCTION_EXECUTE (optional)
  if (!fOldStyle && fExecuteMemImem) {
    fPayload.push_back(fRCUce.sendRCU_ALTRO_INSTRUCTION_EXECUTE());
    fPayload.push_back(fRCUce.sendCE_CMD_TAILER());
  }

  // 11) RCU_ALTRO_INSTRUCTION_WRITE_FILE for ALTRO and FEC data (IMEM, optional)
  if (!fOldStyle && fWriteMem2FileImem) {
    fPayload.push_back(fRCUce.sendRCU_ALTRO_INSTRUCTION_WRITE_FILE());
    fPayload.push_back(fRCUce.sendCE_CMD_TAILER());
  }

  // 12) RCU_REG_CFG_WRITE_FILE (RCU registers, optional)
  if (!fOldStyle && fWriteMem2FileRcu) {
    fPayload.push_back(fRCUce.sendRCU_REG_CFG_WRITE_FILE());
    fPayload.push_back(fRCUce.sendCE_CMD_TAILER());
  }

  // 13) Add RCU data to be written/executed after the Altro and FEC blocks
  if ( !fAppendPayload.empty() ) {
    mem = &fAppendPayload[0];
    fPayload.insert(fPayload.end(), mem, mem+fAppendPayload.size());
  }    

  // 14) Add FEE_VERIFICATION (RCU block)
  if (fVerif) {
    fPayload.push_back(fRCUce.sendFEE_VERIFICATION()); //
    fPayload.push_back(fRCUce.sendCE_CMD_TAILER());    // ends FEE_VERIFICATION
  }

  // 15) Add RCU_READ_RESULT (optional)
  if (fRead) {
    fPayload.push_back(fRCUce.sendRCU_READ_RESULT(fReadSize));
    fPayload.push_back(fRCUce.sendCE_CMD_TAILER());    // ends RCU_READ_RESULT
  }

  // 16) Add FEE_CONFIGURE_END tailer block (RCU block)
  if (fRead)
    fPayload.push_back(fRCUce.sendFEE_CONFIGURE_END_NOSTATE());
  else 
    fPayload.push_back(fRCUce.sendFEE_CONFIGURE_END());
  fPayload.push_back(fRCUce.sendFEE_CONFIGURE_END_1Word(0, fRCUce.deviceRCU(), fHardwareAddress));
  fPayload.push_back(fRCUce.sendCE_CMD_TAILER());    // ends FEE_CONFIGURE_END

  size = fPayload.size();

  // 17) Add FEE_CONFIGURE_32 header block (RCU block)
  fPayload.insert(fPayload.begin(), fCheckSum);
  fPayload.insert(fPayload.begin(), fRCUce.sendFEE_CONFIGURE_1Word(0, fRCUce.deviceRCU(), fHardwareAddress));
  fPayload.insert(fPayload.begin(), size);
  if (fRead)
    fPayload.insert(fPayload.begin(), fRCUce.sendFEE_CONFIGURE_32_NOSTATE());
  else 
    fPayload.insert(fPayload.begin(), fRCUce.sendFEE_CONFIGURE_32());

  // 18) Add FEE_CONFIGURE tailer (RCU block)
  fPayload.push_back(fRCUce.sendCE_CMD_TAILER());    // ends FEE_CONFIGURE_32 (RCU block)

  // ======== CE Block ========

  // 19) Add FEE_VERIFICATION (CE block)
  if (fVerif) {
    fPayload.push_back(fRCUce.sendFEE_VERIFICATION()); //
    fPayload.push_back(fRCUce.sendCE_CMD_TAILER());    // Ends FEE_VERIFICATION
  }

  // 20) Add FEE_EXTERNAL_CONFIGURATION
  if (fExternalConfiguration) {
    fPayload.push_back(fRCUce.sendFEE_EXTERNAL_CONFIGURATION()); // Start DDL Config
    fPayload.push_back(fRCUce.sendCE_CMD_TAILER());              // Ends FEE_EXTERNAL_CONFIGURATION
  }

  // 21) Add FEE_CONFIGURE_END tailer block (CE block)
  if (fRead)
    fPayload.push_back(fRCUce.sendFEE_CONFIGURE_END_NOSTATE());
  else 
    fPayload.push_back(fRCUce.sendFEE_CONFIGURE_END());
  fPayload.push_back(fRCUce.sendFEE_CONFIGURE_END_1Word(0, fRCUce.deviceCE(), fHardwareAddress));
  fPayload.push_back(fRCUce.sendCE_CMD_TAILER());    // Ends FEE_CONFIGURE_END

  size = fPayload.size();
  
  // 22) Add FEE_CONFIGURE_32 header block (CE block)
  fPayload.insert(fPayload.begin(), fCheckSum);
  fPayload.insert(fPayload.begin(), fRCUce.sendFEE_CONFIGURE_1Word(0, fRCUce.deviceCE(), fHardwareAddress));
  fPayload.insert(fPayload.begin(), size);
  if (fRead)
    fPayload.insert(fPayload.begin(), fRCUce.sendFEE_CONFIGURE_32_NOSTATE());
  else 
    fPayload.insert(fPayload.begin(), fRCUce.sendFEE_CONFIGURE_32());

  // 23) Add FEE_CONFIGURE tailer (CE block)
  fPayload.push_back(fRCUce.sendCE_CMD_TAILER());    // Ends FEE_CONFIGURE_32 (CE block)

}

//===========================================================================
uint32_t* RcuContainer::getDataBlock() {
  //
  // Return the data block, including the header and tailer.
  //
  return &fPayload[0];
}

//===========================================================================
void RcuContainer::calculateCheckSum() {
  // to be implemented
  fCheckSum = 0;
}