PrimBuilder.cxx

#include <algorithm>
#include <sstream>
#include "CommonWithDsp/primParams.h"

#include "RodCrate/RodPrimList.h"

#include "SctApiException.h"
#include "SctApiDebug.h"
#include "PrimBuilder.h"
#include "utility.h"

using namespace SctApi;

PrimBuilder *PrimBuilder::singleton = 0;

PrimBuilder::PrimBuilder() {}

void PrimBuilder::slavePrimList(boost::shared_ptr<PrimListWrapper> parentList, 
                                boost::shared_ptr<PrimListWrapper> primList, 
                                unsigned int slaveNumber, bool await, bool response) {
  try {
    primList->list->bufferBuild();
  } catch (SctPixelRod::PrimListException &p) {
    std::cout << "Exception building prim list for slave " << slaveNumber << std::endl;
    std::cout << p.getDescriptor() << " ";
    std::cout << p.getData1() << ", " << p.getData2() << "\n";
    return;
  }

  // Get a copy of buffer and use SEND_SLAVE_LIST/START_SLAVE_LIST primitives
  // to have MDSP send it to the slave
  long buffLength = primList->list->getBufferLength();
  unsigned long* bufferStart = primList->list->getBuffer();

  // Create Slave List primitives
  int offset = sizeof(SEND_SLAVE_LIST_IN)/4;

  long *slaveData = new long[offset+buffLength];

  SEND_SLAVE_LIST_IN &slaveList = *(SEND_SLAVE_LIST_IN *)slaveData;

#if (R_SEND_SLAVE_LIST == 103)
  slaveList.slaveNumber = slaveNumber;
  slaveList.listLength = buffLength;
  slaveList.slavePrimList = (unsigned int*)DEFAULT;
  slaveList.slaveRepData = (unsigned int*)DEFAULT;
#else 
#error "SEND_SLAVE_LIST not compiled (new revision)"
#endif

  // Copy prim list as send data
  for (int i=0; i< buffLength; i++) {
    slaveData[offset + i] = bufferStart[i];
  }

  parentList->addPrimitive(offset+buffLength, 1, SEND_SLAVE_LIST, R_SEND_SLAVE_LIST, slaveData);

  delete [] slaveData;

  startSlaveList(parentList, slaveNumber, await, response);
}

void PrimBuilder::startSlaveList(boost::shared_ptr<PrimListWrapper> primList, 
                                 unsigned int slaveNumber, bool await, bool response) {
  START_SLAVE_LIST_IN startPrim;
#if (R_START_SLAVE_LIST == 103)
  startPrim.slaveNumber = slaveNumber;
  startPrim.pauseMasterList = await?1:0;
  startPrim.getSlaveReply = response?1:0;
#else
#error "START_SLAVE_LIST not compiled (new revision)"
#endif

  primList->addPrimitive(sizeof(START_SLAVE_LIST_IN)/4, 2, START_SLAVE_LIST, R_START_SLAVE_LIST, (long*)&startPrim);
}

void PrimBuilder::echo(boost::shared_ptr<PrimListWrapper> primList, Utility::MemoryBlock block) {
#if (R_ECHO != 100) 
#error "ECHO revision changed!"
#endif

  long *myData = new long[block.size()];
  std::copy(block.address(), block.address() + block.size(), myData);
  primList->addPrimitive(block.size(), 1, ECHO, R_ECHO, myData);

  delete [] myData;
}

void PrimBuilder::startSlave(boost::shared_ptr<PrimListWrapper> prim, int s) {
  START_SLAVE_EXECUTING_IN data;
  data.slaveNumber = s;              // Slave
  data.commOnOff = SLV_DSP_COMM_ON;  // Comm on
  data.slaveType = SLAVE_MONITOR;    // Mode
  data.timeoutInUsec = 0x200000;     // Timeout

  prim->addPrimitive(sizeof(START_SLAVE_EXECUTING_IN)/4, 1, START_SLAVE_EXECUTING, R_START_SLAVE_EXECUTING, (long *)&data);
}

void PrimBuilder::readFifo(boost::shared_ptr<PrimListWrapper> prim, int id, int bank, int elems) {
  RW_FIFO_IN fifo;
#if (R_RW_FIFO == 104)
  fifo.fifoId = id;
  fifo.bank = bank;
  fifo.readNotWrite = 1;
  fifo.numElements = elems;
  fifo.dataBaseAdr = (UINT32 *)0xffffffff;
#else
#error "RW_FIFO revision change"
#endif

  prim->addPrimitive(sizeof(RW_FIFO_IN)/4, 1, RW_FIFO, R_RW_FIFO, (long *)&fifo);
}

void PrimBuilder::pollRegister(boost::shared_ptr<PrimListWrapper> prim, int r, int off, int width, int val, int timeout) {
  POLL_REG_FIELD_IN poll;

#if (R_POLL_REG_FIELD == 105)
  poll.registerID = r;
  poll.offset = off;
  poll.width = width;
  poll.desiredValue = val;
  poll.timeoutInUsec = timeout;
#else
#error "POLL_REG_FIELD revision changed"
#endif

  prim->addPrimitive(sizeof(POLL_REG_FIELD_IN)/4, 1, POLL_REG_FIELD, R_POLL_REG_FIELD, (long*)&poll);
}

void PrimBuilder::taskOp(boost::shared_ptr<PrimListWrapper> prim, int typ, int op, int data) {
  TASK_OPERATION_IN taskOp;
#if (R_TASK_OPERATION == 100) 
  taskOp.taskType = typ;
  taskOp.taskOperation = op;
  taskOp.data = data;
#else 
#error "TASK_OPERATION revision change"
#endif

  prim->addPrimitive(sizeof(TASK_OPERATION_IN)/4, 1, TASK_OPERATION, R_TASK_OPERATION, (long*)&taskOp);
}

void PrimBuilder::readRegister(boost::shared_ptr<PrimListWrapper> prim, int r) {
  RW_REG_FIELD_IN rField;
#if (R_RW_REG_FIELD == 103) || (R_RW_REG_FIELD == 104) || (R_RW_REG_FIELD == 105)
  rField.registerID = r;
  rField.offset = 0;
  rField.width = 32;
  rField.readNotWrite = 1;
  rField.dataIn = 0; // Unused!
#else
#error "RW_REG_FIELD revision change"
#endif

  prim->addPrimitive(sizeof(RW_REG_FIELD_IN)/4, 5, RW_REG_FIELD, R_RW_REG_FIELD, (long *)&rField);
}

void PrimBuilder::writeRegister(boost::shared_ptr<PrimListWrapper> prim, int r, int off, int wid, int value) {
  RW_REG_FIELD_IN rField;
#if (R_RW_REG_FIELD == 103) || (R_RW_REG_FIELD == 104) || (R_RW_REG_FIELD == 105)
  rField.registerID = r;
  rField.offset = off;
  rField.width = wid;
  rField.readNotWrite = 0;
  rField.dataIn = value;
#else
#error "RW_REG_FIELD revision change"
#endif

  prim->addPrimitive(sizeof(RW_REG_FIELD_IN)/4, 5, RW_REG_FIELD, R_RW_REG_FIELD, (long *)&rField);
}

void PrimBuilder::sendStream(boost::shared_ptr<PrimListWrapper> prim, int cmdBuff, bool capture) {
  SEND_STREAM_IN sendStream;

#if (R_SEND_STREAM == 100)
#if (R_RW_MODULE_DATA >= 103) 
// interface for SEND_STREAM changed without version number change
// so have to use a contemporary change to make this work :( AJB.
  sendStream.port = cmdBuff;
#else
  sendStream.cmdBuff = cmdBuff;  
#endif
  sendStream.captureSerOn = capture;
#else
#error "SEND_STREAM revision change"
#endif

  prim->addPrimitive(sizeof(SEND_STREAM_IN)/4, 3, SEND_STREAM, R_SEND_STREAM, (long *)&sendStream);
}

void PrimBuilder::startEvTrap(boost::shared_ptr<PrimListWrapper> prim) {
  long trap[0] = {};

#if (R_START_EVENT_TRAPPING != 101)
#error "START_EVENT_TRAPPING revision change"
#endif

  prim->addPrimitive(0, 0, START_EVENT_TRAPPING, R_START_EVENT_TRAPPING, trap);
}

void PrimBuilder::stopEvTrap(boost::shared_ptr<PrimListWrapper> prim) {
  long trap[0] = {};

#if (R_STOP_EVENT_TRAPPING != 100)
#error "STOP_EVENT_TRAPPING revision change"
#endif

  prim->addPrimitive(0, 0, STOP_EVENT_TRAPPING, R_STOP_EVENT_TRAPPING, trap);
}

void PrimBuilder::setMemory(boost::shared_ptr<PrimListWrapper> primList, unsigned long address, unsigned long words, long value) {
  SET_MEMORY_IN prim;

#if (R_SET_MEMORY == 100)
  prim.start = (UINT32 *)address;
  prim.size = words;
  prim.val = value;
#else 
#error "SET_MEMORY revision changed"
#endif

  primList->addPrimitive(sizeof(SET_MEMORY_IN)/4, 1, SET_MEMORY, R_SET_MEMORY, (const long *)&prim);
}

void PrimBuilder::readSlaveMemory(boost::shared_ptr<PrimListWrapper> primList, unsigned long slave, unsigned long address, unsigned long words) {
  RW_SLAVE_MEMORY_IN rwPrim;

#if (R_RW_SLAVE_MEMORY == 100)
  rwPrim.slaveNumber = slave;
  rwPrim.readNotWrite = 1;
  rwPrim.slaveAddress = (UINT32 *)address;
  rwPrim.masterAddress = (UINT32 *)0xffffffff;
  rwPrim.numWords = words;
#else
#error "RW_SLAVE_MEMORY revision change"
#endif

  primList->addPrimitive(sizeof(RW_SLAVE_MEMORY_IN)/4, 1, RW_SLAVE_MEMORY, R_RW_SLAVE_MEMORY, (long*)&rwPrim);
}

void PrimBuilder::writeSlaveMemory(boost::shared_ptr<PrimListWrapper> primList, 
                                   unsigned long slave, unsigned long address, unsigned long length, unsigned long *data) {
  long *primData = new long[sizeof(RW_SLAVE_MEMORY_IN)/4 + length];

  RW_SLAVE_MEMORY_IN &rwPrim = *(RW_SLAVE_MEMORY_IN*)primData;

#if (R_RW_SLAVE_MEMORY == 100)
  rwPrim.slaveNumber = slave;
  rwPrim.readNotWrite = 0;
  rwPrim.slaveAddress = (UINT32 *)address;
  rwPrim.masterAddress = (UINT32 *)0xffffffff;
  rwPrim.numWords = length;
#else
#error "RW_SLAVE_MEMORY revision change"
#endif

  std::copy(data, data + length, primData + 5);

  primList->addPrimitive(sizeof(RW_SLAVE_MEMORY_IN)/4 + length, 
                         1, RW_SLAVE_MEMORY, R_RW_SLAVE_MEMORY, primData);
}

void PrimBuilder::rodMode(boost::shared_ptr<PrimListWrapper> rodModeList, 
                          int mode, int flag, int fifoSetup, int nBits, int delay, int message) {
#ifndef R_SET_ROD_MODE
#error "Set Rod Mode wasn't compiled"
#elif (R_SET_ROD_MODE != 101)
#error "Set Rod Mode wasn't compiled (wrong prim version)"
#else
  SET_ROD_MODE_IN rodPrim;
  rodPrim.mode = mode;
  rodPrim.flag = flag;
  rodPrim.fifoSetup = fifoSetup;
  rodPrim.nBits = nBits;
  rodPrim.delay = delay;
  rodPrim.evtsPerL1A = 1;         // This is a pixel thing!
  rodPrim.message = message;
  rodModeList->addPrimitive(sizeof(SET_ROD_MODE_IN)/4, 
                            1, SET_ROD_MODE, R_SET_ROD_MODE, (long *)&rodPrim);
#endif
}

void PrimBuilder::moduleMask(boost::shared_ptr<PrimListWrapper> maskList, 
                             int module, int port, int useStructSet, int passOn, int slvs,
                             int cmdLine, int dataLine0, int dataLine1, // 2 and 3 only for pixels
                             int cfg, int modMask0, int modMask1, int maskType, int storage, int maskSet) { 
#if (R_MODULE_MASK == 101)
  // Load module masks
  MODULE_MASK_IN maskPrim;
  maskPrim.moduleNum = module;
  maskPrim.port = port;
  maskPrim.useStructSet = useStructSet;
  maskPrim.passOn = passOn;
  maskPrim.slvBits = slvs;
  maskPrim.cmdLine = cmdLine;
  maskPrim.dataLine[0] = dataLine0;
  maskPrim.dataLine[1] = dataLine1;
  maskPrim.dataLine[2] = 0;   // Pixels only 
  maskPrim.dataLine[3] = 0;   // Pixels only 
  maskPrim.cfg = cfg;               // Don't do manual mask bits set up
  maskPrim.modMask[0] = modMask0;
  maskPrim.modMask[1] = modMask1;
  maskPrim.maskType = maskType;
  maskPrim.storage = storage;
  maskPrim.maskSet = maskSet;

  maskList->addPrimitive(sizeof(MODULE_MASK_IN)/4,
                         1, MODULE_MASK, R_MODULE_MASK, (long *)&maskPrim);
#elif (R_MODULE_MASK == 100) 
#warning "MODULE_MASK method not compiled"
#else 
#error "MODULE_MASK revision change"
#endif
}

void PrimBuilder::masksFromConfig(boost::shared_ptr<PrimListWrapper> maskList, int port) { 
  // passOn       == 0
  // cfg          == 0
  // useStructSet == 1

  // Everything ignored except          this
  moduleMask(maskList, ALL_MODULES, port, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
}

void PrimBuilder::masksToSlaves(boost::shared_ptr<PrimListWrapper> maskList, int slvBits) { 
  // passOn       == 1
  // cfg          == 0
  // useStructSet == 0

  // Use struct set and pass on...
  moduleMask(maskList, ALL_MODULES, 0, 0, 1, slvBits,
             // The rest is ignored
             0, 0, 0, 0, 0, 0, 0, 0, 0);
}

void PrimBuilder::masksConfig(boost::shared_ptr<PrimListWrapper> maskList, 
                              int moduleMasks[2], int port, int maskType, int command, int maskSet) { 
  // passOn       == 0
  // cfg          == 1
  // useStructSet == 0

  // Use cfg to issue command
  // What should the module parameter be?
  moduleMask(maskList, ALL_MODULES, port, 0, 0, 0, 0, 0, 0, 
             1, moduleMasks[0], moduleMasks[1], maskType, command, maskSet);
}

void PrimBuilder::masksConfigModule(boost::shared_ptr<PrimListWrapper> maskList, int module, int cmd, int rx0, int rx1) { 
  // passOn       == 0
  // cfg          == 0
  // useStructSet == 0

  // Configure one module
  moduleMask(maskList, module, 0, 0, 0, 0, cmd, rx0, rx1,
             // The rest is ignored
             0, 0, 0, 0, 0, 0);
}


void PrimBuilder::readModuleData(boost::shared_ptr<PrimListWrapper> primList, int bank, int channel) {

#if (R_RW_MODULE_DATA == 103 )
  RwModuleDataIn primData;
  const unsigned size = sizeof(RwModuleDataIn)/4;
  primData.fRead = 1;
  primData.fCopy = 0;
  primData.copySrcCfgSet = 0;
  primData.cfgSet = bank;
#warning "AJB has noticed a bug in the dsp code of 11 April 2005 which necessitates the fix below"
  // this isnt really a bitfield, but the dsp code currently doing getModule[1<<cfgfield] if it is cfgBitfield not set
  bool douglasHasFixedBugInApril05DspCode = true;
  primData.cfgBitfield = douglasHasFixedBugInApril05DspCode ? 0 : 1;
  primData.module = channel;
  primData.chip = ALL_CHIPS;
  primData.dataType = CONFIG_MODULE_ALL;
#elif (R_RW_MODULE_DATA == 101) || (R_RW_MODULE_DATA == 102)
  RW_MODULE_DATA_IN primData;
  const unsigned size = sizeof(RW_MODULE_DATA_IN)/4;
  primData.readNotWrite = 1;
  primData.structId = bank;
  primData.moduleNum = channel;
  // Ignore configdata as this is a read
#elif (R_RW_MODULE_DATA == 100)
  RW_MODULE_DATA_IN primData;
  const unsigned size = sizeof(RW_MODULE_DATA_IN)/4;
  primData.readNotWrite = 1;
  primData.structID = bank;
  primData.moduleNum = channel;
  // Ignore configdata as this is a read
#else
#error "RW_MODULE_DATA not compiled (primitive change)"
#endif
  primList->addPrimitive(size, 1, RW_MODULE_DATA, R_RW_MODULE_DATA, (long*)&primData);
}

void PrimBuilder::copyModuleData(boost::shared_ptr<PrimListWrapper> primList, int from_bank, 
                 UINT32 to_banks_bitset, int channel) {
#if (R_RW_MODULE_DATA == 103)
  RwModuleDataIn prim;
  prim.fRead = 0;
  prim.fCopy = 1;
  prim.copySrcCfgSet = from_bank;
  prim.cfgSet = to_banks_bitset;
  prim.cfgBitfield = true;
  prim.module = channel;
  prim.chip = ALL_CHIPS;
  prim.dataType = CONFIG_MODULE_ALL;
  primList->addPrimitive(sizeof(RwModuleDataIn)/4, 1, RW_MODULE_DATA, R_RW_MODULE_DATA, (long*)&prim);
#else
  throw SctApiException("Cannot do on-rod copy of module data - should have used get/set");
#warning "copyModuleData not compiled - change of prim version"
#endif
}

void PrimBuilder::writeModuleData(boost::shared_ptr<PrimListWrapper> primList, const ABCDModule* module, int cfgSet_bits, int channel, UINT32 module_parts) {
#if (R_RW_MODULE_DATA == 103 )
  const unsigned prim_size = sizeof(RwModuleDataIn)/4;
  
  RwModuleDataIn primData;
  primData.fRead = 0;
  primData.fCopy = 0;
  primData.copySrcCfgSet = 0;
  primData.cfgSet = cfgSet_bits;
  primData.cfgBitfield = 1;
  primData.module = channel;
  primData.chip = ALL_CHIPS;
  primData.dataType = module_parts;
  
  long* data;
  size_t data_size;
  switch (module_parts){
  case CONFIG_MODULE_ALL: {
    data_size = sizeof(ABCDModule)/sizeof(long);
    data = new long[data_size];
    std::copy((long*)module, (long*)module+data_size, data);
    break;
  }
  case CONFIG_MODULE_CFG:{
    unsigned s = 1; // size of cfg in UINT32 units
    data_size = s * N_SCT_CHIPS;
    data = new long[data_size];
    for (unsigned ichip=0; ichip<N_SCT_CHIPS; ++ichip){
      long* start = (long*)&module->chip[ichip].basic.config;
      std::copy(start, start+s, data+(ichip*s));
    }
    break;
  }
  case CONFIG_MODULE_CALDATA:{
    unsigned s = sizeof(ABCDCaldata)/sizeof(long);
    data_size = s * N_SCT_CHIPS;
    data = new long[data_size];
    for (unsigned ichip=0; ichip<N_SCT_CHIPS; ++ichip){
      long* start = (long*)&module->chip[ichip].caldata;
      std::copy(start, start+s, data+(ichip*s));
    }
    break;
  }
  case CONFIG_MODULE_BASIC:{
    unsigned s = sizeof(ABCDBasic)/sizeof(long);
    data_size = s * N_SCT_CHIPS;
    data = new long[data_size];
    for (unsigned ichip=0; ichip<N_SCT_CHIPS; ++ichip){
      long* start = (long*)&module->chip[ichip].basic;
      std::copy(start, start+s, data+(ichip*s));
    }
    break;
  }
  case CONFIG_MODULE_TRIM:{
    unsigned s = N_SCT_CHANS*8/32;
    data_size = s * N_SCT_CHIPS;
    data = new long[data_size];
    for (unsigned ichip=0; ichip<N_SCT_CHIPS; ++ichip){
      long* start = (long*)module->chip[ichip].trim;
      std::copy(start, start+s, data+(ichip*s));
    }
    break;
  }
  default:{
    std::ostringstream message;
    message << "PrimBuilder: ERROR Can't set cfgtype = " << module_parts;
    throw SctApiException(message.str().c_str());
  }
  }
  long* all_data   = new long[prim_size+data_size];
  long* prim_start = (long*)&primData;
  long* prim_end   = (long*)&primData + prim_size;
  
  std::copy(prim_start, prim_end, all_data);
  std::copy(data, data+data_size, all_data+prim_size);
  
  primList->addPrimitive(prim_size+data_size, 1, RW_MODULE_DATA, R_RW_MODULE_DATA, all_data);
  delete[] data;
  delete[] all_data;
#elif (R_RW_MODULE_DATA == 101) || (R_RW_MODULE_DATA == 102)
#warning "Using old (slow) multiple set"
  // for old primitives, do copy to many cfg sets by adding many primitives
  for (int i=0; i< N_MODULE_CONFIG_SETS; ++i){
    if (1<<i & cfgSet_bits){
      const unsigned int longsInConfig = sizeof(ABCDModule) / 4;
      long *configData = new long[sizeof(RW_MODULE_DATA_IN)/4+longsInConfig];
      RW_MODULE_DATA_IN &params = *(RW_MODULE_DATA_IN*)configData;
      params.readNotWrite = 0;
      params.structId = i;
      params.moduleNum = channel;
      params.configData = (ABCDModule *)0xffffffff;
      // Overwrite params.configData with the first word of the config (hence 3 not 4 and -1 in next line)
      std::copy((long *)module, ((long*)module)+longsInConfig, configData+3);
      primList->addPrimitive(sizeof(RW_MODULE_DATA_IN)/4+longsInConfig-1, 1, RW_MODULE_DATA, R_RW_MODULE_DATA, configData);
      delete [] configData;
    }
  }
#else
#error "RW_MODULE_DATA not compiled (primitive change)"
#endif
}

void PrimBuilder::sendConfig(boost::shared_ptr<PrimListWrapper> primList, 
                             int port, int capture, int module0, int module1, int chip, int setLinks, int restore, 
                             int bank, int group, int data, int active, int enableData) {
  if (enableData!=0) {
    enableData=1; // I don't know whether primdata can cope with values other than 1, but in the past it was always given one, so we may as well do this small thing just to be on the safe side.
  }
#if (R_SEND_CONFIG == 106)
  SendConfigIn primData;
  primData.port = port;
  primData.module[0] = module0;
  primData.module[1] = module1;
  primData.chip = chip;
  primData.setLinks = setLinks;
  primData.cfgSet = bank;
  primData.groupId = group;
  primData.dataType = data;
  primData.activeOnly = active;
  primData.enableDataTaking = enableData;
  primList->addPrimitive(sizeof(SendConfigIn)/4, 1, SEND_CONFIG, R_SEND_CONFIG, (long*)&primData);
#elif (R_SEND_CONFIG == 104) || (R_SEND_CONFIG == 105)
  SEND_CONFIG_IN primData;
  primData.port = port;
  primData.captureSerOn = capture;
  primData.moduleNum[0] = module0;
  primData.moduleNum[1] = module1;
  primData.chipNum = chip;
  primData.setLinks = setLinks;             // Set links 
  primData.restore = restore;               // Restore links 
  primData.structId = bank;
  primData.groupId = group;
  primData.dataType = data;
  primData.activeOnly = active;
  primData.enableDataTaking = enableData;
  primList->addPrimitive(sizeof(SEND_CONFIG_IN)/4, 1, SEND_CONFIG, R_SEND_CONFIG, (long *)&primData);
#else
#error "Send config not compiled! (new prim version)" 
#endif
}

void PrimBuilder::writeModuleVariable(boost::shared_ptr<PrimListWrapper> primList, UINT32 dsp_bank_set, int group, int channel, int chip, int type, float value) {
#ifdef R_RW_MODULE_VARIABLE 
#if (R_RW_MODULE_VARIABLE == 103)
  size_t prim_size = sizeof(RwModuleVariableIn)/4;
  long* data = new long[prim_size+1];
  RwModuleVariableIn& prim = *(RwModuleVariableIn*)data;
  prim.fRead = false;
  prim.cfgSet = dsp_bank_set;
  prim.cfgBitfield = true;
  prim.groupId = group;
  prim.module = channel;
  prim.chip = chip;
  prim.varType = type;
  prim.info = Debug::getInstance()->checkDebugOption(DEBUG_MODULE_CONFIG);
  prim.dataLen = 1;
  MDAT32* p_val = (MDAT32*) data+prim_size;
  *p_val=value;
  primList->addPrimitive(prim_size+1, 1, RW_MODULE_VARIABLE, R_RW_MODULE_VARIABLE, (long*)&prim);
  delete[] data;
#elif (R_RW_MODULE_VARIABLE == 102 ) 
#warning "Old version of RW_MODULE_VARIABLE may be slow"
  std::cout << "using old version of RW_MODULE_VARIABLE - multiple prims" << std::endl;
  RW_MODULE_VARIABLE_IN prim;
  prim.read = 0;
  prim.groupId = group;
  prim.module = channel;
  prim.chip = chip;
  prim.varType = type;
  prim.info = 1;         // Send text message confirming what was done
  prim.dataLen = 1;
  prim.data = (MDAT32*)(*(unsigned int*)(&value));
  for (int i=0; i< N_MODULE_CONFIG_SETS; ++i){
    if (1<<i & cfgSet_bits){
      prim.structId = bank;
      primList->addPrimitive(sizeof(RW_MODULE_VARIABLE_IN)/4, 1, RW_MODULE_VARIABLE, R_RW_MODULE_VARIABLE, (long*)&prim);
    }
  }
#elif (R_RW_MODULE_VARIABLE == 101) 
#error "This one doesn't work"
#else 
#error "Modify config (ROD) not compiled! (new prim version)" 
#endif
#else 
#error "Modify config (ROD) not compiled! (primitive doesn't exist)" 
#endif
}

void PrimBuilder::bocHistogram(boost::shared_ptr<PrimListWrapper> primList, int delay, int width, int numEvents, 
                   struct ::CmdList trigger, int port) {
#ifdef R_BOC_HISTOGRAM
  BOC_HISTOGRAM_IN bocPrim;

#if (R_BOC_HISTOGRAM == 101)
  bocPrim.delay = delay;
  bocPrim.width = width;
  bocPrim.count = numEvents;
  bocPrim.cmdList = trigger;
  bocPrim.port = port;
#elif (R_BOC_HISTOGRAM == 100)
  bocPrim.numSamples = numEvents;
  bocPrim.numLoops = width;
#else
#warning "BOC_HISTOGRAM revision change"
#endif

  primList->addPrimitive(sizeof(BOC_HISTOGRAM_IN)/4, 1, BOC_HISTOGRAM, R_BOC_HISTOGRAM, (long*)&bocPrim);
#else 
#warning "BOC_HISTOGRAM not compiled"
#endif
}

void PrimBuilder::setTrigger(boost::shared_ptr<PrimListWrapper> primList, int currentBin, int histogramSet) 
{
  SET_TRIGGER_IN triggerPrim;

#if (R_SET_TRIGGER == 102)
  triggerPrim.bin = currentBin;
  triggerPrim.set = histogramSet;
#else
#warning "SET_TRIGGER revision change"
#endif

  primList->addPrimitive(sizeof(SET_TRIGGER_IN)/4, 1, SET_TRIGGER, R_SET_TRIGGER, (long*)&triggerPrim);
}

PrimBuilder& PrimBuilder::instance() {
  if(!singleton) {
    singleton = new PrimBuilder;
  }

  return *singleton;
}

---