Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Data Structures | File List | Namespace Members | Data Fields | Related Pages

PrimBuilder.cxx

00001 #include <algorithm>
00002 
00003 #include "CommonWithDsp/primParams.h"
00004 
00005 #include "RodCrate/RodPrimList.h"
00006 
00007 #include "PrimBuilder.h"
00008 #include "utility.h"
00009 
00010 using namespace SctApi;
00011 
00012 PrimBuilder *PrimBuilder::singleton = 0;
00013 
00014 PrimBuilder::PrimBuilder() {}
00015 
00016 void PrimBuilder::slavePrimList(boost::shared_ptr<PrimListWrapper> parentList, 
00017                                 boost::shared_ptr<PrimListWrapper> primList, 
00018                                 unsigned int slaveNumber, bool await, bool response) {
00019   try {
00020     primList->list->bufferBuild();
00021   } catch (SctPixelRod::PrimListException &p) {
00022     std::cout << "Exception building prim list for slave " << slaveNumber << std::endl;
00023     std::cout << p.getDescriptor() << " ";
00024     std::cout << p.getData1() << ", " << p.getData2() << "\n";
00025     return;
00026   }
00027 
00028   // Get a copy of buffer and use SEND_SLAVE_LIST/START_SLAVE_LIST primitives
00029   // to have MDSP send it to the slave
00030   long buffLength = primList->list->getBufferLength();
00031   unsigned long* bufferStart = primList->list->getBuffer();
00032 
00033   // Create Slave List primitives
00034   int offset = sizeof(SEND_SLAVE_LIST_IN)/4;
00035 
00036   long *slaveData = new long[offset+buffLength];
00037 
00038   SEND_SLAVE_LIST_IN &slaveList = *(SEND_SLAVE_LIST_IN *)slaveData;
00039 
00040 #if (R_SEND_SLAVE_LIST == 103)
00041   slaveList.slaveNumber = slaveNumber;
00042   slaveList.listLength = buffLength;
00043   slaveList.slavePrimList = (unsigned int*)DEFAULT;
00044   slaveList.slaveRepData = (unsigned int*)DEFAULT;
00045 #else 
00046 #error "SEND_SLAVE_LIST not compiled (new revision)"
00047 #endif
00048 
00049   // Copy prim list as send data
00050   for (int i=0; i< buffLength; i++) {
00051     slaveData[offset + i] = bufferStart[i];
00052   }
00053 
00054   parentList->addPrimitive(offset+buffLength, 1, SEND_SLAVE_LIST, R_SEND_SLAVE_LIST, slaveData);
00055 
00056   delete [] slaveData;
00057 
00058   startSlaveList(parentList, slaveNumber, await, response);
00059 }
00060 
00061 void PrimBuilder::startSlaveList(boost::shared_ptr<PrimListWrapper> primList, 
00062                                  unsigned int slaveNumber, bool await, bool response) {
00063   START_SLAVE_LIST_IN startPrim;
00064 #if (R_START_SLAVE_LIST == 103)
00065   startPrim.slaveNumber = slaveNumber;
00066   startPrim.pauseMasterList = await?1:0;
00067   startPrim.getSlaveReply = response?1:0;
00068 #else
00069 #error "START_SLAVE_LIST not compiled (new revision)"
00070 #endif
00071 
00072   primList->addPrimitive(sizeof(START_SLAVE_LIST_IN)/4, 2, START_SLAVE_LIST, R_START_SLAVE_LIST, (long*)&startPrim);
00073 }
00074 
00075 void PrimBuilder::echo(boost::shared_ptr<PrimListWrapper> primList, Utility::MemoryBlock block) {
00076 #if (R_ECHO != 100) 
00077 #error "ECHO revision changed!"
00078 #endif
00079 
00080   long *myData = new long[block.size()];
00081   std::copy(block.address(), block.address() + block.size(), myData);
00082   primList->addPrimitive(block.size(), 1, ECHO, R_ECHO, myData);
00083 
00084   delete [] myData;
00085 }
00086 
00087 void PrimBuilder::startSlave(boost::shared_ptr<PrimListWrapper> prim, int s) {
00088   START_SLAVE_EXECUTING_IN data;
00089   data.slaveNumber = s;              // Slave
00090   data.commOnOff = SLV_DSP_COMM_ON;  // Comm on
00091   data.slaveType = SLAVE_MONITOR;    // Mode
00092   data.timeoutInUsec = 0x200000;     // Timeout
00093 
00094   prim->addPrimitive(sizeof(START_SLAVE_EXECUTING_IN)/4, 1, START_SLAVE_EXECUTING, R_START_SLAVE_EXECUTING, (long *)&data);
00095 }
00096 
00097 void PrimBuilder::readFifo(boost::shared_ptr<PrimListWrapper> prim, int id, int bank, int elems) {
00098   RW_FIFO_IN fifo;
00099 #if (R_RW_FIFO == 104)
00100   fifo.fifoId = id;
00101   fifo.bank = bank;
00102   fifo.readNotWrite = 1;
00103   fifo.numElements = elems;
00104   fifo.dataBaseAdr = (UINT32 *)0xffffffff;
00105 #else
00106 #error "RW_FIFO revision change"
00107 #endif
00108 
00109   prim->addPrimitive(sizeof(RW_FIFO_IN)/4, 1, RW_FIFO, R_RW_FIFO, (long *)&fifo);
00110 }
00111 
00112 void PrimBuilder::pollRegister(boost::shared_ptr<PrimListWrapper> prim, int r, int off, int width, int val, int timeout) {
00113   POLL_REG_FIELD_IN poll;
00114 
00115 #if (R_POLL_REG_FIELD == 105)
00116   poll.registerID = r;
00117   poll.offset = off;
00118   poll.width = width;
00119   poll.desiredValue = val;
00120   poll.timeoutInUsec = timeout;
00121 #else
00122 #error "POLL_REG_FIELD revision changed"
00123 #endif
00124 
00125   prim->addPrimitive(sizeof(POLL_REG_FIELD_IN)/4, 1, POLL_REG_FIELD, R_POLL_REG_FIELD, (long*)&poll);
00126 }
00127 
00128 void PrimBuilder::taskOp(boost::shared_ptr<PrimListWrapper> prim, int typ, int op, int data) {
00129   TASK_OPERATION_IN taskOp;
00130 #if (R_TASK_OPERATION == 100) 
00131   taskOp.taskType = typ;
00132   taskOp.taskOperation = op;
00133   taskOp.data = data;
00134 #else 
00135 #error "TASK_OPERATION revision change"
00136 #endif
00137 
00138   prim->addPrimitive(sizeof(TASK_OPERATION_IN)/4, 1, TASK_OPERATION, R_TASK_OPERATION, (long*)&taskOp);
00139 }
00140 
00141 void PrimBuilder::readRegister(boost::shared_ptr<PrimListWrapper> prim, int r) {
00142   RW_REG_FIELD_IN rField;
00143 #if (R_RW_REG_FIELD == 103) || (R_RW_REG_FIELD == 104) || (R_RW_REG_FIELD == 105)
00144   rField.registerID = r;
00145   rField.offset = 0;
00146   rField.width = 32;
00147   rField.readNotWrite = 1;
00148   rField.dataIn = 0; // Unused!
00149 #else
00150 #error "RW_REG_FIELD revision change"
00151 #endif
00152 
00153   prim->addPrimitive(sizeof(RW_REG_FIELD_IN)/4, 5, RW_REG_FIELD, R_RW_REG_FIELD, (long *)&rField);
00154 }
00155 
00156 void PrimBuilder::writeRegister(boost::shared_ptr<PrimListWrapper> prim, int r, int off, int wid, int value) {
00157   RW_REG_FIELD_IN rField;
00158 #if (R_RW_REG_FIELD == 103) || (R_RW_REG_FIELD == 104) || (R_RW_REG_FIELD == 105)
00159   rField.registerID = r;
00160   rField.offset = off;
00161   rField.width = wid;
00162   rField.readNotWrite = 0;
00163   rField.dataIn = value;
00164 #else
00165 #error "RW_REG_FIELD revision change"
00166 #endif
00167 
00168   prim->addPrimitive(sizeof(RW_REG_FIELD_IN)/4, 5, RW_REG_FIELD, R_RW_REG_FIELD, (long *)&rField);
00169 }
00170 
00171 void PrimBuilder::sendStream(boost::shared_ptr<PrimListWrapper> prim, int cmdBuff, bool capture) {
00172   SEND_STREAM_IN sendStream;
00173 
00174 #if (R_SEND_STREAM == 100)
00175   sendStream.cmdBuff = cmdBuff;
00176   sendStream.captureSerOn = capture;
00177 #else
00178 #error "SEND_STREAM revision change"
00179 #endif
00180 
00181   prim->addPrimitive(sizeof(SEND_STREAM_IN)/4, 3, SEND_STREAM, R_SEND_STREAM, (long *)&sendStream);
00182 }
00183 
00184 void PrimBuilder::startEvTrap(boost::shared_ptr<PrimListWrapper> prim) {
00185   long trap[0] = {};
00186 
00187 #if (R_START_EVENT_TRAPPING != 101)
00188 #error "START_EVENT_TRAPPING revision change"
00189 #endif
00190 
00191   prim->addPrimitive(0, 0, START_EVENT_TRAPPING, R_START_EVENT_TRAPPING, trap);
00192 }
00193 
00194 void PrimBuilder::stopEvTrap(boost::shared_ptr<PrimListWrapper> prim) {
00195   long trap[0] = {};
00196 
00197 #if (R_STOP_EVENT_TRAPPING != 100)
00198 #error "STOP_EVENT_TRAPPING revision change"
00199 #endif
00200 
00201   prim->addPrimitive(0, 0, STOP_EVENT_TRAPPING, R_STOP_EVENT_TRAPPING, trap);
00202 }
00203 
00204 void PrimBuilder::setMemory(boost::shared_ptr<PrimListWrapper> primList, unsigned long address, unsigned long words, long value) {
00205   SET_MEMORY_IN prim;
00206 
00207 #if (R_SET_MEMORY == 100)
00208   prim.start = (UINT32 *)address;
00209   prim.size = words;
00210   prim.val = value;
00211 #else 
00212 #error "SET_MEMORY revision changed"
00213 #endif
00214 
00215   primList->addPrimitive(sizeof(SET_MEMORY_IN)/4, 1, SET_MEMORY, R_SET_MEMORY, (const long *)&prim);
00216 }
00217 
00218 void PrimBuilder::readSlaveMemory(boost::shared_ptr<PrimListWrapper> primList, unsigned long slave, unsigned long address, unsigned long words) {
00219   RW_SLAVE_MEMORY_IN rwPrim;
00220 
00221 #if (R_RW_SLAVE_MEMORY == 100)
00222   rwPrim.slaveNumber = slave;
00223   rwPrim.readNotWrite = 1;
00224   rwPrim.slaveAddress = (UINT32 *)address;
00225   rwPrim.masterAddress = (UINT32 *)0xffffffff;
00226   rwPrim.numWords = words;
00227 #else
00228 #error "RW_SLAVE_MEMORY revision change"
00229 #endif
00230 
00231   primList->addPrimitive(sizeof(RW_SLAVE_MEMORY_IN)/4, 1, RW_SLAVE_MEMORY, R_RW_SLAVE_MEMORY, (long*)&rwPrim);
00232 }
00233 
00234 void PrimBuilder::writeSlaveMemory(boost::shared_ptr<PrimListWrapper> primList, 
00235                                    unsigned long slave, unsigned long address, unsigned long length, unsigned long *data) {
00236   long *primData = new long[sizeof(RW_SLAVE_MEMORY_IN)/4 + length];
00237 
00238   RW_SLAVE_MEMORY_IN &rwPrim = *(RW_SLAVE_MEMORY_IN*)primData;
00239 
00240 #if (R_RW_SLAVE_MEMORY == 100)
00241   rwPrim.slaveNumber = slave;
00242   rwPrim.readNotWrite = 0;
00243   rwPrim.slaveAddress = (UINT32 *)address;
00244   rwPrim.masterAddress = (UINT32 *)0xffffffff;
00245   rwPrim.numWords = length;
00246 #else
00247 #error "RW_SLAVE_MEMORY revision change"
00248 #endif
00249 
00250   std::copy(data, data + length, primData + 5);
00251 
00252   primList->addPrimitive(sizeof(RW_SLAVE_MEMORY_IN)/4 + length, 
00253                          1, RW_SLAVE_MEMORY, R_RW_SLAVE_MEMORY, primData);
00254 }
00255 
00256 void PrimBuilder::rodMode(boost::shared_ptr<PrimListWrapper> rodModeList, 
00257                           int mode, int flag, int fifoSetup, int nBits, int delay, int message) {
00258 #ifndef SET_ROD_MODE
00259   throw SctApiException("Set Rod Mode wasn't compiled");
00260 #else
00261   SET_ROD_MODE_IN rodPrim;
00262 
00263 #if (R_SET_ROD_MODE == 101)
00264   rodPrim.mode = mode;
00265   rodPrim.flag = flag;
00266   rodPrim.fifoSetup = fifoSetup;
00267   rodPrim.nBits = nBits;
00268   rodPrim.delay = delay;
00269   rodPrim.evtsPerL1A = 1;         // This is a pixel thing!
00270   rodPrim.message = message;
00271 #else
00272   throw SctApiException("Set Rod Mode wasn't compiled (wrong prim version)");
00273 // #error "SET_ROD_MODE revision change"
00274 #endif
00275 
00276   rodModeList->addPrimitive(sizeof(SET_ROD_MODE_IN)/4, 
00277                             1, SET_ROD_MODE, R_SET_ROD_MODE, (long *)&rodPrim);
00278 #endif
00279 }
00280 
00281 void PrimBuilder::moduleMask(boost::shared_ptr<PrimListWrapper> maskList, 
00282                              int module, int port, int useStructSet, int passOn, int slvs,
00283                              int cmdLine, int dataLine0, int dataLine1, // 2 and 3 only for pixels
00284                              int cfg, int modMask0, int modMask1, int maskType, int storage, int maskSet) { 
00285 #if (R_MODULE_MASK == 101)
00286   // Load module masks
00287   MODULE_MASK_IN maskPrim;
00288   maskPrim.moduleNum = module;
00289   maskPrim.port = port;
00290   maskPrim.useStructSet = useStructSet;
00291   maskPrim.passOn = passOn;
00292   maskPrim.slvBits = slvs;
00293   maskPrim.cmdLine = cmdLine;
00294   maskPrim.dataLine[0] = dataLine0;
00295   maskPrim.dataLine[1] = dataLine1;
00296   maskPrim.dataLine[2] = 0;   // Pixels only 
00297   maskPrim.dataLine[3] = 0;   // Pixels only 
00298   maskPrim.cfg = cfg;               // Don't do manual mask bits set up
00299   maskPrim.modMask[0] = modMask0;
00300   maskPrim.modMask[1] = modMask1;
00301   maskPrim.maskType = maskType;
00302   maskPrim.storage = storage;
00303   maskPrim.maskSet = maskSet;
00304 
00305   maskList->addPrimitive(sizeof(MODULE_MASK_IN)/4,
00306                          1, MODULE_MASK, R_MODULE_MASK, (long *)&maskPrim);
00307 #elif (R_MODULE_MASK == 100) 
00308 #warning "MODULE_MASK method not compiled"
00309 #else 
00310 #error "MODULE_MASK revision change"
00311 #endif
00312 }
00313 
00314 void PrimBuilder::masksFromConfig(boost::shared_ptr<PrimListWrapper> maskList, int port) { 
00315   // Everything ignored except          this
00316   moduleMask(maskList, ALL_MODULES, port, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
00317 }
00318 
00319 void PrimBuilder::masksToSlaves(boost::shared_ptr<PrimListWrapper> maskList, int slvBits) { 
00320   // Use struct set and pass on...
00321   moduleMask(maskList, ALL_MODULES, 0, 0, 1, slvBits,
00322              // The rest is ignored
00323              0, 0, 0, 0, 0, 0, 0, 0, 0);
00324 }
00325 
00326 void PrimBuilder::readModuleData(boost::shared_ptr<PrimListWrapper> primList, int bank, int channel) {
00327   RW_MODULE_DATA_IN primData;
00328 
00329 #if (R_RW_MODULE_DATA == 101) || (R_RW_MODULE_DATA == 102)
00330   primData.readNotWrite = 1;
00331   primData.structId = bank;
00332   primData.moduleNum = channel;
00333 #elif (R_RW_MODULE_DATA == 100)
00334   primData.readNotWrite = 1;
00335   primData.structID = bank;
00336   primData.moduleNum = channel;
00337 #else
00338 #error "RW_MODULE_DATA not compiled (primitive change)"
00339 #endif
00340 
00341   // Ignore configdata as this is a read
00342   primList->addPrimitive(sizeof(RW_MODULE_DATA_IN)/4, 1, RW_MODULE_DATA, R_RW_MODULE_DATA, (long*)&primData);
00343 }
00344 
00345 void PrimBuilder::writeModuleData(boost::shared_ptr<PrimListWrapper> primList, const ABCDModule* module, int bank, int channel) {
00346   const unsigned int longsInConfig = sizeof(ABCDModule) / 4;
00347 
00348   long *configData = new long[sizeof(RW_MODULE_DATA_IN)/4+longsInConfig];
00349 
00350   RW_MODULE_DATA_IN &params = *(RW_MODULE_DATA_IN*)configData;
00351 #if (R_RW_MODULE_DATA == 101) || (R_RW_MODULE_DATA == 102)
00352   params.readNotWrite = 0;
00353   params.structId = bank;
00354   params.moduleNum = channel;
00355   params.configData = (ABCDModule *)0xffffffff;
00356 #else
00357 #error "RW_MODULE_DATA not compiled (primitive change)"
00358 #endif
00359 
00360   // Overwrite params.configData with the first word of the config (hence 3 not 4 and -1 in next line)
00361   std::copy((long *)module, ((long*)module)+longsInConfig, configData+3);
00362 
00363   primList->addPrimitive(sizeof(RW_MODULE_DATA_IN)/4+longsInConfig-1, 1, RW_MODULE_DATA, R_RW_MODULE_DATA, configData);
00364 
00365   delete [] configData;
00366 }
00367 
00368 void PrimBuilder::sendConfig(boost::shared_ptr<PrimListWrapper> primList, 
00369                              int port, int capture, int module0, int module1, int chip, int setLinks, int restore, 
00370                              int bank, int group, int data, int active, int enableData) {
00371   if (enableData!=0) {
00372     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.
00373   }
00374   SEND_CONFIG_IN primData;
00375 
00376 #if (R_SEND_CONFIG == 104) || (R_SEND_CONFIG == 105)
00377   primData.port = port;
00378   primData.captureSerOn = capture;
00379   primData.moduleNum[0] = module0;
00380   primData.moduleNum[1] = module1;
00381   primData.chipNum = chip;
00382   primData.setLinks = setLinks;             // Set links 
00383   primData.restore = restore;               // Restore links 
00384   primData.structId = bank;
00385   primData.groupId = group;
00386   primData.dataType = data;
00387   primData.activeOnly = active;
00388   primData.enableDataTaking = enableData;
00389 #else
00390 #error "Send config not compiled! (new prim version)" 
00391 #endif
00392 
00393   primList->addPrimitive(sizeof(SEND_CONFIG_IN)/4, 1, SEND_CONFIG, R_SEND_CONFIG, (long *)&primData);
00394 }
00395 
00396 void PrimBuilder::writeModuleVariable(boost::shared_ptr<PrimListWrapper> primList, int bank, int group, int channel, int chip, int type, float value) {
00397 #if (defined(RW_MODULE_VARIABLE) && defined(R_RW_MODULE_VARIABLE)) 
00398   RW_MODULE_VARIABLE_IN prim;
00399 
00400 #if (R_RW_MODULE_VARIABLE == 101) 
00401 #warning "This one doesn't work"
00402 #elif (R_RW_MODULE_VARIABLE == 102) 
00403   prim.read = 0;
00404   prim.structId = bank;
00405   prim.groupId = group;
00406   prim.module = channel;
00407   prim.chip = chip;
00408   prim.varType = type;
00409   prim.info = 1;         // Send text message confirming what was done
00410   prim.dataLen = 1;
00411   prim.data = (MDAT32*)(*(unsigned int*)(&value));
00412 #else 
00413 #warning "Modify config (ROD) not compiled! (new prim version)" 
00414 #endif
00415 
00416   primList->addPrimitive(sizeof(RW_MODULE_VARIABLE_IN)/4, 1, RW_MODULE_VARIABLE, R_RW_MODULE_VARIABLE, (long*)&prim);
00417 #else 
00418 #warning "Modify config (ROD) not compiled! (primitive doesn't exist)" 
00419 #endif
00420 }
00421 
00422 void PrimBuilder::bocHistogram(boost::shared_ptr<PrimListWrapper> primList, int samples, int numLoops) {
00423 #ifdef R_BOC_HISTOGRAM
00424   BOC_HISTOGRAM_IN bocPrim;
00425 
00426 #if (R_BOC_HISTOGRAM == 100)
00427   bocPrim.numSamples = samples;
00428   bocPrim.numLoops = numLoops;
00429 #else
00430 #warning "BOC_HISTOGRAM revision change"
00431 #endif
00432 
00433   primList->addPrimitive(sizeof(BOC_HISTOGRAM_IN)/4, 1, BOC_HISTOGRAM, R_BOC_HISTOGRAM, (long*)&bocPrim);
00434 #else 
00435   std::cout << "BOC_HISTOGRAM not compiled\n";
00436 #endif
00437 }
00438 
00439 void PrimBuilder::setTrigger(boost::shared_ptr<PrimListWrapper> primList, int currentBin, int histogramSet) 
00440 {
00441   SET_TRIGGER_IN triggerPrim;
00442 
00443 #if (R_SET_TRIGGER == 102)
00444   triggerPrim.bin = currentBin;
00445   triggerPrim.set = histogramSet;
00446 #else
00447 #warning "SET_TRIGGER revision change"
00448 #endif
00449 
00450   primList->addPrimitive(sizeof(SET_TRIGGER_IN)/4, 1, SET_TRIGGER, R_SET_TRIGGER, (long*)&triggerPrim);
00451 }
00452 
00453 PrimBuilder& PrimBuilder::instance() {
00454   if(!singleton) {
00455     singleton = new PrimBuilder;
00456   }
00457 
00458   return *singleton;
00459 }
00460 

Generated on Fri Sep 16 18:01:54 2005 for SCT DAQ/DCS Software - C++ by doxygen 1.3.5