pxar
 All Classes Namespaces Functions Variables Typedefs Friends
dictionaries.h
1 
10 #ifndef PXAR_DICTIONARIES_H
11 #define PXAR_DICTIONARIES_H
12 
14 #if ((defined WIN32) && (defined __CINT__))
15 typedef unsigned char uint8_t;
16 #else
17 #include <stdint.h>
18 #endif
19 
20 #include <string>
21 #include <map>
22 #include "constants.h"
23 #include <iostream>
24 
25 #define DTB_REG 0xFF
26 #define TBM_REG 0x0F
27 #define ROC_REG 0x00
28 #define PG_ERR 0xFF00
29 
30 #define PROBE_ANALOG PROBEA_OFF
31 #define PROBE_DIGITAL PROBE_OFF
32 #define PROBE_NONE 0xFF
33 
34 namespace pxar {
35 
39  class dacConfig {
40  public:
41  dacConfig() {}
42  dacConfig(uint8_t id, uint8_t size) : _type(0), _id(id), _size(size), _preferred(true) {}
43  dacConfig(uint8_t id, uint8_t size, uint8_t type) : _type(type), _id(id), _size(size), _preferred(true) {}
44  dacConfig(uint8_t id, uint8_t size, uint8_t type, bool preferred) : _type(type), _id(id), _size(size), _preferred(preferred) {}
45  uint8_t _type;
46  uint8_t _id;
47  uint8_t _size;
48  bool _preferred;
49  };
50 
51 
56  class RegisterDictionary {
57  public:
58  static RegisterDictionary * getInstance() {
59  static RegisterDictionary instance; // Guaranteed to be destroyed.
60  // Instantiated on first use.
61  return &instance;
62  }
63 
64  // Return the register id for the name in question:
65  inline uint8_t getRegister(std::string name, uint8_t type) {
66  if(_registers.find(name)->second._type == type) {
67  return _registers.find(name)->second._id;
68  }
69  else { return type;}
70  }
71 
72  // Return the register size for the register in question:
73  inline uint8_t getSize(std::string name, uint8_t type) {
74  if(_registers.find(name)->second._type == type) {
75  return _registers.find(name)->second._size;
76  }
77  else { return type;}
78  }
79 
80  // Return the register size for the register in question:
81  inline uint8_t getSize(uint8_t id, uint8_t type) {
82  for(std::map<std::string, dacConfig>::iterator iter = _registers.begin(); iter != _registers.end(); ++iter) {
83  if((*iter).second._type == type && (*iter).second._id == id) {
84  return (*iter).second._size;
85  }
86  }
87  return type;
88  }
89 
90  // Return the register name for the register in question:
91  inline std::string getName(uint8_t id, uint8_t type) {
92  for(std::map<std::string, dacConfig>::iterator iter = _registers.begin(); iter != _registers.end(); ++iter) {
93  if((*iter).second._type == type && (*iter).second._id == id && (*iter).second._preferred == true) {
94  return (*iter).first;}
95  }
96  return "";
97  }
98 
99  // Return all (preferred) register names for the type in question:
100  inline std::vector<std::string> getAllNames(uint8_t type) {
101  std::vector<std::string> names;
102  for(std::map<std::string, dacConfig>::iterator iter = _registers.begin(); iter != _registers.end(); ++iter) {
103  if((*iter).second._type == type && (*iter).second._preferred == true) {
104  names.push_back((*iter).first);
105  }
106  }
107  return names;
108  }
109 
110  // Return all (preferred) register names for a single type:
111  inline std::vector<std::string> getAllROCNames() {return getAllNames(ROC_REG);}
112  inline std::vector<std::string> getAllDTBNames() {return getAllNames(DTB_REG);}
113  inline std::vector<std::string> getAllTBMNames() {return getAllNames(TBM_REG);}
114 
115  private:
116  RegisterDictionary() {
117  //------- DTB registers -----------------------------
118  _registers["clk"] = dacConfig(SIG_CLK,255,DTB_REG);
119  _registers["ctr"] = dacConfig(SIG_CTR,255,DTB_REG);
120  _registers["sda"] = dacConfig(SIG_SDA,255,DTB_REG);
121  _registers["tin"] = dacConfig(SIG_TIN,255,DTB_REG);
122  _registers["level"] = dacConfig(SIG_LEVEL,15,DTB_REG);
123  _registers["triggerdelay"] = dacConfig(SIG_LOOP_TRIGGER_DELAY,255,DTB_REG);
124  _registers["deser160phase"] = dacConfig(SIG_DESER160PHASE,7,DTB_REG);
125 
126  _registers["tout"] = dacConfig(SIG_RDA_TOUT,19,DTB_REG);
127  _registers["rda"] = dacConfig(SIG_RDA_TOUT,19,DTB_REG);
128 
129 
130  //------- TBM registers -----------------------------
131  _registers["counters"] = dacConfig(TBM_REG_COUNTER_SWITCHES,255,TBM_REG,false);
132  _registers["base0"] = dacConfig(TBM_REG_COUNTER_SWITCHES,255,TBM_REG);
133 
134  _registers["mode"] = dacConfig(TBM_REG_SET_MODE,255,TBM_REG,false);
135  _registers["base2"] = dacConfig(TBM_REG_SET_MODE,255,TBM_REG);
136 
137  _registers["clear"] = dacConfig(TBM_REG_CLEAR_INJECT,255,TBM_REG,false);
138  _registers["inject"] = dacConfig(TBM_REG_CLEAR_INJECT,255,TBM_REG,false);
139  _registers["base4"] = dacConfig(TBM_REG_CLEAR_INJECT,255,TBM_REG);
140 
141  _registers["pkam_set"] = dacConfig(TBM_REG_SET_PKAM_COUNTER,255,TBM_REG,false);
142  _registers["base8"] = dacConfig(TBM_REG_SET_PKAM_COUNTER,255,TBM_REG);
143 
144  _registers["delays"] = dacConfig(TBM_REG_SET_DELAYS,255,TBM_REG,false);
145  _registers["basea"] = dacConfig(TBM_REG_SET_DELAYS,255,TBM_REG);
146 
147  _registers["autoreset"] = dacConfig(TBM_REG_TEMPERATURE_CONTROL,255,TBM_REG,false);
148  _registers["basec"] = dacConfig(TBM_REG_TEMPERATURE_CONTROL,255,TBM_REG);
149  // In the old TBM these were the temperature registers:
150  _registers["temperature"] = dacConfig(TBM_REG_TEMPERATURE_CONTROL,255,TBM_REG,false);
151 
152  _registers["cores"] = dacConfig(TBM_REG_CORES_A_B,255,TBM_REG,false);
153  _registers["basee"] = dacConfig(TBM_REG_CORES_A_B,255,TBM_REG);
154 
155 
156  //------- ROC registers -----------------------------
157  // DAC name, register and size reference:
158  // http://cms.web.psi.ch/phase1/psi46dig/index.html
159 
160  _registers["vdig"] = dacConfig(ROC_DAC_Vdig,15,ROC_REG);
161  _registers["vdd"] = dacConfig(ROC_DAC_Vdig,15,ROC_REG,false);
162 
163  _registers["vana"] = dacConfig(ROC_DAC_Vana,255,ROC_REG);
164  _registers["iana"] = dacConfig(ROC_DAC_Vana,255,ROC_REG,false);
165 
166  _registers["vsf"] = dacConfig(ROC_DAC_Vsh,255,ROC_REG,false);
167  _registers["vsh"] = dacConfig(ROC_DAC_Vsh,255,ROC_REG);
168 
169  _registers["vcomp"] = dacConfig(ROC_DAC_Vcomp,15,ROC_REG);
170 
171  _registers["vwllpr"] = dacConfig(ROC_DAC_VwllPr,255,ROC_REG);
172  _registers["fbpre"] = dacConfig(ROC_DAC_VwllPr,255,ROC_REG,false);
173 
174  _registers["vwllsh"] = dacConfig(ROC_DAC_VwllSh,255,ROC_REG);
175  _registers["fbsh"] = dacConfig(ROC_DAC_VwllSh,255,ROC_REG,false);
176 
177  _registers["vhlddel"] = dacConfig(ROC_DAC_VhldDel,255,ROC_REG);
178  _registers["holddel"] = dacConfig(ROC_DAC_VhldDel,255,ROC_REG,false);
179 
180  _registers["vtrim"] = dacConfig(ROC_DAC_Vtrim,255,ROC_REG);
181  _registers["trimscale"] = dacConfig(ROC_DAC_Vtrim,255,ROC_REG,false);
182 
183  _registers["vthrcomp"] = dacConfig(ROC_DAC_VthrComp,255,ROC_REG);
184  _registers["globalthr"] = dacConfig(ROC_DAC_VthrComp,255,ROC_REG,false);
185 
186  _registers["vibias_bus"] = dacConfig(ROC_DAC_VIBias_Bus,255,ROC_REG);
187 
188  _registers["voffsetro"] = dacConfig(ROC_DAC_VoffsetRO,255,ROC_REG,false);
189  _registers["voffsetr0"] = dacConfig(ROC_DAC_VoffsetRO,255,ROC_REG,false);
190  _registers["phoffset"] = dacConfig(ROC_DAC_VoffsetRO,255,ROC_REG);
191 
192  _registers["vcomp_adc"] = dacConfig(ROC_DAC_VIbias_PH,255,ROC_REG);
193  _registers["vibias_ph"] = dacConfig(ROC_DAC_VIbias_PH,255,ROC_REG,false);
194  _registers["adcpower"] = dacConfig(ROC_DAC_VIbias_PH,255,ROC_REG,false);
195 
196  _registers["viref_adc"] = dacConfig(ROC_DAC_VIbias_DAC,255,ROC_REG,false);
197  _registers["vibias_dac"] = dacConfig(ROC_DAC_VIbias_DAC,255,ROC_REG,false);
198  _registers["ibias_dac"] = dacConfig(ROC_DAC_VIbias_DAC,255,ROC_REG,false);
199  _registers["phscale"] = dacConfig(ROC_DAC_VIbias_DAC,255,ROC_REG);
200 
201  _registers["vicolor"] = dacConfig(ROC_DAC_VIColOr,255,ROC_REG);
202 
203  _registers["vcal"] = dacConfig(ROC_DAC_Vcal,255,ROC_REG);
204 
205  _registers["caldel"] = dacConfig(ROC_DAC_CalDel,255,ROC_REG);
206 
207  _registers["ctrlreg"] = dacConfig(ROC_DAC_CtrlReg,255,ROC_REG);
208  _registers["ccr"] = dacConfig(ROC_DAC_CtrlReg,255,ROC_REG,false);
209 
210  _registers["wbc"] = dacConfig(ROC_DAC_WBC,255,ROC_REG);
211 
212  _registers["readback"] = dacConfig(ROC_DAC_Readback,15,ROC_REG);
213  _registers["rbreg"] = dacConfig(ROC_DAC_Readback,15,ROC_REG,false);
214 
215  // DACs removed from psi46digV3 (?):
216  _registers["vbias_sf"] = dacConfig(ROC_DAC_Vbias_sf,15,ROC_REG);
217  _registers["voffsetop"] = dacConfig(ROC_DAC_VoffsetOp,255,ROC_REG);
218  _registers["vion"] = dacConfig(ROC_DAC_VIon,255,ROC_REG);
219 
220  // DACs removed from psi46digV2:
221  _registers["vleak_comp"] = dacConfig(ROC_DAC_Vleak_comp,255,ROC_REG);
222  _registers["vleak"] = dacConfig(ROC_DAC_Vleak_comp,255,ROC_REG);
223 
224  _registers["vrgpr"] = dacConfig(ROC_DAC_VrgPr,255,ROC_REG);
225  _registers["vrgsh"] = dacConfig(ROC_DAC_VrgSh,255,ROC_REG);
226 
227  _registers["vibiasop"] = dacConfig(ROC_DAC_VIbiasOp,255,ROC_REG);
228  _registers["vbias_op"] = dacConfig(ROC_DAC_VIbiasOp,255,ROC_REG,false);
229 
230  _registers["vibias_roc"] = dacConfig(ROC_DAC_VIbias_roc,255,ROC_REG);
231  _registers["vnpix"] = dacConfig(ROC_DAC_Vnpix,255,ROC_REG);
232  _registers["vsumcol"] = dacConfig(ROC_DAC_VsumCol,255,ROC_REG);
233  }
234 
235  std::map<std::string, dacConfig> _registers;
236  // Dont forget to declare these two. You want to make sure they
237  // are unaccessable otherwise you may accidently get copies of
238  // your singleton appearing.
239  RegisterDictionary(RegisterDictionary const&); // Don't Implement
240  void operator=(RegisterDictionary const&); // Don't implement
241  };
242 
243 
248  class DeviceDictionary {
249  public:
250  static DeviceDictionary * getInstance() {
251  static DeviceDictionary instance; // Guaranteed to be destroyed.
252  // Instantiated on first use.
253  return &instance;
254  }
255 
256  // Return the register id for the name in question:
257  inline uint8_t getDevCode(std::string name) {
258  if(_devices.find(name) != _devices.end()) { return _devices[name]; }
259  else { return 0x0; }
260  }
261 
262  // Return the signal name for the probe signal in question:
263  inline std::string getName(uint8_t devCode) {
264  for(std::map<std::string, uint8_t>::iterator iter = _devices.begin(); iter != _devices.end(); ++iter) {
265  if((*iter).second == devCode) { return (*iter).first; }
266  }
267  return "";
268  }
269 
270  private:
271  DeviceDictionary() {
272  // Device name and types
273 
274  // ROC flavors:
275  _devices["psi46v2"] = ROC_PSI46V2;
276  _devices["psi46xdb"] = ROC_PSI46XDB;
277  _devices["psi46dig"] = ROC_PSI46DIG;
278  _devices["psi46dig_trig"] = ROC_PSI46DIG_TRIG;
279  _devices["psi46digv2_b"] = ROC_PSI46DIGV2_B;
280  _devices["psi46digv2"] = ROC_PSI46DIGV2;
281  _devices["psi46digv2.1"] = ROC_PSI46DIGV21;
282  _devices["psi46digv21"] = ROC_PSI46DIGV21;
283  _devices["psi46digv21respin"] = ROC_PSI46DIGV21RESPIN;
284  // This name is not correct, but kept for legacy reasons:
285  _devices["psi46digv3"] = ROC_PSI46DIGV21;
286 
287  // TBM flavors:
288  _devices["tbm08"] = TBM_08;
289  _devices["tbm08a"] = TBM_08A;
290  _devices["tbm08b"] = TBM_08B;
291  _devices["tbm09"] = TBM_09;
292  }
293 
294  std::map<std::string, uint8_t> _devices;
295  DeviceDictionary(DeviceDictionary const&); // Don't Implement
296  void operator=(DeviceDictionary const&); // Don't implement
297  };
298 
299 
304  class ProbeDictionary {
305  public:
306  static ProbeDictionary * getInstance() {
307  static ProbeDictionary instance; // Guaranteed to be destroyed.
308  // Instantiated on first use.
309  return &instance;
310  }
311 
312  // Return the signal id for the probe signal in question:
313  inline uint8_t getSignal(std::string name, uint8_t type) {
314  // Looking for digital probe signal:
315  if(type == PROBE_DIGITAL && _signals.find(name)->second._signal_dig != PROBE_NONE) {
316  return _signals.find(name)->second._signal_dig;
317  }
318  // Looking for analog probe signal:
319  else if(type == PROBE_ANALOG && _signals.find(name)->second._signal_ana != PROBE_NONE) {
320  return _signals.find(name)->second._signal_ana;
321  }
322  // Couldn't find any matching signal:
323  else { return type; }
324  }
325 
326  // Return the signal name for the probe signal in question:
327  inline std::string getName(uint8_t signal, uint8_t type) {
328  for(std::map<std::string, probeConfig>::iterator iter = _signals.begin(); iter != _signals.end(); ++iter) {
329  if(type == PROBE_DIGITAL && iter->second._signal_dig == signal && iter->second._preferred == true) {
330  return (*iter).first;
331  }
332  else if(type == PROBE_ANALOG && iter->second._signal_ana == signal && iter->second._preferred == true) {
333  return (*iter).first;
334  }
335  }
336  return "";
337  }
338 
339  // Return all (preferred) signal names for the type in question:
340  inline std::vector<std::string> getAllNames(uint8_t type) {
341  std::vector<std::string> names;
342  for(std::map<std::string, probeConfig>::iterator iter = _signals.begin(); iter != _signals.end(); ++iter) {
343  if(((type == PROBE_DIGITAL && iter->second._signal_dig != PROBE_NONE)
344  || (type == PROBE_ANALOG && iter->second._signal_ana != PROBE_NONE))
345  && (*iter).second._preferred == true) {
346  names.push_back((*iter).first);
347  }
348  }
349  return names;
350  }
351 
352  // Return all (preferred) signal names for a single type:
353  inline std::vector<std::string> getAllAnalogNames() {return getAllNames(PROBE_ANALOG);}
354  inline std::vector<std::string> getAllDigitalNames() {return getAllNames(PROBE_DIGITAL);}
355 
356  private:
357 
360  class probeConfig {
361  public:
362  probeConfig() {}
363  probeConfig(uint8_t signal_dig, uint8_t signal_ana, bool preferred = true) : _signal_dig(signal_dig), _signal_ana(signal_ana), _preferred(preferred) {}
364  uint8_t _signal_dig;
365  uint8_t _signal_ana;
366  bool _preferred;
367  };
368 
369  ProbeDictionary() {
370  // Probe name and values
371 
372  // Signals accessible via both analog and digital ports:
373  _signals["tin"] = probeConfig(PROBE_TIN,PROBEA_TIN);
374  _signals["ctr"] = probeConfig(PROBE_CTR,PROBEA_CTR);
375  _signals["clk"] = probeConfig(PROBE_CLK,PROBEA_CLK);
376  _signals["sda"] = probeConfig(PROBE_SDA,PROBEA_SDA);
377  _signals["tout"] = probeConfig(PROBE_TOUT,PROBEA_TOUT);
378  _signals["rda"] = probeConfig(PROBE_TOUT,PROBEA_TOUT);
379  _signals["off"] = probeConfig(PROBE_OFF,PROBEA_OFF);
380 
381  // Purely digital signals:
382  _signals["sdasend"] = probeConfig(PROBE_SDA_SEND,PROBE_NONE);
383  _signals["pgtok"] = probeConfig(PROBE_PG_TOK,PROBE_NONE);
384  _signals["pgtrg"] = probeConfig(PROBE_PG_TRG,PROBE_NONE);
385  _signals["pgcal"] = probeConfig(PROBE_PG_CAL,PROBE_NONE);
386 
387  _signals["pgresr"] = probeConfig(PROBE_PG_RES_ROC,PROBE_NONE,false);
388  _signals["pgresroc"] = probeConfig(PROBE_PG_RES_ROC,PROBE_NONE);
389 
390  _signals["pgrest"] = probeConfig(PROBE_PG_RES_TBM,PROBE_NONE,false);
391  _signals["pgrestbm"] = probeConfig(PROBE_PG_RES_TBM,PROBE_NONE);
392 
393  _signals["pgsync"] = probeConfig(PROBE_PG_SYNC,PROBE_NONE);
394 
395  _signals["clkp"] = probeConfig(PROBE_CLK_PRESEN,PROBE_NONE);
396  _signals["clkpresent"] = probeConfig(PROBE_CLK_PRESEN,PROBE_NONE,false);
397 
398  _signals["clkg"] = probeConfig(PROBE_CLK_GOOD,PROBE_NONE);
399  _signals["clkgood"] = probeConfig(PROBE_CLK_GOOD,PROBE_NONE,false);
400 
401  _signals["daq0wr"] = probeConfig(PROBE_DAQ0_WR,PROBE_NONE);
402  _signals["crc"] = probeConfig(PROBE_CRC,PROBE_NONE);
403  _signals["adcrunning"] = probeConfig(PROBE_ADC_RUNNING,PROBE_NONE);
404  _signals["adcrun"] = probeConfig(PROBE_ADC_RUN,PROBE_NONE);
405  _signals["adcpgate"] = probeConfig(PROBE_ADC_PGATE,PROBE_NONE);
406  _signals["adcstart"] = probeConfig(PROBE_ADC_START,PROBE_NONE);
407  _signals["adcsgate"] = probeConfig(PROBE_ADC_SGATE,PROBE_NONE);
408  _signals["adcs"] = probeConfig(PROBE_ADC_S,PROBE_NONE);
409 
410  _signals["tbm0gate"] = probeConfig(PROBE_TBM0_GATE,PROBE_NONE);
411  _signals["tbmgate0"] = probeConfig(PROBE_TBM0_GATE,PROBE_NONE,false);
412  _signals["tbm0data"] = probeConfig(PROBE_TBM0_DATA,PROBE_NONE);
413  _signals["tbmdata0"] = probeConfig(PROBE_TBM0_DATA,PROBE_NONE,false);
414  _signals["tbm0tbmhdr"] = probeConfig(PROBE_TBM0_TBMHDR,PROBE_NONE);
415  _signals["tbmheader0"] = probeConfig(PROBE_TBM0_TBMHDR,PROBE_NONE,false);
416  _signals["tbm0rochdr"] = probeConfig(PROBE_TBM0_ROCHDR,PROBE_NONE);
417  _signals["tbmrocheader0"] = probeConfig(PROBE_TBM0_ROCHDR,PROBE_NONE,false);
418  _signals["tbm0tbmtrl"] = probeConfig(PROBE_TBM0_TBMTRL,PROBE_NONE);
419  _signals["tbmtrailer0"] = probeConfig(PROBE_TBM0_TBMTRL,PROBE_NONE,false);
420 
421  _signals["tbm1gate"] = probeConfig(PROBE_TBM1_GATE,PROBE_NONE);
422  _signals["tbmgate1"] = probeConfig(PROBE_TBM1_GATE,PROBE_NONE,false);
423  _signals["tbm1data"] = probeConfig(PROBE_TBM1_DATA,PROBE_NONE);
424  _signals["tbmdata1"] = probeConfig(PROBE_TBM1_DATA,PROBE_NONE,false);
425  _signals["tbm1tbmhdr"] = probeConfig(PROBE_TBM1_TBMHDR,PROBE_NONE);
426  _signals["tbmheader1"] = probeConfig(PROBE_TBM1_TBMHDR,PROBE_NONE,false);
427  _signals["tbm1rochdr"] = probeConfig(PROBE_TBM1_ROCHDR,PROBE_NONE);
428  _signals["tbmrocheader1"] = probeConfig(PROBE_TBM1_ROCHDR,PROBE_NONE,false);
429  _signals["tbm1tbmtrl"] = probeConfig(PROBE_TBM1_TBMTRL,PROBE_NONE);
430  _signals["tbmtrailer1"] = probeConfig(PROBE_TBM1_TBMTRL,PROBE_NONE,false);
431 
432  _signals["tbm2gate"] = probeConfig(PROBE_TBM2_GATE,PROBE_NONE);
433  _signals["tbmgate2"] = probeConfig(PROBE_TBM2_GATE,PROBE_NONE,false);
434  _signals["tbm2data"] = probeConfig(PROBE_TBM2_DATA,PROBE_NONE);
435  _signals["tbmdata2"] = probeConfig(PROBE_TBM2_DATA,PROBE_NONE,false);
436  _signals["tbm2tbmhdr"] = probeConfig(PROBE_TBM2_TBMHDR,PROBE_NONE);
437  _signals["tbmheader2"] = probeConfig(PROBE_TBM2_TBMHDR,PROBE_NONE,false);
438  _signals["tbm2rochdr"] = probeConfig(PROBE_TBM2_ROCHDR,PROBE_NONE);
439  _signals["tbmrocheader2"] = probeConfig(PROBE_TBM2_ROCHDR,PROBE_NONE,false);
440  _signals["tbm2tbmtrl"] = probeConfig(PROBE_TBM2_TBMTRL,PROBE_NONE);
441  _signals["tbmtrailer2"] = probeConfig(PROBE_TBM2_TBMTRL,PROBE_NONE,false);
442 
443  _signals["tbm3gate"] = probeConfig(PROBE_TBM3_GATE,PROBE_NONE);
444  _signals["tbmgate3"] = probeConfig(PROBE_TBM3_GATE,PROBE_NONE,false);
445  _signals["tbm3data"] = probeConfig(PROBE_TBM3_DATA,PROBE_NONE);
446  _signals["tbmdata3"] = probeConfig(PROBE_TBM3_DATA,PROBE_NONE,false);
447  _signals["tbm3tbmhdr"] = probeConfig(PROBE_TBM3_TBMHDR,PROBE_NONE);
448  _signals["tbmheader3"] = probeConfig(PROBE_TBM3_TBMHDR,PROBE_NONE,false);
449  _signals["tbm3rochdr"] = probeConfig(PROBE_TBM3_ROCHDR,PROBE_NONE);
450  _signals["tbmrocheader3"] = probeConfig(PROBE_TBM3_ROCHDR,PROBE_NONE,false);
451  _signals["tbm3tbmtrl"] = probeConfig(PROBE_TBM3_TBMTRL,PROBE_NONE);
452  _signals["tbmtrailer3"] = probeConfig(PROBE_TBM3_TBMTRL,PROBE_NONE,false);
453 
454  _signals["tbm4gate"] = probeConfig(PROBE_TBM4_GATE,PROBE_NONE);
455  _signals["tbmgate4"] = probeConfig(PROBE_TBM4_GATE,PROBE_NONE,false);
456  _signals["tbm4data"] = probeConfig(PROBE_TBM4_DATA,PROBE_NONE);
457  _signals["tbmdata4"] = probeConfig(PROBE_TBM4_DATA,PROBE_NONE,false);
458  _signals["tbm4tbmhdr"] = probeConfig(PROBE_TBM4_TBMHDR,PROBE_NONE);
459  _signals["tbmheader4"] = probeConfig(PROBE_TBM4_TBMHDR,PROBE_NONE,false);
460  _signals["tbm4rochdr"] = probeConfig(PROBE_TBM4_ROCHDR,PROBE_NONE);
461  _signals["tbmrocheader4"] = probeConfig(PROBE_TBM4_ROCHDR,PROBE_NONE,false);
462  _signals["tbm4tbmtrl"] = probeConfig(PROBE_TBM4_TBMTRL,PROBE_NONE);
463  _signals["tbmtrailer4"] = probeConfig(PROBE_TBM4_TBMTRL,PROBE_NONE,false);
464 
465  _signals["tbm5gate"] = probeConfig(PROBE_TBM5_GATE,PROBE_NONE);
466  _signals["tbmgate5"] = probeConfig(PROBE_TBM5_GATE,PROBE_NONE,false);
467  _signals["tbm5data"] = probeConfig(PROBE_TBM5_DATA,PROBE_NONE);
468  _signals["tbmdata5"] = probeConfig(PROBE_TBM5_DATA,PROBE_NONE,false);
469  _signals["tbm5tbmhdr"] = probeConfig(PROBE_TBM5_TBMHDR,PROBE_NONE);
470  _signals["tbmheader5"] = probeConfig(PROBE_TBM5_TBMHDR,PROBE_NONE,false);
471  _signals["tbm5rochdr"] = probeConfig(PROBE_TBM5_ROCHDR,PROBE_NONE);
472  _signals["tbmrocheader5"] = probeConfig(PROBE_TBM5_ROCHDR,PROBE_NONE,false);
473  _signals["tbm5tbmtrl"] = probeConfig(PROBE_TBM5_TBMTRL,PROBE_NONE);
474  _signals["tbmtrailer5"] = probeConfig(PROBE_TBM5_TBMTRL,PROBE_NONE,false);
475 
476  // Purely analog signals:
477  _signals["sdata1"] = probeConfig(PROBE_NONE,PROBEA_SDATA1);
478  _signals["sdata2"] = probeConfig(PROBE_NONE,PROBEA_SDATA2);
479  }
480 
481  std::map<std::string, probeConfig> _signals;
482  ProbeDictionary(ProbeDictionary const&); // Don't Implement
483  void operator=(ProbeDictionary const&); // Don't implement
484  };
485 
486 
491  class PatternGeneratorDictionary {
492  public:
493  static PatternGeneratorDictionary * getInstance() {
494  static PatternGeneratorDictionary instance; // Guaranteed to be destroyed.
495  // Instantiated on first use.
496  return &instance;
497  }
498 
499  // Return the register id for the name in question:
500  inline uint16_t getSignal(std::string name) {
501  if(_signals.find(name) != _signals.end()) { return _signals[name]; }
502  else { return PG_ERR; }
503  }
504 
505  // Return the signal name for the probe signal in question:
506  inline std::string getName(uint16_t signal) {
507  for(std::map<std::string, uint16_t>::iterator iter = _signals.begin(); iter != _signals.end(); ++iter) {
508  if((*iter).second == signal) { return (*iter).first; }
509  }
510  return "";
511  }
512 
513  private:
514  PatternGeneratorDictionary() {
515  // None (empty cycle):
516  _signals["none"] = PG_NONE;
517  _signals["empty"] = PG_NONE;
518  _signals["delay"] = PG_NONE;
519 
520  // Token:
521  _signals["pg_tok"] = PG_TOK;
522  _signals["tok"] = PG_TOK;
523  _signals["token"] = PG_TOK;
524 
525  // Trigger:
526  _signals["pg_trg"] = PG_TRG;
527  _signals["trg"] = PG_TRG;
528  _signals["trigger"] = PG_TRG;
529 
530  // Calibrate signal
531  _signals["pg_cal"] = PG_CAL;
532  _signals["cal"] = PG_CAL;
533  _signals["calibrate"] = PG_CAL;
534 
535  // ROC Reset Signal
536  _signals["pg_resr"] = PG_RESR;
537  _signals["resr"] = PG_RESR;
538  _signals["resetroc"] = PG_RESR;
539 
540  // TBM Reset Signal
541  _signals["pg_rest"] = PG_REST;
542  _signals["rest"] = PG_REST;
543  _signals["resettbm"] = PG_REST;
544 
545  // PG Sync Signal
546  _signals["pg_sync"] = PG_SYNC;
547  _signals["sync"] = PG_SYNC;
548  }
549 
550  std::map<std::string, uint16_t> _signals;
551  PatternGeneratorDictionary(PatternGeneratorDictionary const&); // Don't Implement
552  void operator=(PatternGeneratorDictionary const&); // Don't implement
553  };
554 
555 } //namespace pxar
556 
557 #endif /* PXAR_DICTIONARIES_H */
Generated on Tue Mar 3 2015 10:03:37 for pxar by   doxygen 1.8.6