source: trunk/FACT++/src/ftmctrl.cc@ 12535

Last change on this file since 12535 was 12534, checked in by tbretz, 13 years ago
Improved some log message
File size: 93.3 KB
Line 
1#include <array>
2
3#include "Dim.h"
4#include "Event.h"
5#include "Shell.h"
6#include "StateMachineDim.h"
7#include "Connection.h"
8#include "Configuration.h"
9#include "Console.h"
10#include "Converter.h"
11
12#include "tools.h"
13
14#include "HeadersFTM.h"
15
16
17namespace ba = boost::asio;
18namespace bs = boost::system;
19
20using namespace std;
21using namespace std::placeholders;
22
23// ------------------------------------------------------------------------
24
25class ConnectionFTM : public Connection
26{
27public:
28 enum States
29 {
30 // State Machine states
31 kDisconnected = StateMachineImp::kSM_UserMode,
32 kConnected,
33 kIdle,
34 kConfigured, // Returned if idle and fBufStaticData==fStaticData
35 kTriggerOn,
36 };
37
38private:
39 vector<uint16_t> fBuffer;
40
41 bool fHasHeader;
42
43 bool fIsVerbose;
44 bool fIsDynamicOut;
45 bool fIsHexOutput;
46
47protected:
48 map<uint16_t, uint32_t> fCounter;
49
50 FTM::Header fHeader;
51 FTM::FtuList fFtuList;
52 FTM::StaticData fStaticData;
53 FTM::DynamicData fDynamicData;
54 FTM::Error fError;
55
56 FTM::StaticData fBufStaticData;
57
58 virtual void UpdateFirstHeader()
59 {
60 // FIXME: Message() ?
61 Out() << endl << kBold << "First header received:" << endl;
62 Out() << fHeader;
63 if (fIsHexOutput)
64 Out() << Converter::GetHex<uint16_t>(fHeader, 16) << endl;
65 }
66
67 virtual void UpdateHeader()
68 {
69 // emit service with trigger counter from header
70 if (!fIsVerbose)
71 return;
72
73 if (fHeader.fType==FTM::kDynamicData && !fIsDynamicOut)
74 return;
75
76 Out() << endl << kBold << "Header received:" << endl;
77 Out() << fHeader;
78 if (fIsHexOutput)
79 Out() << Converter::GetHex<uint16_t>(fHeader, 16) << endl;
80 }
81
82 virtual void UpdateFtuList()
83 {
84 if (!fIsVerbose)
85 return;
86
87 Out() << endl << kBold << "FtuList received:" << endl;
88 Out() << fFtuList;
89 if (fIsHexOutput)
90 Out() << Converter::GetHex<uint16_t>(fFtuList, 16) << endl;
91 }
92
93 virtual void UpdateStaticData()
94 {
95 if (!fIsVerbose)
96 return;
97
98 Out() << endl << kBold << "Static data received:" << endl;
99 Out() << fStaticData;
100 if (fIsHexOutput)
101 Out() << Converter::GetHex<uint16_t>(fStaticData, 16) << endl;
102 }
103
104 virtual void UpdateDynamicData()
105 {
106 if (!fIsDynamicOut)
107 return;
108
109 Out() << endl << kBold << "Dynamic data received:" << endl;
110 Out() << fDynamicData;
111 if (fIsHexOutput)
112 Out() << Converter::GetHex<uint16_t>(fDynamicData, 16) << endl;
113 }
114
115 virtual void UpdateError()
116 {
117 if (!fIsVerbose)
118 return;
119
120 Out() << endl << kRed << "Error received:" << endl;
121 Out() << fError;
122 if (fIsHexOutput)
123 Out() << Converter::GetHex<uint16_t>(fError, 16) << endl;
124 }
125
126 virtual void UpdateCounter()
127 {
128 if (!fIsVerbose)
129 return;
130
131 if (!fIsDynamicOut)
132 return;
133
134 Out() << "Received: ";
135 Out() << "H=" << fCounter[FTM::kHeader] << " ";
136 Out() << "S=" << fCounter[FTM::kStaticData] << " ";
137 Out() << "D=" << fCounter[FTM::kDynamicData] << " ";
138 Out() << "F=" << fCounter[FTM::kFtuList] << " ";
139 Out() << "E=" << fCounter[FTM::kErrorList] << " ";
140 Out() << "R=" << fCounter[FTM::kRegister] << endl;
141 }
142
143 bool CheckConsistency(FTM::StaticData &data)
144 {
145 bool warn1 = false;
146 if (data.IsEnabled(FTM::StaticData::kPedestal) != (data.GetSequencePed() >0) ||
147 data.IsEnabled(FTM::StaticData::kLPint) != (data.GetSequenceLPint()>0) ||
148 data.IsEnabled(FTM::StaticData::kLPext) != (data.GetSequenceLPext()>0))
149 {
150 warn1 = true;
151 data.Enable(FTM::StaticData::kPedestal, data.GetSequencePed()>0);
152 data.Enable(FTM::StaticData::kLPint, data.GetSequenceLPint()>0);
153 data.Enable(FTM::StaticData::kLPext, data.GetSequenceLPext()>0);
154 }
155
156 bool warn2 = false;
157 const uint16_t ref = data[0].fPrescaling;
158 for (int i=1; i<40; i++)
159 {
160 if (data[i].fPrescaling != ref)
161 {
162 warn2 = true;
163 data[i].fPrescaling = ref;
164 }
165 }
166
167 bool warn3 = false;
168 for (int i=0; i<4; i++)
169 if (data.fActiveFTU[i]!=0x3ff)
170 {
171 warn3 = true;
172 data.fActiveFTU[i]=0x3ff;
173 }
174
175
176
177 if (warn1)
178 Warn("GeneralSettings not consistent with trigger sequence.");
179 if (warn2)
180 Warn("Prescaling not consistent for all boards.");
181 if (warn3)
182 Warn("Not all FTUs are enabled - enable all FTUs.");
183
184 return !warn1 && !warn2 && !warn3;
185 }
186
187private:
188 void HandleReceivedData(const bs::error_code& err, size_t bytes_received, int /*type*/)
189 {
190 // Do not schedule a new read if the connection failed.
191 if (bytes_received==0 || err)
192 {
193 if (err==ba::error::eof)
194 Warn("Connection closed by remote host (FTM).");
195
196 // 107: Transport endpoint is not connected (bs::error_code(107, bs::system_category))
197 // 125: Operation canceled
198 if (err && err!=ba::error::eof && // Connection closed by remote host
199 err!=ba::error::basic_errors::not_connected && // Connection closed by remote host
200 err!=ba::error::basic_errors::operation_aborted) // Connection closed by us
201 {
202 ostringstream str;
203 str << "Reading from " << URL() << ": " << err.message() << " (" << err << ")";// << endl;
204 Error(str);
205 }
206 PostClose(err!=ba::error::basic_errors::operation_aborted);
207 return;
208 }
209
210 // If we have not yet received a header we expect one now
211 // This could be moved to a HandleReceivedHeader function
212 if (!fHasHeader)
213 {
214 if (bytes_received!=sizeof(FTM::Header))
215 {
216 ostringstream str;
217 str << "Excepted " << sizeof(FTM::Header) << " bytes (FTM::Header) but received " << bytes_received << ".";
218 Error(str);
219 PostClose(false);
220 return;
221 }
222
223 fHeader = fBuffer;
224
225 // Check the data integrity
226 if (fHeader.fDelimiter!=FTM::kDelimiterStart)
227 {
228 ostringstream str;
229 str << "Invalid header received: start delimiter wrong, received ";
230 str << hex << fHeader.fDelimiter << ", expected " << FTM::kDelimiterStart << ".";
231 Error(str);
232 PostClose(false);
233 return;
234 }
235
236 fHasHeader = true;
237
238 // Convert FTM state into FtmCtrl state
239 if (++fCounter[FTM::kHeader]==1)
240 UpdateFirstHeader();
241
242 UpdateCounter();
243 UpdateHeader();
244
245 // Start reading of data
246 switch (fHeader.fType)
247 {
248 case FTM::kStaticData:
249 case FTM::kDynamicData:
250 case FTM::kFtuList:
251 case FTM::kRegister:
252 case FTM::kErrorList:
253 // This is not very efficient because the space is reallocated
254 // maybe we can check if the capacity of the std::vector
255 // is ever decreased. If not, everythign is fine.
256 fBuffer.resize(fHeader.fDataSize);
257 AsyncRead(ba::buffer(fBuffer));
258 AsyncWait(fInTimeout, 50, &Connection::HandleReadTimeout);
259 return;
260
261 default:
262 ostringstream str;
263 str << "Unknonw type " << fHeader.fType << " in received header." << endl;
264 Error(str);
265 PostClose(false);
266 return;
267 }
268
269 return;
270 }
271
272 // Check the data integrity (check end delimiter)
273 if (ntohs(fBuffer.back())!=FTM::kDelimiterEnd)
274 {
275 ostringstream str;
276 str << "Invalid data received: end delimiter wrong, received ";
277 str << hex << ntohs(fBuffer.back()) << ", expected " << FTM::kDelimiterEnd << ".";
278 Error(str);
279 PostClose(false);
280 return;
281 }
282
283 // Remove end delimiter
284 fBuffer.pop_back();
285
286 try
287 {
288 // If we have already received a header this is the data now
289 // This could be moved to a HandleReceivedData function
290
291 fCounter[fHeader.fType]++;
292 UpdateCounter();
293
294 switch (fHeader.fType)
295 {
296 case FTM::kFtuList:
297 fFtuList = fBuffer;
298 UpdateFtuList();
299 break;
300
301 case FTM::kStaticData:
302 if (fCounter[FTM::kStaticData]==1)
303 {
304 // This check is only done at startup
305 FTM::StaticData data(fBuffer);
306 if (!CheckConsistency(data))
307 {
308 CmdSendStatDat(data);
309 CmdPing(); // FIXME: Only needed in case of warn3
310 break;
311 }
312 }
313
314 fStaticData = fBuffer;
315 UpdateStaticData();
316 break;
317
318 case FTM::kDynamicData:
319 fDynamicData = fBuffer;
320 UpdateDynamicData();
321 break;
322
323 case FTM::kRegister:
324 if (fIsVerbose)
325 {
326 Out() << endl << kBold << "Register received: " << endl;
327 Out() << "Addr: " << ntohs(fBuffer[0]) << endl;
328 Out() << "Value: " << ntohs(fBuffer[1]) << endl;
329 }
330 break;
331
332 case FTM::kErrorList:
333 fError = fBuffer;
334 UpdateError();
335 break;
336
337 default:
338 ostringstream str;
339 str << "Unknonw type " << fHeader.fType << " in header." << endl;
340 Error(str);
341 PostClose(false);
342 return;
343 }
344 }
345 catch (const logic_error &e)
346 {
347 ostringstream str;
348 str << "Exception converting buffer into data structure: " << e.what();
349 Error(str);
350 PostClose(false);
351 return;
352 }
353
354 fInTimeout.cancel();
355
356 //fHeader.clear();
357 fHasHeader = false;
358 fBuffer.resize(sizeof(FTM::Header)/2);
359 AsyncRead(ba::buffer(fBuffer));
360 }
361
362 // This is called when a connection was established
363 void ConnectionEstablished()
364 {
365 fCounter.clear();
366 fBufStaticData.clear();
367
368 fHeader.clear();
369 fHasHeader = false;
370 fBuffer.resize(sizeof(FTM::Header)/2);
371 AsyncRead(ba::buffer(fBuffer));
372
373// if (!fDefaultSetup.empty())
374// LoadStaticData(fDefaultSetup);
375
376 // Get a header and configdata!
377 CmdReqStatDat();
378
379 // get the DNA of the FTUs
380 CmdPing();
381 }
382
383 void HandleReadTimeout(const bs::error_code &error)
384 {
385 if (error==ba::error::basic_errors::operation_aborted)
386 return;
387
388 if (error)
389 {
390 ostringstream str;
391 str << "Read timeout of " << URL() << ": " << error.message() << " (" << error << ")";// << endl;
392 Error(str);
393
394 PostClose();
395 return;
396
397 }
398
399 if (!is_open())
400 {
401 // For example: Here we could schedule a new accept if we
402 // would not want to allow two connections at the same time.
403 return;
404 }
405
406 // Check whether the deadline has passed. We compare the deadline
407 // against the current time since a new asynchronous operation
408 // may have moved the deadline before this actor had a chance
409 // to run.
410 if (fInTimeout.expires_at() > ba::deadline_timer::traits_type::now())
411 return;
412
413 Error("Timeout reading data from "+URL());
414
415 PostClose();
416 }
417
418
419 template<size_t N>
420 void PostCmd(array<uint16_t, N> dat, uint16_t u1=0, uint16_t u2=0, uint16_t u3=0, uint16_t u4=0)
421 {
422 array<uint16_t, 5> cmd = {{ '@', u1, u2, u3, u4 }};
423
424 ostringstream msg;
425 msg << "Sending command:" << hex;
426 msg << " 0x" << setw(4) << setfill('0') << cmd[0];
427 msg << " 0x" << setw(4) << setfill('0') << u1;
428 msg << " 0x" << setw(4) << setfill('0') << u2;
429 msg << " 0x" << setw(4) << setfill('0') << u3;
430 msg << " 0x" << setw(4) << setfill('0') << u4;
431 msg << " (+" << dec << dat.size() << " words)";
432 Message(msg);
433
434 vector<uint16_t> out(cmd.size()+dat.size());
435
436 transform(cmd.begin(), cmd.end(), out.begin(), htons);
437 transform(dat.begin(), dat.end(), out.begin()+cmd.size(), htons);
438
439 PostMessage(out);
440 }
441
442 void PostCmd(vector<uint16_t> dat, uint16_t u1=0, uint16_t u2=0, uint16_t u3=0, uint16_t u4=0)
443 {
444 array<uint16_t, 5> cmd = {{ '@', u1, u2, u3, u4 }};
445
446 ostringstream msg;
447 msg << "Sending command:" << hex;
448 msg << " 0x" << setw(4) << setfill('0') << cmd[0];
449 msg << " 0x" << setw(4) << setfill('0') << u1;
450 msg << " 0x" << setw(4) << setfill('0') << u2;
451 msg << " 0x" << setw(4) << setfill('0') << u3;
452 msg << " 0x" << setw(4) << setfill('0') << u4;
453 msg << " (+" << dec << dat.size() << " words)";
454 Message(msg);
455
456 vector<uint16_t> out(cmd.size()+dat.size());
457
458 transform(cmd.begin(), cmd.end(), out.begin(), htons);
459 copy(dat.begin(), dat.end(), out.begin()+cmd.size());
460
461 PostMessage(out);
462 }
463
464 void PostCmd(uint16_t u1=0, uint16_t u2=0, uint16_t u3=0, uint16_t u4=0)
465 {
466 PostCmd(array<uint16_t, 0>(), u1, u2, u3, u4);
467 }
468public:
469
470// static const uint16_t kMaxAddr;
471
472public:
473 ConnectionFTM(ba::io_service& ioservice, MessageImp &imp) : Connection(ioservice, imp()),
474 fIsVerbose(true), fIsDynamicOut(true), fIsHexOutput(true)
475 {
476 SetLogStream(&imp);
477 }
478
479 void CmdToggleLed()
480 {
481 PostCmd(FTM::kCmdToggleLed);
482 }
483
484 void CmdPing()
485 {
486 PostCmd(FTM::kCmdPing);
487 }
488
489 void CmdReqDynDat()
490 {
491 PostCmd(FTM::kCmdRead, FTM::kCmdDynamicData);
492 }
493
494 void CmdReqStatDat()
495 {
496 PostCmd(FTM::kCmdRead, FTM::kCmdStaticData);
497 }
498
499 void CmdSendStatDat(const FTM::StaticData &data)
500 {
501 fBufStaticData = data;
502
503 PostCmd(data.HtoN(), FTM::kCmdWrite, FTM::kCmdStaticData);
504
505 // Request the changed configuration to ensure the
506 // change is distributed in the network
507 CmdReqStatDat();
508 }
509
510 void CmdStartRun()
511 {
512 PostCmd(FTM::kCmdStartRun, FTM::kStartRun);
513
514 // Update state information by requesting a new header
515 CmdGetRegister(0);
516 }
517
518 void CmdStopRun()
519 {
520 PostCmd(FTM::kCmdStopRun);
521
522 // Update state information by requesting a new header
523 CmdGetRegister(0);
524 }
525
526 void CmdTakeNevents(uint32_t n)
527 {
528 const array<uint16_t, 2> data = {{ uint16_t(n>>16), uint16_t(n&0xffff) }};
529 PostCmd(data, FTM::kCmdStartRun, FTM::kTakeNevents);
530
531 // Update state information by requesting a new header
532 CmdGetRegister(0);
533 }
534
535 bool CmdSetRegister(uint16_t addr, uint16_t val)
536 {
537 if (addr>FTM::StaticData::kMaxAddr)
538 return false;
539
540 const array<uint16_t, 2> data = {{ addr, val }};
541 PostCmd(data, FTM::kCmdWrite, FTM::kCmdRegister);
542
543 reinterpret_cast<uint16_t*>(&fBufStaticData)[addr] = val;
544
545 // Request the changed configuration to ensure the
546 // change is distributed in the network
547 CmdReqStatDat();
548
549 return true;
550 }
551
552 bool CmdGetRegister(uint16_t addr)
553 {
554 if (addr>FTM::StaticData::kMaxAddr)
555 return false;
556
557 const array<uint16_t, 1> data = {{ addr }};
558 PostCmd(data, FTM::kCmdRead, FTM::kCmdRegister);
559
560 return true;
561 }
562
563 bool CmdResetCrate(uint16_t addr)
564 {
565 if (addr>3)
566 return false;
567
568 PostCmd(FTM::kCmdCrateReset, 1<<addr);
569
570 return true;
571 }
572
573 bool CmdResetCamera()
574 {
575 PostCmd(FTM::kCmdCrateReset, FTM::kResetCrate0);
576 PostCmd(FTM::kCmdCrateReset, FTM::kResetCrate1);
577 PostCmd(FTM::kCmdCrateReset, FTM::kResetCrate2);
578 PostCmd(FTM::kCmdCrateReset, FTM::kResetCrate3);
579
580 return true;
581 }
582
583 bool CmdDisableReports(bool b)
584 {
585 PostCmd(FTM::kCmdDisableReports, b ? uint16_t(0) : uint16_t(1));
586 return true;
587 }
588
589
590 void SetVerbose(bool b)
591 {
592 fIsVerbose = b;
593 }
594
595 void SetHexOutput(bool b)
596 {
597 fIsHexOutput = b;
598 }
599
600 void SetDynamicOut(bool b)
601 {
602 fIsDynamicOut = b;
603 }
604/*
605 void SetDefaultSetup(const string &file)
606 {
607 fDefaultSetup = file;
608 }
609*/
610
611 bool LoadStaticData(string name)
612 {
613 if (name.rfind(".bin")!=name.length()-4)
614 name += ".bin";
615
616 ifstream fin(name);
617 if (!fin)
618 return false;
619
620 FTM::StaticData data;
621
622 fin.read(reinterpret_cast<char*>(&data), sizeof(FTM::StaticData));
623
624 if (fin.gcount()<streamsize(sizeof(FTM::StaticData)))
625 return false;
626
627 if (fin.fail() || fin.eof())
628 return false;
629
630 if (fin.peek()!=-1)
631 return false;
632
633 CmdSendStatDat(data);
634
635 return true;
636 }
637
638 bool SaveStaticData(string name) const
639 {
640 if (name.rfind(".bin")!=name.length()-4)
641 name += ".bin";
642
643 ofstream fout(name);
644 if (!fout)
645 return false;
646
647 fout.write(reinterpret_cast<const char*>(&fStaticData), sizeof(FTM::StaticData));
648
649 return !fout.bad();
650 }
651
652 bool SetThreshold(int32_t patch, int32_t value)
653 {
654 if (patch>FTM::StaticData::kMaxPatchIdx)
655 return false;
656
657 if (value<0 || value>FTM::StaticData::kMaxDAC)
658 return false;
659
660 if (patch<0)
661 {
662 FTM::StaticData data(fStaticData);
663
664 bool ident = true;
665 for (int i=0; i<=FTM::StaticData::kMaxPatchIdx; i++)
666 if (data[i/4].fDAC[i%4] != value)
667 {
668 ident = false;
669 break;
670 }
671
672 if (ident)
673 return true;
674
675 for (int i=0; i<=FTM::StaticData::kMaxPatchIdx; i++)
676 data[i/4].fDAC[i%4] = value;
677
678 // Maybe move to a "COMMIT" command?
679 CmdSendStatDat(data);
680
681 return true;
682 }
683
684 /*
685 if (data[patch/4].fDAC[patch%4] == value)
686 return true;
687 */
688
689 // Calculate offset in static data block
690 const uint16_t addr = (uintptr_t(&fStaticData[patch/4].fDAC[patch%4])-uintptr_t(&fStaticData))/2;
691
692 // From CmdSetRegister
693 const array<uint16_t, 2> data = {{ addr, uint16_t(value) }};
694 PostCmd(data, FTM::kCmdWrite, FTM::kCmdRegister);
695
696 reinterpret_cast<uint16_t*>(&fBufStaticData)[addr] = value;
697
698 // Now execute change before the static data is requested back
699 PostCmd(FTM::kCmdConfigFTU, (patch/40) | (((patch/4)%10)<<8));
700
701 //CmdGetRegister(addr);
702 CmdReqStatDat();
703
704 return true;
705 }
706
707 bool SetNoutof4(int32_t patch, int32_t value)
708 {
709 if (patch>=FTM::StaticData::kMaxMultiplicity)
710 return false;
711
712 if (value<0 || value>FTM::StaticData::kMaxDAC)
713 return false;
714
715 if (patch<0)
716 {
717 FTM::StaticData data(fStaticData);
718
719 bool ident = true;
720 for (int i=0; i<FTM::StaticData::kMaxMultiplicity; i++)
721 if (data[i].fDAC[4] != value)
722 {
723 ident = false;
724 break;
725 }
726
727 if (ident)
728 return true;
729
730 for (int i=0; i<=FTM::StaticData::kMaxMultiplicity; i++)
731 data[i].fDAC[4] = value;
732
733 // Maybe move to a "COMMIT" command?
734 CmdSendStatDat(data);
735
736 return true;
737 }
738
739 /*
740 if (data[patch/4].fDAC[patch%4] == value)
741 return true;
742
743 data[patch/4].fDAC[patch%4] = value;
744
745 CmdSendStatDat(data);
746 return true;
747 */
748
749 // Calculate offset in static data block
750 const uint16_t addr = (uintptr_t(&fStaticData[patch].fDAC[4])-uintptr_t(&fStaticData))/2;
751
752 // From CmdSetRegister
753 const array<uint16_t, 2> data = {{ addr, uint16_t(value) }};
754 PostCmd(data, FTM::kCmdWrite, FTM::kCmdRegister);
755
756 reinterpret_cast<uint16_t*>(&fBufStaticData)[addr] = value;
757
758 // Now execute change before the static data is requested back
759 PostCmd(FTM::kCmdConfigFTU, (patch/40) | (((patch/4)%10)<<8));
760
761 //CmdGetRegister(addr);
762 CmdReqStatDat();
763
764 return true;
765 }
766
767 bool SetPrescaling(uint32_t value)
768 {
769 if (value>0xffff)
770 return false;
771
772 FTM::StaticData data(fStaticData);
773
774 bool ident = true;
775 for (int i=0; i<40; i++)
776 if (data[i].fPrescaling != value)
777 {
778 ident = false;
779 break;
780 }
781
782 if (ident)
783 return true;
784
785 data.SetPrescaling(value);
786
787 // Maybe move to a "COMMIT" command?
788 CmdSendStatDat(data);
789
790 return true;
791 }
792
793 bool EnableFTU(int32_t board, bool enable)
794 {
795 if (board>39)
796 return false;
797
798 FTM::StaticData data(fStaticData);
799
800 if (board<0)
801 {
802 if (enable)
803 data.EnableAllFTU();
804 else
805 data.DisableAllFTU();
806 }
807 else
808 {
809 if (enable)
810 data.EnableFTU(board);
811 else
812 data.DisableFTU(board);
813
814 }
815
816 // Maybe move to a "COMMIT" command?
817 CmdSendStatDat(data);
818
819 return true;
820 }
821
822 bool ToggleFTU(uint32_t board)
823 {
824 if (board>39)
825 return false;
826
827 FTM::StaticData data(fStaticData);
828
829 data.ToggleFTU(board);
830
831 // Maybe move to a "COMMIT" command?
832 CmdSendStatDat(data);
833
834 return true;
835 }
836
837 bool SetVal(uint16_t *dest, uint32_t val, uint32_t max)
838 {
839 if (val>max)
840 return false;
841
842 if (*dest==val)
843 return true;
844
845 FTM::StaticData data(fStaticData);
846
847 dest = reinterpret_cast<uint16_t*>(&data) + (dest - reinterpret_cast<uint16_t*>(&fStaticData));
848
849 *dest = val;
850
851 CmdSendStatDat(data);
852
853 return true;
854 }
855
856 bool SetTriggerInterval(uint32_t val)
857 {
858 return SetVal(&fStaticData.fTriggerInterval, val,
859 FTM::StaticData::kMaxTriggerInterval);
860 }
861
862 bool SetTriggerDelay(uint32_t val)
863 {
864 return SetVal(&fStaticData.fDelayTrigger, val,
865 FTM::StaticData::kMaxDelayTrigger);
866 }
867
868 bool SetTimeMarkerDelay(uint32_t val)
869 {
870 return SetVal(&fStaticData.fDelayTimeMarker, val,
871 FTM::StaticData::kMaxDelayTimeMarker);
872 }
873
874 bool SetDeadTime(uint32_t val)
875 {
876 return SetVal(&fStaticData.fDeadTime, val,
877 FTM::StaticData::kMaxDeadTime);
878 }
879
880 void Enable(FTM::StaticData::GeneralSettings type, bool enable)
881 {
882 //if (fStaticData.IsEnabled(type)==enable)
883 // return;
884
885 FTM::StaticData data(fStaticData);
886 data.Enable(type, enable);
887 CmdSendStatDat(data);
888 }
889
890 bool SetTriggerSeq(const uint16_t d[3])
891 {
892 if (d[0]>FTM::StaticData::kMaxSequence ||
893 d[1]>FTM::StaticData::kMaxSequence ||
894 d[2]>FTM::StaticData::kMaxSequence)
895 return false;
896
897 FTM::StaticData data(fStaticData);
898
899 /*
900 data.Enable(FTM::StaticData::kPedestal, d[0]>0);
901 data.Enable(FTM::StaticData::kLPext, d[1]>0);
902 data.Enable(FTM::StaticData::kLPint, d[2]>0);
903 */
904
905 data.SetSequence(d[0], d[2], d[1]);
906
907 //if (fStaticData.fTriggerSeq !=data.fTriggerSequence ||
908 // fStaticData.fGeneralSettings!=data.fGeneralSettings)
909 // CmdSendStatDat(data);
910
911 CmdSendStatDat(data);
912
913 return true;
914 }
915
916 bool SetTriggerMultiplicity(uint16_t n)
917 {
918 if (n==0 || n>FTM::StaticData::kMaxMultiplicity)
919 return false;
920
921 if (n==fStaticData.fMultiplicityPhysics)
922 return true;
923
924 FTM::StaticData data(fStaticData);
925
926 data.fMultiplicityPhysics = n;
927
928 CmdSendStatDat(data);
929
930 return true;
931 }
932
933 bool SetTriggerWindow(uint16_t win)
934 {
935 if (win>FTM::StaticData::kMaxWindow)
936 return false;
937
938 if (win==fStaticData.fWindowPhysics)
939 return true;
940
941 FTM::StaticData data(fStaticData);
942
943 data.fWindowPhysics = win;
944
945 CmdSendStatDat(data);
946
947 return true;
948 }
949
950 bool SetCalibMultiplicity(uint16_t n)
951 {
952 if (n==0 || n>FTM::StaticData::kMaxMultiplicity)
953 return false;
954
955 if (n==fStaticData.fMultiplicityCalib)
956 return true;
957
958 FTM::StaticData data(fStaticData);
959
960 data.fMultiplicityCalib = n;
961
962 CmdSendStatDat(data);
963
964 return true;
965 }
966
967 bool SetCalibWindow(uint16_t win)
968 {
969 if (win>FTM::StaticData::kMaxWindow)
970 return false;
971
972 if (win==fStaticData.fWindowCalib)
973 return true;
974
975 FTM::StaticData data(fStaticData);
976
977 data.fWindowCalib = win;
978
979 CmdSendStatDat(data);
980
981 return true;
982 }
983
984 bool SetClockRegister(const uint64_t reg[])
985 {
986 FTM::StaticData data(fStaticData);
987
988 for (int i=0; i<8; i++)
989 if (reg[i]>0xffffffff)
990 return false;
991
992 data.SetClockRegister(reg);
993
994 CmdSendStatDat(data);
995
996 return true;
997 }
998
999 bool EnableLP(FTM::StaticData::GeneralSettings lp, FTM::StaticData::LightPulserEnable group, bool enable)
1000 {
1001 if (lp!=FTM::StaticData::kLPint && lp!=FTM::StaticData::kLPext)
1002 return false;
1003
1004 FTM::StaticData data(fStaticData);
1005
1006 if (lp==FTM::StaticData::kLPint)
1007 data.EnableLPint(group, enable);
1008
1009 if (lp==FTM::StaticData::kLPext)
1010 data.EnableLPext(group, enable);
1011
1012 CmdSendStatDat(data);
1013
1014 return true;
1015 }
1016
1017 bool SetIntensity(FTM::StaticData::GeneralSettings lp, uint16_t intensity)
1018 {
1019 if (intensity>FTM::StaticData::kMaxIntensity)
1020 return false;
1021
1022 if (lp!=FTM::StaticData::kLPint && lp!=FTM::StaticData::kLPext)
1023 return false;
1024
1025 FTM::StaticData data(fStaticData);
1026
1027 if (lp==FTM::StaticData::kLPint)
1028 data.fIntensityLPint = intensity;
1029
1030 if (lp==FTM::StaticData::kLPext)
1031 data.fIntensityLPext = intensity;
1032
1033 CmdSendStatDat(data);
1034
1035 return true;
1036 }
1037
1038 bool EnablePixel(int16_t idx, bool enable)
1039 {
1040 if (idx<-1 || idx>FTM::StaticData::kMaxPixelIdx)
1041 return false;
1042
1043 if (idx==-1)
1044 {
1045 FTM::StaticData data(fStaticData);
1046
1047 for (int i=0; i<=FTM::StaticData::kMaxPixelIdx; i++)
1048 data.EnablePixel(i, enable);
1049
1050 CmdSendStatDat(data);
1051
1052 return true;
1053 }
1054
1055 /*
1056 data.EnablePixel(idx, enable);
1057 CmdSendStatDat(data);
1058 return true;
1059 */
1060
1061 FTM::StaticData data(fStaticData);
1062
1063 const uintptr_t base = uintptr_t(&data);
1064 const uint16_t *mem = data.EnablePixel(idx, enable);
1065
1066 // Calculate offset in static data block
1067 const uint16_t addr = (uintptr_t(mem)-base)/2;
1068
1069 // From CmdSetRegister
1070 const array<uint16_t, 2> cmd = {{ addr, *mem }};
1071 PostCmd(cmd, FTM::kCmdWrite, FTM::kCmdRegister);
1072
1073 reinterpret_cast<uint16_t*>(&fBufStaticData)[addr] = *mem;
1074
1075 // Now execute change before the static data is requested back
1076 PostCmd(FTM::kCmdConfigFTU, (idx/360) | (((idx/36)%10)<<8));
1077
1078 // Now request the register back to ensure consistency
1079 //CmdGetRegister(addr);
1080 CmdReqStatDat();
1081
1082 return true;
1083 }
1084
1085 bool DisableAllPixelsExcept(uint16_t idx)
1086 {
1087 if (idx>FTM::StaticData::kMaxPixelIdx)
1088 return false;
1089
1090 FTM::StaticData data(fStaticData);
1091
1092 for (int i=0; i<=FTM::StaticData::kMaxPixelIdx; i++)
1093 data.EnablePixel(i, i==idx);
1094
1095 CmdSendStatDat(data);
1096
1097 return true;
1098 }
1099
1100 bool DisableAllPatchesExcept(int16_t idx)
1101 {
1102 if (idx>FTM::StaticData::kMaxPatchIdx)
1103 return false;
1104
1105 FTM::StaticData data(fStaticData);
1106
1107 for (int i=0; i<=FTM::StaticData::kMaxPixelIdx; i++)
1108 data.EnablePixel(i, i/9==idx);
1109
1110 CmdSendStatDat(data);
1111
1112 return true;
1113 }
1114
1115 bool EnablePatch(int16_t idx, bool enable)
1116 {
1117 if (idx>FTM::StaticData::kMaxPatchIdx)
1118 return false;
1119
1120 FTM::StaticData data(fStaticData);
1121
1122 for (int i=0; i<=FTM::StaticData::kMaxPixelIdx; i++)
1123 if (i/9==idx)
1124 data.EnablePixel(i, enable);
1125
1126 CmdSendStatDat(data);
1127
1128 return true;
1129 }
1130
1131 bool TogglePixel(uint16_t idx)
1132 {
1133 if (idx>FTM::StaticData::kMaxPixelIdx)
1134 return false;
1135
1136 FTM::StaticData data(fStaticData);
1137
1138 data.EnablePixel(idx, !fStaticData.Enabled(idx));
1139
1140 CmdSendStatDat(data);
1141
1142 return true;
1143 }
1144
1145 States GetState() const
1146 {
1147 if (!IsConnected())
1148 return kDisconnected;
1149
1150 switch (fHeader.fState&FTM::kFtmStates)
1151 {
1152 case FTM::kFtmUndefined:
1153 return kConnected;
1154
1155 case FTM::kFtmRunning:
1156 case FTM::kFtmCalib:
1157 return kTriggerOn;
1158
1159 case FTM::kFtmIdle:
1160 case FTM::kFtmConfig:
1161 return fStaticData == fBufStaticData ? kConfigured : kIdle;
1162 }
1163
1164 throw runtime_error("ConnectionFTM::GetState - Impossible code reached.");
1165 }
1166
1167 int GetCounter(FTM::Types type) { return fCounter[type]; }
1168
1169 const FTM::StaticData &GetStaticData() const { return fStaticData; }
1170};
1171
1172//const uint16_t ConnectionFTM::kMaxAddr = 0xfff;
1173
1174// ------------------------------------------------------------------------
1175
1176#include "DimDescriptionService.h"
1177
1178class ConnectionDimFTM : public ConnectionFTM
1179{
1180private:
1181
1182 DimDescribedService fDimPassport;
1183 DimDescribedService fDimTriggerRates;
1184 DimDescribedService fDimError;
1185 DimDescribedService fDimFtuList;
1186 DimDescribedService fDimStaticData;
1187 DimDescribedService fDimDynamicData;
1188 DimDescribedService fDimCounter;
1189
1190 uint64_t fTimeStamp;
1191 uint64_t fTimeStampOn;
1192 uint32_t fTriggerCounter;
1193
1194 void UpdateFirstHeader()
1195 {
1196 ConnectionFTM::UpdateFirstHeader();
1197
1198 const FTM::DimPassport data(fHeader);
1199 fDimPassport.Update(data);
1200 }
1201
1202 /*
1203 void UpdateHeader()
1204 {
1205 ConnectionFTM::UpdateHeader();
1206
1207 if (fHeader.fType!=FTM::kDynamicData)
1208 return;
1209
1210 const FTM::DimTriggerCounter data(fHeader);
1211 fDimTriggerCounter.Update(data);
1212 }*/
1213
1214 void UpdateFtuList()
1215 {
1216 ConnectionFTM::UpdateFtuList();
1217
1218 const FTM::DimFtuList data(fHeader, fFtuList);
1219 fDimFtuList.Update(data);
1220 }
1221
1222 void UpdateStaticData()
1223 {
1224 ConnectionFTM::UpdateStaticData();
1225
1226 const FTM::DimStaticData data(fHeader, fStaticData);
1227 fDimStaticData.Update(data);
1228 }
1229
1230 void UpdateDynamicData()
1231 {
1232 ConnectionFTM::UpdateDynamicData();
1233
1234 const FTM::DimDynamicData data(fHeader, fDynamicData, fStaticData);
1235 fDimDynamicData.Update(data);
1236
1237 float rate = -1;
1238 uint64_t tdiff = 0;
1239 uint64_t odiff = 0;
1240 if (fHeader.fTimeStamp>=fTimeStamp && fHeader.fTriggerCounter>=fTriggerCounter)
1241 {
1242 tdiff = fHeader.fTimeStamp -fTimeStamp;
1243 odiff = fDynamicData.fOnTimeCounter -fTimeStampOn;
1244
1245 const uint32_t cdiff = fHeader.fTriggerCounter-fTriggerCounter;
1246 rate = tdiff==0 ? 0 : 1000000*float(cdiff)/tdiff;
1247 }
1248
1249 fTimeStamp = fHeader.fTimeStamp;
1250 fTimeStampOn = fDynamicData.fOnTimeCounter;
1251 fTriggerCounter = fHeader.fTriggerCounter;
1252
1253 const FTM::DimTriggerRates rates(fHeader, fDynamicData, fStaticData,
1254 rate, tdiff*1e-6, odiff*1e-6);
1255
1256 fDimTriggerRates.Update(rates);
1257 }
1258
1259 void UpdateError()
1260 {
1261 ConnectionFTM::UpdateError();
1262
1263 const FTM::DimError data(fHeader, fError);
1264 fDimError.Update(data);
1265 }
1266
1267 void UpdateCounter()
1268 {
1269 ConnectionFTM::UpdateCounter();
1270
1271 const uint32_t counter[6] =
1272 {
1273 fCounter[FTM::kHeader],
1274 fCounter[FTM::kStaticData],
1275 fCounter[FTM::kDynamicData],
1276 fCounter[FTM::kFtuList],
1277 fCounter[FTM::kErrorList],
1278 fCounter[FTM::kRegister],
1279 };
1280
1281 fDimCounter.Update(counter);
1282 }
1283
1284public:
1285 ConnectionDimFTM(ba::io_service& ioservice, MessageImp &imp) :
1286 ConnectionFTM(ioservice, imp),
1287 fDimPassport ("FTM_CONTROL/PASSPORT", "X:1;S:1",
1288 "Info about the FTM and FPGA version"
1289 "|Data0[int]:BoardId, hexCode"
1290 "|Data1[int]:DNA of the FTM board"),
1291 fDimTriggerRates ("FTM_CONTROL/TRIGGER_RATES", "X:1;X:1;I:1;F:1;F:40;F:160;F:1;F:1",
1292 "Patch,Board,Camera trigger rates"
1293 "|FTMtimeStamp[us]:Time in microseconds, since trigger enabled or disabled"
1294 "|OnTimeCounter[us]:Effective on-time, i.e. FTM processes triggers (e.g. No FAD busy)"
1295 "|TriggerCounter[int]:Counter of camera trigers (events) since trigger enabled or disabled"
1296 "|TriggerRate[Hz]:Trigger rate"
1297 "|BoardRate[Hz]:Trigger rate of individual FTUs"
1298 "|PatchRate[Hz]:Trigger rate of individual patches"
1299 "|ElapsedTime[sec]:Time elapsed since previous report"
1300 "|OnTime[sec]:OnTime elapsed since previous report"),
1301 fDimError ("FTM_CONTROL/ERROR", "X:1;S:1;S:28", ""),
1302 fDimFtuList ("FTM_CONTROL/FTU_LIST", "X:1;X:1;S:1;C:4;X:40;C:40;C:40",
1303 "Logs the changes of status of the FTUs"
1304 "|FTMtimeStamp[us]:Time in microseconds"
1305 "|ActiveFTU[bitpattern]:Description of enabled FTUs"
1306 "|NumBoards[int]:Total number of enabled FTUs"
1307 "|NumBoardsCrate[int]:Total number of enabled FTUs per crate"
1308 "|DNA[hexCode]:Hex code identifier of FTUs"
1309 "|Addr[bitpattern]:Crate address (hardware) of FTUs"
1310 "|Ping[int]:Number of pings until FTU response"),
1311 fDimStaticData ("FTM_CONTROL/STATIC_DATA", "X:1;S:1;S:1;X:1;S:1;S:3;C:4;S:1;S:1;S:1;S:1;S:1;S:1;I:1;I:8;S:90;S:160;S:40;S:40",
1312 "Configuration of FTM and FTUs"
1313 "|FTMtimeStamp[us]:Time in microseconds, since trigger enabled or disabled"
1314 "|GeneralSettings[bitpattern]:Status of the FTM settings (cf. FTM doc)"
1315 "|LEDStatus[bitpattern]:Not Used"
1316 "|ActiveFTU[bitpattern]:List of enabled FTUs"
1317 "|TriggerInterval[bitpattern]:Period of cal. and ped. events (cf. FTM doc)"
1318 "|TriggerSeq[int]:Sequence of calib. and pedestal events (LPint, LPext, Ped)"
1319 "|LPSettings[bitpattern]:Settings of LP, enabled int, ext, intensity int, ext"
1320 "|PhysTrigMult[int]:N for N out of 40 logic on FTM (Physics)"
1321 "|CalibTrigMult[int]: N for N out of 40 logic on FTM (Calib)"
1322 "|PhysTrigWindow[ns]:Coincidence window for N out of 40 (Physics)"
1323 "|CalibTrigWindow[ns]:Coincidence window for N out of 40 (Calib)"
1324 "|TrigDelay[ns]:Trigger delay applied on FTM"
1325 "|TMDelay[ns]:TM delay applied on FTM"
1326 "|DeadTime[ns]:Dead time applied after each event on the FTM"
1327 "|ClkCond[bitpattern]:Clock conditionner settings on the FTM (DRS sampling freq.)"
1328 "|PixEnabled[bitpattern]:Enabled pixels, pckd in 90 shorts (160*9bits=180bytes)"
1329 "|PatchThresh[DACcounts]:Threshold of the trigger patches"
1330 "|Multiplicity[DACcounts]:N out of 4 logic settings per FTU"
1331 "|Prescaling[500ms]:Update rate of the rate counter"),
1332
1333 fDimDynamicData ("FTM_CONTROL/DYNAMIC_DATA", "X:1;X:1;F:4;I:160;I:40;S:40;S:40;S:40;S:1",
1334 "Regular reports sent by FTM"
1335 "|FTMtimeStamp[us]:Time in microseconds, since trigger enabled or disabled"
1336 "|OnTimeCounter[us]:Ontime, i.e. FTM processes triggers (e.g. No FAD busy)"
1337 "|Temperatures[Nan]:not yet defined nor used (wanna be FTM onboard temps)"
1338 "|TriggerPatchCounter[int]:trigger patches counting since last update (prescaling)"
1339 "|BoardsCounter[int]:FTU board counting after N out of 4 and since last update"
1340 "|RateOverflow[bitpattern]:bits 0-4=patches overflow, 5=board overflow, 1 per board"
1341 "|Prescaling[500ms]:Update rate of the rate counter"
1342 "|CrcError[int]:Number of checksum error in RS485 communication"
1343 "|State[int]:State value of the FTM firmware (cf. FTM doc)"),
1344 fDimCounter ("FTM_CONTROL/COUNTER", "I:1;I:1;I:1;I:1;I:1;I:1",
1345 "Communication statistics to or from FTM control and FTM"
1346 "|Data0[int]:Num. of headers (any header) received by ftm control"
1347 "|Data1[int]:Num. of static data blocks (ftm and ftu settings)"
1348 "|Data2[int]:Num. of dynamic data blocks (e.g. rates)"
1349 "|Data3[int]:Num. of FTU list (FTU identifiers, answer from ping)"
1350 "|Data4[int]:Num. of error messages"
1351 "|Data5[int]:Num. of answers from a single register accesess"),
1352 fTimeStamp(UINT64_MAX),
1353 fTriggerCounter(UINT32_MAX)
1354 {
1355 }
1356
1357 // A B [C] [D] E [F] G H [I] J K [L] M N O P Q R [S] T U V W [X] Y Z
1358};
1359
1360// ------------------------------------------------------------------------
1361
1362template <class T, class S>
1363class StateMachineFTM : public T, public ba::io_service, public ba::io_service::work
1364{
1365 int Wrap(boost::function<void()> f)
1366 {
1367 f();
1368 return T::GetCurrentState();
1369 }
1370
1371 function<int(const EventImp &)> Wrapper(function<void()> func)
1372 {
1373 return bind(&StateMachineFTM::Wrap, this, func);
1374 }
1375
1376private:
1377 S fFTM;
1378
1379 bool CheckEventSize(size_t has, const char *name, size_t size)
1380 {
1381 if (has==size)
1382 return true;
1383
1384 ostringstream msg;
1385 msg << name << " - Received event has " << has << " bytes, but expected " << size << ".";
1386 T::Fatal(msg);
1387 return false;
1388 }
1389
1390 int SetRegister(const EventImp &evt)
1391 {
1392 if (!CheckEventSize(evt.GetSize(), "SetRegister", 8))
1393 return T::kSM_FatalError;
1394
1395 const uint32_t *dat = evt.Ptr<uint32_t>();
1396
1397 if (dat[1]>uint16_t(-1))
1398 {
1399 ostringstream msg;
1400 msg << hex << "Value " << dat[1] << " out of range.";
1401 T::Error(msg);
1402 return T::GetCurrentState();
1403 }
1404
1405
1406 if (dat[0]>uint16_t(-1) || !fFTM.CmdSetRegister(dat[0], dat[1]))
1407 {
1408 ostringstream msg;
1409 msg << hex << "Address " << dat[0] << " out of range.";
1410 T::Error(msg);
1411 }
1412
1413 return T::GetCurrentState();
1414 }
1415
1416 int GetRegister(const EventImp &evt)
1417 {
1418 if (!CheckEventSize(evt.GetSize(), "GetRegister", 4))
1419 return T::kSM_FatalError;
1420
1421 const unsigned int addr = evt.GetInt();
1422 if (addr>uint16_t(-1) || !fFTM.CmdGetRegister(addr))
1423 {
1424 ostringstream msg;
1425 msg << hex << "Address " << addr << " out of range.";
1426 T::Error(msg);
1427 }
1428
1429 return T::GetCurrentState();
1430 }
1431
1432 int TakeNevents(const EventImp &evt)
1433 {
1434 if (!CheckEventSize(evt.GetSize(), "TakeNevents", 4))
1435 return T::kSM_FatalError;
1436
1437 const unsigned int dat = evt.GetUInt();
1438
1439 /*
1440 if (dat[1]>uint32_t(-1))
1441 {
1442 ostringstream msg;
1443 msg << hex << "Value " << dat[1] << " out of range.";
1444 T::Error(msg);
1445 return T::GetCurrentState();
1446 }*/
1447
1448 fFTM.CmdTakeNevents(dat);
1449
1450 return T::GetCurrentState();
1451 }
1452
1453 int DisableReports(const EventImp &evt)
1454 {
1455 if (!CheckEventSize(evt.GetSize(), "DisableReports", 1))
1456 return T::kSM_FatalError;
1457
1458 fFTM.CmdDisableReports(evt.GetBool());
1459
1460 return T::GetCurrentState();
1461 }
1462
1463 int SetVerbosity(const EventImp &evt)
1464 {
1465 if (!CheckEventSize(evt.GetSize(), "SetVerbosity", 1))
1466 return T::kSM_FatalError;
1467
1468 fFTM.SetVerbose(evt.GetBool());
1469
1470 return T::GetCurrentState();
1471 }
1472
1473 int SetHexOutput(const EventImp &evt)
1474 {
1475 if (!CheckEventSize(evt.GetSize(), "SetHexOutput", 1))
1476 return T::kSM_FatalError;
1477
1478 fFTM.SetHexOutput(evt.GetBool());
1479
1480 return T::GetCurrentState();
1481 }
1482
1483 int SetDynamicOut(const EventImp &evt)
1484 {
1485 if (!CheckEventSize(evt.GetSize(), "SetDynamicOut", 1))
1486 return T::kSM_FatalError;
1487
1488 fFTM.SetDynamicOut(evt.GetBool());
1489
1490 return T::GetCurrentState();
1491 }
1492
1493 int LoadStaticData(const EventImp &evt)
1494 {
1495 if (fFTM.LoadStaticData(evt.GetString()))
1496 return T::GetCurrentState();
1497
1498 ostringstream msg;
1499 msg << "Loading static data from file '" << evt.GetString() << "' failed ";
1500
1501 if (errno)
1502 msg << "(" << strerror(errno) << ")";
1503 else
1504 msg << "(wrong size, expected " << sizeof(FTM::StaticData) << " bytes)";
1505
1506 T::Warn(msg);
1507
1508 return T::GetCurrentState();
1509 }
1510
1511 int SaveStaticData(const EventImp &evt)
1512 {
1513 if (fFTM.SaveStaticData(evt.GetString()))
1514 return T::GetCurrentState();
1515
1516 ostringstream msg;
1517 msg << "Writing static data to file '" << evt.GetString() << "' failed ";
1518 msg << "(" << strerror(errno) << ")";
1519
1520 T::Warn(msg);
1521
1522 return T::GetCurrentState();
1523 }
1524
1525 int SetThreshold(const EventImp &evt)
1526 {
1527 if (!CheckEventSize(evt.GetSize(), "SetThreshold", 8))
1528 return T::kSM_FatalError;
1529
1530 const int32_t *data = evt.Ptr<int32_t>();
1531
1532 if (!fFTM.SetThreshold(data[0], data[1]))
1533 {
1534 ostringstream msg;
1535 msg << "SetThreshold - Maximum allowed patch number 159, valid value range 0-0xffff (got: " << data[0] << " " << data[1] << ")";
1536 T::Warn(msg);
1537 }
1538
1539 return T::GetCurrentState();
1540 }
1541
1542 int SetNoutof4(const EventImp &evt)
1543 {
1544 if (!CheckEventSize(evt.GetSize(), "SetNoutof4", 8))
1545 return T::kSM_FatalError;
1546
1547 const int32_t *data = evt.Ptr<int32_t>();
1548
1549 if (!fFTM.SetNoutof4(data[0], data[1]))
1550 T::Warn("SetNoutof4 - Maximum allowed board number 39, valid value range 0-0xffff");
1551
1552 return T::GetCurrentState();
1553 }
1554
1555 int EnableFTU(const EventImp &evt)
1556 {
1557 if (!CheckEventSize(evt.GetSize(), "EnableFTU", 5))
1558 return T::kSM_FatalError;
1559
1560 const int32_t &board = evt.Get<int32_t>();
1561 const int8_t &enable = evt.Get<int8_t>(4);
1562
1563 if (!fFTM.EnableFTU(board, enable))
1564 T::Warn("EnableFTU - Board number must be <40.");
1565
1566 return T::GetCurrentState();
1567 }
1568
1569 int ToggleFTU(const EventImp &evt)
1570 {
1571 if (!CheckEventSize(evt.GetSize(), "ToggleFTU", 4))
1572 return T::kSM_FatalError;
1573
1574 if (!fFTM.ToggleFTU(evt.GetInt()))
1575 T::Warn("ToggleFTU - Allowed range of boards 0-39.");
1576
1577 return T::GetCurrentState();
1578 }
1579
1580 int SetTriggerInterval(const EventImp &evt)
1581 {
1582 if (!CheckEventSize(evt.GetSize(), "SetTriggerInterval", 4))
1583 return T::kSM_FatalError;
1584
1585 if (!fFTM.SetTriggerInterval(evt.GetInt()))
1586 T::Warn("SetTriggerInterval - Value out of range.");
1587
1588 return T::GetCurrentState();
1589 }
1590
1591 int SetTriggerDelay(const EventImp &evt)
1592 {
1593 if (!CheckEventSize(evt.GetSize(), "SetTriggerDelay", 4))
1594 return T::kSM_FatalError;
1595
1596 if (!fFTM.SetTriggerDelay(evt.GetInt()))
1597 T::Warn("SetTriggerDealy - Value out of range.");
1598
1599 return T::GetCurrentState();
1600 }
1601
1602 int SetTimeMarkerDelay(const EventImp &evt)
1603 {
1604 if (!CheckEventSize(evt.GetSize(), "SetTimeMarkerDelay", 4))
1605 return T::kSM_FatalError;
1606
1607 if (!fFTM.SetTimeMarkerDelay(evt.GetInt()))
1608 T::Warn("SetTimeMarkerDelay - Value out of range.");
1609
1610 return T::GetCurrentState();
1611 }
1612
1613 int SetPrescaling(const EventImp &evt)
1614 {
1615 if (!CheckEventSize(evt.GetSize(), "SetPrescaling", 4))
1616 return T::kSM_FatalError;
1617
1618 if (!fFTM.SetPrescaling(evt.GetInt()-1))
1619 T::Warn("SetPrescaling - Value out of range.");
1620
1621 return T::GetCurrentState();
1622 }
1623
1624 int SetTriggerSeq(const EventImp &evt)
1625 {
1626 if (!CheckEventSize(evt.GetSize(), "SetTriggerSeq", 6))
1627 return T::kSM_FatalError;
1628
1629 const uint16_t *data = evt.Ptr<uint16_t>();
1630
1631 if (!fFTM.SetTriggerSeq(data))
1632 T::Warn("SetTriggerSeq - Value out of range.");
1633
1634 return T::GetCurrentState();
1635 }
1636
1637 int SetDeadTime(const EventImp &evt)
1638 {
1639 if (!CheckEventSize(evt.GetSize(), "SetDeadTime", 4))
1640 return T::kSM_FatalError;
1641
1642 if (!fFTM.SetDeadTime(evt.GetInt()))
1643 T::Warn("SetDeadTime - Value out of range.");
1644
1645 return T::GetCurrentState();
1646 }
1647
1648 int SetTriggerMultiplicity(const EventImp &evt)
1649 {
1650 if (!CheckEventSize(evt.GetSize(), "SetTriggerMultiplicity", 2))
1651 return T::kSM_FatalError;
1652
1653 if (!fFTM.SetTriggerMultiplicity(evt.GetUShort()))
1654 T::Warn("SetTriggerMultiplicity - Value out of range.");
1655
1656 return T::GetCurrentState();
1657 }
1658
1659 int SetCalibMultiplicity(const EventImp &evt)
1660 {
1661 if (!CheckEventSize(evt.GetSize(), "SetCalibMultiplicity", 2))
1662 return T::kSM_FatalError;
1663
1664 if (!fFTM.SetCalibMultiplicity(evt.GetUShort()))
1665 T::Warn("SetCalibMultiplicity - Value out of range.");
1666
1667 return T::GetCurrentState();
1668 }
1669
1670 int SetTriggerWindow(const EventImp &evt)
1671 {
1672 if (!CheckEventSize(evt.GetSize(), "SetTriggerWindow", 2))
1673 return T::kSM_FatalError;
1674
1675 if (!fFTM.SetTriggerWindow(evt.GetUShort()))
1676 T::Warn("SetTriggerWindow - Value out of range.");
1677
1678 return T::GetCurrentState();
1679 }
1680
1681 int SetCalibWindow(const EventImp &evt)
1682 {
1683 if (!CheckEventSize(evt.GetSize(), "SetCalibWindow", 2))
1684 return T::kSM_FatalError;
1685
1686 if (!fFTM.SetCalibWindow(evt.GetUShort()))
1687 T::Warn("SetCalibWindow - Value out of range.");
1688
1689 return T::GetCurrentState();
1690 }
1691
1692 int SetClockRegister(const EventImp &evt)
1693 {
1694 if (!CheckEventSize(evt.GetSize(), "SetClockRegister", 8*8))
1695 return T::kSM_FatalError;
1696
1697 const uint64_t *reg = evt.Ptr<uint64_t>();
1698
1699 if (!fFTM.SetClockRegister(reg))
1700 T::Warn("SetClockRegister - Value out of range.");
1701
1702 return T::GetCurrentState();
1703 }
1704
1705 int SetClockFrequency(const EventImp &evt)
1706 {
1707 if (!CheckEventSize(evt.GetSize(), "SetClockFrequency", 2))
1708 return T::kSM_FatalError;
1709
1710 const map<uint16_t,array<uint64_t, 8>>::const_iterator it =
1711 fClockCondSetup.find(evt.GetUShort());
1712
1713 if (it==fClockCondSetup.end())
1714 {
1715 T::Warn("SetClockFrequency - Frequency not supported.");
1716 return T::GetCurrentState();
1717 }
1718
1719 if (!fFTM.SetClockRegister(it->second.data()))
1720 T::Warn("SetClockFrequency - Register values out of range.");
1721
1722 return T::GetCurrentState();
1723 }
1724
1725 int EnableLP(const EventImp &evt, FTM::StaticData::GeneralSettings lp, FTM::StaticData::LightPulserEnable group)
1726 {
1727 if (!CheckEventSize(evt.GetSize(), "EnableLP", 1))
1728 return T::kSM_FatalError;
1729
1730 if (!fFTM.EnableLP(lp, group, evt.GetBool()))
1731 T::Warn("EnableLP - Invalid light pulser id.");
1732
1733 return T::GetCurrentState();
1734 }
1735
1736 int SetIntensity(const EventImp &evt, FTM::StaticData::GeneralSettings lp)
1737 {
1738 if (!CheckEventSize(evt.GetSize(), "SetIntensity", 2))
1739 return T::kSM_FatalError;
1740
1741 if (!fFTM.SetIntensity(lp, evt.GetShort()))
1742 T::Warn("SetIntensity - Value out of range.");
1743
1744 return T::GetCurrentState();
1745 }
1746
1747 int Enable(const EventImp &evt, FTM::StaticData::GeneralSettings type)
1748 {
1749 if (!CheckEventSize(evt.GetSize(), "Enable", 1))
1750 return T::kSM_FatalError;
1751
1752 fFTM.Enable(type, evt.GetBool());
1753
1754 return T::GetCurrentState();
1755 }
1756
1757 int EnablePixel(const EventImp &evt, bool b)
1758 {
1759 if (!CheckEventSize(evt.GetSize(), "EnablePixel", 2))
1760 return T::kSM_FatalError;
1761
1762 if (!fFTM.EnablePixel(evt.GetUShort(), b))
1763 T::Warn("EnablePixel - Value out of range.");
1764
1765 return T::GetCurrentState();
1766 }
1767
1768 int DisableAllPixelsExcept(const EventImp &evt)
1769 {
1770 if (!CheckEventSize(evt.GetSize(), "DisableAllPixelsExcept", 2))
1771 return T::kSM_FatalError;
1772
1773 if (!fFTM.DisableAllPixelsExcept(evt.GetUShort()))
1774 T::Warn("DisableAllPixelsExcept - Value out of range.");
1775
1776 return T::GetCurrentState();
1777 }
1778
1779 int DisableAllPatchesExcept(const EventImp &evt)
1780 {
1781 if (!CheckEventSize(evt.GetSize(), "DisableAllPatchesExcept", 2))
1782 return T::kSM_FatalError;
1783
1784 if (!fFTM.DisableAllPatchesExcept(evt.GetUShort()))
1785 T::Warn("DisableAllPatchesExcept - Value out of range.");
1786
1787 return T::GetCurrentState();
1788 }
1789
1790 int EnablePatch(const EventImp &evt, bool enable)
1791 {
1792 if (!CheckEventSize(evt.GetSize(), "EnablePatch", 2))
1793 return T::kSM_FatalError;
1794
1795 if (!fFTM.EnablePatch(evt.GetUShort(), enable))
1796 T::Warn("EnablePatch - Value out of range.");
1797
1798 return T::GetCurrentState();
1799 }
1800
1801 int TogglePixel(const EventImp &evt)
1802 {
1803 if (!CheckEventSize(evt.GetSize(), "TogglePixel", 2))
1804 return T::kSM_FatalError;
1805
1806 if (!fFTM.TogglePixel(evt.GetUShort()))
1807 T::Warn("TogglePixel - Value out of range.");
1808
1809 return T::GetCurrentState();
1810 }
1811
1812 int ResetCrate(const EventImp &evt)
1813 {
1814 if (!CheckEventSize(evt.GetSize(), "ResetCrate", 2))
1815 return T::kSM_FatalError;
1816
1817 fFTM.CmdResetCrate(evt.GetUShort());
1818
1819 return T::GetCurrentState();
1820 }
1821
1822 int Disconnect()
1823 {
1824 // Close all connections
1825 fFTM.PostClose(false);
1826
1827 /*
1828 // Now wait until all connection have been closed and
1829 // all pending handlers have been processed
1830 poll();
1831 */
1832
1833 return T::GetCurrentState();
1834 }
1835
1836 int Reconnect(const EventImp &evt)
1837 {
1838 // Close all connections to supress the warning in SetEndpoint
1839 fFTM.PostClose(false);
1840
1841 // Now wait until all connection have been closed and
1842 // all pending handlers have been processed
1843 poll();
1844
1845 if (evt.GetBool())
1846 fFTM.SetEndpoint(evt.GetString());
1847
1848 // Now we can reopen the connection
1849 fFTM.PostClose(true);
1850
1851 return T::GetCurrentState();
1852 }
1853
1854 /*
1855 int Transition(const Event &evt)
1856 {
1857 switch (evt.GetTargetState())
1858 {
1859 case kDisconnected:
1860 case kConnected:
1861 }
1862
1863 return T::kSM_FatalError;
1864 }*/
1865
1866 int64_t fCounterReg;
1867 int64_t fCounterStat;
1868
1869 typedef map<string, FTM::StaticData> Configs;
1870 Configs fConfigs;
1871 Configs::const_iterator fTargetConfig;
1872
1873 int ConfigureFTM(const EventImp &evt)
1874 {
1875 const string name = evt.GetText();
1876
1877 fTargetConfig = fConfigs.find(name);
1878 if (fTargetConfig==fConfigs.end())
1879 {
1880 T::Error("ConfigureFTM - Run-type '"+name+"' not found.");
1881 return T::GetCurrentState();
1882 }
1883
1884 T::Message("Starting configuration for '"+name+"'");
1885
1886 fCounterReg = fFTM.GetCounter(FTM::kRegister);
1887 fFTM.CmdStopRun();
1888
1889 return FTM::kConfiguring1;
1890 }
1891
1892 int ResetConfig()
1893 {
1894 return fFTM.GetState();
1895 }
1896
1897 int Execute()
1898 {
1899 // Dispatch (execute) at most one handler from the queue. In contrary
1900 // to run_one(), it doesn't wait until a handler is available
1901 // which can be dispatched, so poll_one() might return with 0
1902 // handlers dispatched. The handlers are always dispatched/executed
1903 // synchronously, i.e. within the call to poll_one()
1904 poll_one();
1905
1906 // If FTM is neither in data taking nor idle,
1907 // leave configuration state
1908 switch (fFTM.GetState())
1909 {
1910 case ConnectionFTM::kDisconnected: return FTM::kDisconnected;
1911 case ConnectionFTM::kConnected: return FTM::kConnected;
1912 default:
1913 break;
1914 }
1915
1916 switch (T::GetCurrentState())
1917 {
1918 case FTM::kConfiguring1:
1919 // If FTM has received an anwer to the stop_run command
1920 // the counter for the registers has been increased
1921 if (fFTM.GetCounter(FTM::kRegister)<=fCounterReg)
1922 break;
1923
1924 // If now the state is not idle as expected this means we had
1925 // an error (maybe old events waiting in the queue)
1926 if (fFTM.GetState()!=ConnectionFTM::kIdle &&
1927 fFTM.GetState()!=ConnectionFTM::kConfigured)
1928 return FTM::kConfigError1;
1929
1930 fCounterStat = fFTM.GetCounter(FTM::kStaticData);
1931
1932 T::Message("Trigger successfully disabled... sending new configuration.");
1933
1934 fFTM.CmdSendStatDat(fTargetConfig->second);
1935
1936 // Next state is: wait for the answer to our configuration
1937 return FTM::kConfiguring2;
1938
1939 case FTM::kConfiguring2:
1940 case FTM::kConfigured:
1941 // If FTM has received an anwer to the stop_run command
1942 // the counter for the registers has been increased
1943 if (fFTM.GetCounter(FTM::kStaticData)<=fCounterStat)
1944 break;
1945
1946 // If now the configuration is not what we expected
1947 // we had an error (maybe old events waiting in the queue?)
1948 // ======================
1949 if (fFTM.GetState()!=ConnectionFTM::kConfigured)
1950 return FTM::kConfigError2;
1951 // ======================
1952
1953 // Check configuration again when a new static data block
1954 // will be received
1955 fCounterStat = fFTM.GetCounter(FTM::kStaticData);
1956
1957 T::Info(" ==> TODO: Update run in database!");
1958 T::Message("Sending new configuration was successfull.");
1959
1960 // Next state is: wait for the answer to our configuration
1961 return FTM::kConfigured;
1962
1963 default:
1964 switch (fFTM.GetState())
1965 {
1966 case ConnectionFTM::kIdle: return FTM::kIdle;
1967 case ConnectionFTM::kConfigured: return FTM::kIdle;
1968 case ConnectionFTM::kTriggerOn: return FTM::kTriggerOn;
1969 default:
1970 throw runtime_error("StateMachienFTM - Execute() - Inavlid state.");
1971 }
1972 }
1973
1974 if (T::GetCurrentState()==FTM::kConfigured &&
1975 fFTM.GetState()==ConnectionFTM::kTriggerOn)
1976 return FTM::kTriggerOn;
1977
1978 return T::GetCurrentState();
1979 }
1980
1981public:
1982 StateMachineFTM(ostream &out=cout) :
1983 T(out, "FTM_CONTROL"), ba::io_service::work(static_cast<ba::io_service&>(*this)),
1984 fFTM(*this, *this)
1985 {
1986 // ba::io_service::work is a kind of keep_alive for the loop.
1987 // It prevents the io_service to go to stopped state, which
1988 // would prevent any consecutive calls to run()
1989 // or poll() to do nothing. reset() could also revoke to the
1990 // previous state but this might introduce some overhead of
1991 // deletion and creation of threads and more.
1992
1993
1994 // State names
1995 T::AddStateName(FTM::kDisconnected, "Disconnected",
1996 "FTM board not connected via ethernet.");
1997
1998 T::AddStateName(FTM::kConnected, "Connected",
1999 "Ethernet connection to FTM established (no state received yet).");
2000
2001 T::AddStateName(FTM::kIdle, "Idle",
2002 "Ethernet connection to FTM established, FTM in idle state.");
2003
2004 T::AddStateName(FTM::kConfiguring1, "Configuring1",
2005 "Command to diable run sent... waiting for response.");
2006 T::AddStateName(FTM::kConfiguring2, "Configuring2",
2007 "New configuration sent... waiting for response.");
2008 T::AddStateName(FTM::kConfigured, "Configured",
2009 "Received answer identical with target configuration.");
2010
2011 T::AddStateName(FTM::kTriggerOn, "TriggerOn",
2012 "Ethernet connection to FTM established, FTM trigger output to FADs enabled.");
2013
2014 T::AddStateName(FTM::kConfigError1, "ErrorInConfig1", "");
2015 T::AddStateName(FTM::kConfigError2, "ErrorInConfig2", "");
2016
2017 // FTM Commands
2018 T::AddEvent("TOGGLE_LED", FTM::kIdle)
2019 (Wrapper(bind(&ConnectionFTM::CmdToggleLed, &fFTM)))
2020 ("toggle led");
2021
2022 T::AddEvent("PING", FTM::kIdle)
2023 (Wrapper(bind(&ConnectionFTM::CmdPing, &fFTM)))
2024 ("send ping");
2025
2026 T::AddEvent("REQUEST_DYNAMIC_DATA", FTM::kIdle)
2027 (Wrapper(bind(&ConnectionFTM::CmdReqDynDat, &fFTM)))
2028 ("request transmission of dynamic data block");
2029
2030 T::AddEvent("REQUEST_STATIC_DATA", FTM::kIdle)
2031 (Wrapper(bind(&ConnectionFTM::CmdReqStatDat, &fFTM)))
2032 ("request transmission of static data from FTM to memory");
2033
2034 T::AddEvent("GET_REGISTER", "I", FTM::kIdle)
2035 (bind(&StateMachineFTM::GetRegister, this, placeholders::_1))
2036 ("read register from address addr"
2037 "|addr[short]:Address of register");
2038
2039 T::AddEvent("SET_REGISTER", "I:2", FTM::kIdle)
2040 (bind(&StateMachineFTM::SetRegister, this, placeholders::_1))
2041 ("set register to value"
2042 "|addr[short]:Address of register"
2043 "|val[short]:Value to be set");
2044
2045 T::AddEvent("START_TRIGGER", FTM::kIdle, FTM::kConfigured)
2046 (Wrapper(bind(&ConnectionFTM::CmdStartRun, &fFTM)))
2047 ("start a run (start distributing triggers)");
2048
2049 T::AddEvent("STOP_TRIGGER", FTM::kTriggerOn)
2050 (Wrapper(bind(&ConnectionFTM::CmdStopRun, &fFTM)))
2051 ("stop a run (stop distributing triggers)");
2052
2053 T::AddEvent("TAKE_N_EVENTS", "I", FTM::kIdle)
2054 (bind(&StateMachineFTM::TakeNevents, this, placeholders::_1))
2055 ("take n events (distribute n triggers)|number[int]:Number of events to be taken");
2056
2057 T::AddEvent("DISABLE_REPORTS", "B", FTM::kIdle)
2058 (bind(&StateMachineFTM::DisableReports, this, placeholders::_1))
2059 ("disable sending rate reports"
2060 "|status[bool]:disable or enable that the FTM sends rate reports (yes/no)");
2061
2062 T::AddEvent("SET_THRESHOLD", "I:2", FTM::kIdle, FTM::kConfigured, FTM::kTriggerOn)
2063 (bind(&StateMachineFTM::SetThreshold, this, placeholders::_1))
2064 ("Set the comparator threshold"
2065 "|Patch[idx]:Index of the patch (0-159), -1 for all"
2066 "|Threshold[counts]:Threshold to be set in binary counts");
2067
2068 T::AddEvent("SET_N_OUT_OF_4", "I:2", FTM::kIdle, FTM::kTriggerOn)
2069 (bind(&StateMachineFTM::SetNoutof4, this, placeholders::_1))
2070 ("Set the comparator threshold"
2071 "|Board[idx]:Index of the board (0-39), -1 for all"
2072 "|Threshold[counts]:Threshold to be set in binary counts");
2073
2074 T::AddEvent("SET_PRESCALING", "I:1", FTM::kIdle)
2075 (bind(&StateMachineFTM::SetPrescaling, this, placeholders::_1))
2076 ("");
2077
2078 T::AddEvent("ENABLE_FTU", "I:1;B:1", FTM::kIdle)
2079 (bind(&StateMachineFTM::EnableFTU, this, placeholders::_1))
2080 ("Enable or disable FTU"
2081 "|Board[idx]:Index of the board (0-39), -1 for all"
2082 "|Enable[bool]:Whether FTU should be enabled or disabled (yes/no)");
2083
2084 T::AddEvent("DISABLE_PIXEL", "S:1", FTM::kIdle, FTM::kTriggerOn)
2085 (bind(&StateMachineFTM::EnablePixel, this, placeholders::_1, false))
2086 ("(-1 or all)");
2087
2088 T::AddEvent("ENABLE_PIXEL", "S:1", FTM::kIdle, FTM::kTriggerOn)
2089 (bind(&StateMachineFTM::EnablePixel, this, placeholders::_1, true))
2090 ("(-1 or all)");
2091
2092 T::AddEvent("DISABLE_ALL_PIXELS_EXCEPT", "S:1", FTM::kIdle)
2093 (bind(&StateMachineFTM::DisableAllPixelsExcept, this, placeholders::_1))
2094 ("");
2095
2096 T::AddEvent("DISABLE_ALL_PATCHES_EXCEPT", "S:1", FTM::kIdle)
2097 (bind(&StateMachineFTM::DisableAllPatchesExcept, this, placeholders::_1))
2098 ("");
2099
2100 T::AddEvent("ENABLE_PATCH", "S:1", FTM::kIdle)
2101 (bind(&StateMachineFTM::EnablePatch, this, placeholders::_1, true))
2102 ("");
2103
2104 T::AddEvent("DISABLE_PATCH", "S:1", FTM::kIdle)
2105 (bind(&StateMachineFTM::EnablePatch, this, placeholders::_1, false))
2106 ("");
2107
2108 T::AddEvent("TOGGLE_PIXEL", "S:1", FTM::kIdle)
2109 (bind(&StateMachineFTM::TogglePixel, this, placeholders::_1))
2110 ("");
2111
2112 T::AddEvent("TOGGLE_FTU", "I:1", FTM::kIdle)
2113 (bind(&StateMachineFTM::ToggleFTU, this, placeholders::_1))
2114 ("Toggle status of FTU (this is mainly meant to be used in the GUI)"
2115 "|Board[idx]:Index of the board (0-39)");
2116
2117 T::AddEvent("SET_TRIGGER_INTERVAL", "I:1", FTM::kIdle)
2118 (bind(&StateMachineFTM::SetTriggerInterval, this, placeholders::_1))
2119 ("Sets the trigger interval which is the distance between two consecutive artificial triggers."
2120 "|interval[int]:The applied trigger interval is: interval*4ns+8ns");
2121
2122 T::AddEvent("SET_TRIGGER_DELAY", "I:1", FTM::kIdle)
2123 (bind(&StateMachineFTM::SetTriggerDelay, this, placeholders::_1))
2124 (""
2125 "|delay[int]:The applied trigger delay is: delay*4ns+8ns");
2126
2127 T::AddEvent("SET_TIME_MARKER_DELAY", "I:1", FTM::kIdle)
2128 (bind(&StateMachineFTM::SetTimeMarkerDelay, this, placeholders::_1))
2129 (""
2130 "|delay[int]:The applied time marker delay is: delay*4ns+8ns");
2131
2132 T::AddEvent("SET_DEAD_TIME", "I:1", FTM::kIdle)
2133 (bind(&StateMachineFTM::SetDeadTime, this, placeholders::_1))
2134 (""
2135 "|dead_time[int]:The applied dead time is: dead_time*4ns+8ns");
2136
2137 T::AddEvent("ENABLE_TRIGGER", "B:1", FTM::kIdle)
2138 (bind(&StateMachineFTM::Enable, this, placeholders::_1, FTM::StaticData::kTrigger))
2139 ("Switch on the physics trigger"
2140 "|Enable[bool]:Enable physics trigger (yes/no)");
2141
2142 // FIXME: Switch on/off depending on sequence
2143 T::AddEvent("ENABLE_EXT1", "B:1", FTM::kIdle)
2144 (bind(&StateMachineFTM::Enable, this, placeholders::_1, FTM::StaticData::kExt1))
2145 ("Switch on the triggers through the first external line"
2146 "|Enable[bool]:Enable ext1 trigger (yes/no)");
2147
2148 // FIXME: Switch on/off depending on sequence
2149 T::AddEvent("ENABLE_EXT2", "B:1", FTM::kIdle)
2150 (bind(&StateMachineFTM::Enable, this, placeholders::_1, FTM::StaticData::kExt2))
2151 ("Switch on the triggers through the second external line"
2152 "|Enable[bool]:Enable ext2 trigger (yes/no)");
2153
2154 T::AddEvent("ENABLE_VETO", "B:1", FTM::kIdle)
2155 (bind(&StateMachineFTM::Enable, this, placeholders::_1, FTM::StaticData::kVeto))
2156 ("Enable veto line"
2157 "|Enable[bool]:Enable veto (yes/no)");
2158
2159 T::AddEvent("ENABLE_CLOCK_CONDITIONER", "B:1", FTM::kIdle)
2160 (bind(&StateMachineFTM::Enable, this, placeholders::_1, FTM::StaticData::kClockConditioner))
2161 ("Enable clock conidtioner output in favor of time marker output"
2162 "|Enable[bool]:Enable clock conditioner (yes/no)");
2163
2164 T::AddEvent("ENABLE_GROUP1_LPINT", "B:1", FTM::kIdle)
2165 (bind(&StateMachineFTM::EnableLP, this, placeholders::_1, FTM::StaticData::kLPint, FTM::StaticData::kGroup1))
2166 ("");
2167 T::AddEvent("ENABLE_GROUP1_LPEXT", "B:1", FTM::kIdle)
2168 (bind(&StateMachineFTM::EnableLP, this, placeholders::_1, FTM::StaticData::kLPext, FTM::StaticData::kGroup1))
2169 ("");
2170 T::AddEvent("ENABLE_GROUP2_LPINT", "B:1", FTM::kIdle)
2171 (bind(&StateMachineFTM::EnableLP, this, placeholders::_1, FTM::StaticData::kLPint, FTM::StaticData::kGroup2))
2172 ("");
2173 T::AddEvent("ENABLE_GROUP2_LPEXT", "B:1", FTM::kIdle)
2174 (bind(&StateMachineFTM::EnableLP, this, placeholders::_1, FTM::StaticData::kLPext, FTM::StaticData::kGroup2))
2175 ("");
2176 T::AddEvent("SET_INTENSITY_LPINT", "S:1", FTM::kIdle)
2177 (bind(&StateMachineFTM::SetIntensity, this, placeholders::_1, FTM::StaticData::kLPint))
2178 ("");
2179 T::AddEvent("SET_INTENSITY_LPEXT", "S:1", FTM::kIdle)
2180 (bind(&StateMachineFTM::SetIntensity, this, placeholders::_1, FTM::StaticData::kLPext))
2181 ("");
2182
2183
2184 T::AddEvent("SET_TRIGGER_SEQUENCE", "S:3", FTM::kIdle)
2185 (bind(&StateMachineFTM::SetTriggerSeq, this, placeholders::_1))
2186 ("Setup the sequence of artificial triggers produced by the FTM"
2187 "|Ped[short]:number of pedestal triggers in a row"
2188 "|LPext[short]:number of triggers of the external light pulser"
2189 "|LPint[short]:number of triggers of the internal light pulser");
2190
2191 T::AddEvent("SET_TRIGGER_MULTIPLICITY", "S:1", FTM::kIdle)
2192 (bind(&StateMachineFTM::SetTriggerMultiplicity, this, placeholders::_1))
2193 ("Setup the Multiplicity condition for physcis triggers"
2194 "|N[int]:Number of requirered coincident triggers from sum-patches (1-40)");
2195
2196 T::AddEvent("SET_TRIGGER_WINDOW", "S:1", FTM::kIdle)
2197 (bind(&StateMachineFTM::SetTriggerWindow, this, placeholders::_1))
2198 ("");
2199
2200 T::AddEvent("SET_CALIBRATION_MULTIPLICITY", "S:1", FTM::kIdle)
2201 (bind(&StateMachineFTM::SetCalibMultiplicity, this, placeholders::_1))
2202 ("Setup the Multiplicity condition for artificial (calibration) triggers"
2203 "|N[int]:Number of requirered coincident triggers from sum-patches (1-40)");
2204
2205 T::AddEvent("SET_CALIBRATION_WINDOW", "S:1", FTM::kIdle)
2206 (bind(&StateMachineFTM::SetCalibWindow, this, placeholders::_1))
2207 ("");
2208
2209 T::AddEvent("SET_CLOCK_FREQUENCY", "S:1", FTM::kIdle)
2210 (bind(&StateMachineFTM::SetClockFrequency, this, placeholders::_1))
2211 ("");
2212
2213 T::AddEvent("SET_CLOCK_REGISTER", "X:8", FTM::kIdle)
2214 (bind(&StateMachineFTM::SetClockRegister, this, placeholders::_1))
2215 ("");
2216
2217 // A new configure will first stop the FTM this means
2218 // we can allow it in idle _and_ taking data
2219 T::AddEvent("CONFIGURE", "C", FTM::kIdle, FTM::kConfiguring1, FTM::kConfiguring2, FTM::kConfigured, FTM::kTriggerOn)
2220 (bind(&StateMachineFTM::ConfigureFTM, this, placeholders::_1))
2221 ("");
2222
2223 T::AddEvent("RESET_CONFIGURE", FTM::kConfiguring1, FTM::kConfiguring2, FTM::kConfigured, FTM::kConfigError1, FTM::kConfigError2)
2224 (bind(&StateMachineFTM::ResetConfig, this))
2225 ("");
2226
2227
2228
2229 T::AddEvent("RESET_CRATE", "S:1", FTM::kIdle)
2230 (bind(&StateMachineFTM::ResetCrate, this, placeholders::_1))
2231 ("Reset one of the crates 0-3"
2232 "|crate[short]:Crate number to be reseted (0-3)");
2233
2234 T::AddEvent("RESET_CAMERA", FTM::kIdle)
2235 (Wrapper(bind(&ConnectionFTM::CmdResetCamera, &fFTM)))
2236 ("Reset all crates. The commands are sent in the order 0,1,2,3");
2237
2238
2239 // Load/save static data block
2240 T::AddEvent("SAVE", "C", FTM::kIdle)
2241 (bind(&StateMachineFTM::SaveStaticData, this, placeholders::_1))
2242 ("Saves the static data (FTM configuration) from memory to a file"
2243 "|filename[string]:Filename (can include a path), .bin is automatically added");
2244
2245 T::AddEvent("LOAD", "C", FTM::kIdle)
2246 (bind(&StateMachineFTM::LoadStaticData, this, placeholders::_1))
2247 ("Loads the static data (FTM configuration) from a file into memory and sends it to the FTM"
2248 "|filename[string]:Filename (can include a path), .bin is automatically added");
2249
2250
2251
2252 // Verbosity commands
2253 T::AddEvent("SET_VERBOSE", "B")
2254 (bind(&StateMachineFTM::SetVerbosity, this, placeholders::_1))
2255 ("set verbosity state"
2256 "|verbosity[bool]:disable or enable verbosity for received data (yes/no), except dynamic data");
2257
2258 T::AddEvent("SET_HEX_OUTPUT", "B")
2259 (bind(&StateMachineFTM::SetHexOutput, this, placeholders::_1))
2260 ("enable or disable hex output for received data"
2261 "|hexout[bool]:disable or enable hex output for received data (yes/no)");
2262
2263 T::AddEvent("SET_DYNAMIC_OUTPUT", "B")
2264 (bind(&StateMachineFTM::SetDynamicOut, this, placeholders::_1))
2265 ("enable or disable output for received dynamic data (data is still broadcasted via Dim)"
2266 "|dynout[bool]:disable or enable output for dynamic data (yes/no)");
2267
2268
2269 // Conenction commands
2270 T::AddEvent("DISCONNECT", FTM::kConnected, FTM::kIdle)
2271 (bind(&StateMachineFTM::Disconnect, this))
2272 ("disconnect from ethernet");
2273
2274 T::AddEvent("RECONNECT", "O", FTM::kDisconnected, FTM::kConnected, FTM::kIdle, FTM::kConfigured)
2275 (bind(&StateMachineFTM::Reconnect, this, placeholders::_1))
2276 ("(Re)connect ethernet connection to FTM, a new address can be given"
2277 "|[host][string]:new ethernet address in the form <host:port>");
2278
2279 fFTM.StartConnect();
2280 }
2281
2282 void SetEndpoint(const string &url)
2283 {
2284 fFTM.SetEndpoint(url);
2285 }
2286
2287 map<uint16_t, array<uint64_t, 8>> fClockCondSetup;
2288
2289 template<class V>
2290 bool CheckConfigVal(Configuration &conf, V max, const string &name, const string &sub)
2291 {
2292 if (!conf.HasDef(name, sub))
2293 {
2294 T::Error("Neither "+name+"default nor "+name+sub+" found.");
2295 return false;
2296 }
2297
2298 const V val = conf.GetDef<V>(name, sub);
2299
2300 if (val<=max)
2301 return true;
2302
2303 ostringstream str;
2304 str << name << sub << "=" << val << " exceeds allowed maximum of " << max << "!";
2305 T::Error(str);
2306
2307 return false;
2308 }
2309
2310 int EvalOptions(Configuration &conf)
2311 {
2312 // ---------- General setup ----------
2313 fFTM.SetVerbose(!conf.Get<bool>("quiet"));
2314 fFTM.SetHexOutput(conf.Get<bool>("hex-out"));
2315 fFTM.SetDynamicOut(conf.Get<bool>("dynamic-out"));
2316
2317 // ---------- Setup clock conditioner frequencies ----------
2318 const vector<uint16_t> freq = conf.Vec<uint16_t>("clock-conditioner.frequency");
2319 if (freq.size()==0)
2320 T::Warn("No frequencies for the clock-conditioner defined.");
2321 else
2322 T::Message("Defining clock conditioner frequencies");
2323 for (vector<uint16_t>::const_iterator it=freq.begin();
2324 it!=freq.end(); it++)
2325 {
2326 if (fClockCondSetup.count(*it)>0)
2327 {
2328 T::Error("clock-conditioner frequency defined twice.");
2329 return 1;
2330 }
2331
2332 if (!conf.HasDef("clock-conditioner.R0.", *it) ||
2333 !conf.HasDef("clock-conditioner.R1.", *it) ||
2334 !conf.HasDef("clock-conditioner.R8.", *it) ||
2335 !conf.HasDef("clock-conditioner.R9.", *it) ||
2336 !conf.HasDef("clock-conditioner.R11.", *it) ||
2337 !conf.HasDef("clock-conditioner.R13.", *it) ||
2338 !conf.HasDef("clock-conditioner.R14.", *it) ||
2339 !conf.HasDef("clock-conditioner.R15.", *it))
2340 {
2341 T::Error("clock-conditioner values incomplete.");
2342 return 1;
2343 }
2344
2345 array<uint64_t, 8> &arr = fClockCondSetup[*it];
2346
2347 arr[0] = conf.GetDef<Hex<uint32_t>>("clock-conditioner.R0.", *it);
2348 arr[1] = conf.GetDef<Hex<uint32_t>>("clock-conditioner.R1.", *it);
2349 arr[2] = conf.GetDef<Hex<uint32_t>>("clock-conditioner.R8.", *it);
2350 arr[3] = conf.GetDef<Hex<uint32_t>>("clock-conditioner.R9.", *it);
2351 arr[4] = conf.GetDef<Hex<uint32_t>>("clock-conditioner.R11.", *it);
2352 arr[5] = conf.GetDef<Hex<uint32_t>>("clock-conditioner.R13.", *it);
2353 arr[6] = conf.GetDef<Hex<uint32_t>>("clock-conditioner.R14.", *it);
2354 arr[7] = conf.GetDef<Hex<uint32_t>>("clock-conditioner.R15.", *it);
2355
2356 ostringstream out;
2357 out << " -> " << setw(4) << *it << "MHz:" << hex << setfill('0');
2358 for (int i=0; i<8; i++)
2359 out << " " << setw(8) << arr[i];
2360 T::Message(out.str());
2361 }
2362
2363 // ---------- Setup run types ---------
2364 const vector<string> types = conf.Vec<string>("run-type");
2365 if (types.size()==0)
2366 T::Warn("No run-types defined.");
2367 else
2368 T::Message("Defining run-types");
2369 for (vector<string>::const_iterator it=types.begin();
2370 it!=types.end(); it++)
2371 {
2372 T::Message(" -> "+ *it);
2373
2374 if (fConfigs.count(*it)>0)
2375 {
2376 T::Error("Run-type "+*it+" defined twice.");
2377 return 2;
2378 }
2379
2380 if (!conf.HasDef("sampling-frequency.", *it))
2381 {
2382 T::Error("Neither sampling-frequency."+*it+" nor sampling-frequency.default found.");
2383 return 2;
2384 }
2385
2386 const uint16_t frq = conf.GetDef<uint16_t>("sampling-frequency.", *it);
2387
2388 FTM::StaticData data;
2389 data.SetClockRegister(fClockCondSetup[frq].data());
2390
2391 // Trigger sequence ped:lp1:lp2
2392 // (data. is used here as an abbreviation for FTM::StaticData::
2393 if (!CheckConfigVal<bool> (conf, true, "trigger.enable-trigger.", *it) ||
2394 !CheckConfigVal<bool> (conf, true, "trigger.enable-external-1.", *it) ||
2395 !CheckConfigVal<bool> (conf, true, "trigger.enable-external-2.", *it) ||
2396 !CheckConfigVal<bool> (conf, true, "trigger.enable-veto.", *it) ||
2397 !CheckConfigVal<bool> (conf, true, "trigger.enable-clock-conditioner.", *it) ||
2398 !CheckConfigVal<bool> (conf, true, "light-pulser.external.enable-group1.", *it) ||
2399 !CheckConfigVal<bool> (conf, true, "light-pulser.external.enable-group2.", *it) ||
2400 !CheckConfigVal<bool> (conf, true, "light-pulser.internal.enable-group1.", *it) ||
2401 !CheckConfigVal<bool> (conf, true, "light-pulser.internal.enable-group2.", *it) ||
2402 !CheckConfigVal<uint16_t>(conf, data.kMaxSequence, "trigger.sequence.pedestal.", *it) ||
2403 !CheckConfigVal<uint16_t>(conf, data.kMaxSequence, "trigger.sequence.lp-ext.", *it) ||
2404 !CheckConfigVal<uint16_t>(conf, data.kMaxSequence, "trigger.sequence.lp-int.", *it) ||
2405 !CheckConfigVal<uint16_t>(conf, data.kMaxTriggerInterval, "trigger.sequence.interval.", *it) ||
2406 !CheckConfigVal<uint16_t>(conf, data.kMaxMultiplicity, "trigger.multiplicity-physics.", *it) ||
2407 !CheckConfigVal<uint16_t>(conf, data.kMaxMultiplicity, "trigger.multiplicity-calib.", *it) ||
2408 !CheckConfigVal<uint16_t>(conf, data.kMaxWindow, "trigger.coincidence-window-physics.", *it) ||
2409 !CheckConfigVal<uint16_t>(conf, data.kMaxWindow, "trigger.coincidence-window-calib.", *it) ||
2410 !CheckConfigVal<uint16_t>(conf, data.kMaxDeadTime, "trigger.dead-time.", *it) ||
2411 !CheckConfigVal<uint16_t>(conf, data.kMaxDelayTrigger, "trigger.delay.", *it) ||
2412 !CheckConfigVal<uint16_t>(conf, data.kMaxDelayTimeMarker, "trigger.time-marker-delay.", *it) ||
2413 !CheckConfigVal<uint16_t>(conf, 0xffff, "ftu-report-interval.", *it) ||
2414 !CheckConfigVal<uint16_t>(conf, data.kMaxIntensity, "light-pulser.external.intensity.", *it) ||
2415 !CheckConfigVal<uint16_t>(conf, data.kMaxIntensity, "light-pulser.internal.intensity.", *it) ||
2416 !CheckConfigVal<uint16_t>(conf, data.kMaxDAC, "trigger.threshold.patch.", *it) ||
2417 !CheckConfigVal<uint16_t>(conf, data.kMaxDAC, "trigger.threshold.logic.", *it) ||
2418 0)
2419 return 2;
2420
2421 data.Enable(data.kTrigger, conf.GetDef<bool>("trigger.enable-trigger.", *it));
2422 data.Enable(data.kExt1, conf.GetDef<bool>("trigger.enable-external-1.", *it));
2423 data.Enable(data.kExt2, conf.GetDef<bool>("trigger.enable-external-2.", *it));
2424 data.Enable(data.kVeto, conf.GetDef<bool>("trigger.enable-veto.", *it));
2425 data.Enable(data.kClockConditioner, conf.GetDef<bool>("trigger.enable-clock-conditioner.", *it));
2426
2427 data.EnableLPint(data.kGroup1, conf.GetDef<bool>("light-pulser.internal.enable-group1.", *it));
2428 data.EnableLPint(data.kGroup2, conf.GetDef<bool>("light-pulser.internal.enable-group2.", *it));
2429 data.EnableLPext(data.kGroup1, conf.GetDef<bool>("light-pulser.external.enable-group1.", *it));
2430 data.EnableLPext(data.kGroup2, conf.GetDef<bool>("light-pulser.external.enable-group2.", *it));
2431
2432 // [ms] Interval between two artificial triggers (no matter which type) minimum 1ms, 10 bit
2433 data.fIntensityLPint = conf.GetDef<uint16_t>("light-pulser.internal.intensity.", *it);
2434 data.fIntensityLPext = conf.GetDef<uint16_t>("light-pulser.external.intensity.", *it);
2435 data.fTriggerInterval = conf.GetDef<uint16_t>("trigger.sequence.interval.", *it);
2436 data.fMultiplicityPhysics = conf.GetDef<uint16_t>("trigger.multiplicity-physics.", *it);
2437 data.fMultiplicityCalib = conf.GetDef<uint16_t>("trigger.multiplicity-calib.", *it);
2438 data.fWindowPhysics = conf.GetDef<uint16_t>("trigger.coincidence-window-physics.", *it); /// (4ns * x + 8ns)
2439 data.fWindowCalib = conf.GetDef<uint16_t>("trigger.coincidence-window-calib.", *it); /// (4ns * x + 8ns)
2440 data.fDelayTrigger = conf.GetDef<uint16_t>("trigger.delay.", *it); /// (4ns * x + 8ns)
2441 data.fDelayTimeMarker = conf.GetDef<uint16_t>("trigger.time-marker-delay.", *it); /// (4ns * x + 8ns)
2442 data.fDeadTime = conf.GetDef<uint16_t>("trigger.dead-time.", *it); /// (4ns * x + 8ns)
2443
2444 data.SetPrescaling(conf.GetDef<uint16_t>("ftu-report-interval.", *it));
2445
2446 const uint16_t seqped = conf.GetDef<uint16_t>("trigger.sequence.pedestal.", *it);
2447 const uint16_t seqint = conf.GetDef<uint16_t>("trigger.sequence.lp-int.", *it);
2448 const uint16_t seqext = conf.GetDef<uint16_t>("trigger.sequence.lp-ext.", *it);
2449
2450 data.SetSequence(seqped, seqint, seqext);
2451
2452 data.EnableAllFTU();
2453 data.EnableAllPixel();
2454
2455 const vector<uint16_t> pat1 = conf.Vec<uint16_t>("trigger.disable-patch.default");
2456 const vector<uint16_t> pat2 = conf.Vec<uint16_t>("trigger.disable-patch."+*it);
2457
2458 const vector<uint16_t> pix1 = conf.Vec<uint16_t>("trigger.disable-pixel.default");
2459 const vector<uint16_t> pix2 = conf.Vec<uint16_t>("trigger.disable-pixel."+*it);
2460
2461 const vector<uint16_t> ftu1 = conf.Vec<uint16_t>("disable-ftu.default");
2462 const vector<uint16_t> ftu2 = conf.Vec<uint16_t>("disable-ftu."+*it);
2463
2464 vector<uint16_t> ftu, pat, pix;
2465 ftu.insert(ftu.end(), ftu1.begin(), ftu1.end());
2466 ftu.insert(ftu.end(), ftu2.begin(), ftu2.end());
2467 pat.insert(pat.end(), pat1.begin(), pat1.end());
2468 pat.insert(pat.end(), pat2.begin(), pat2.end());
2469 pix.insert(pix.end(), pix1.begin(), pix1.end());
2470 pix.insert(pix.end(), pix2.begin(), pix2.end());
2471
2472 for (vector<uint16_t>::const_iterator ip=ftu.begin(); ip!=ftu.end(); ip++)
2473 {
2474 if (*ip>FTM::StaticData::kMaxPatchIdx)
2475 {
2476 ostringstream str;
2477 str << "disable-ftu.*=" << *ip << " exceeds allowed maximum of " << FTM::StaticData::kMaxPatchIdx << "!";
2478 T::Error(str);
2479 return 2;
2480 }
2481 data.DisableFTU(*ip);
2482 }
2483 for (vector<uint16_t>::const_iterator ip=pat.begin(); ip!=pat.end(); ip++)
2484 {
2485 if (*ip>FTM::StaticData::kMaxPatchIdx)
2486 {
2487 ostringstream str;
2488 str << "trigger.disable-patch.*=" << *ip << " exceeds allowed maximum of " << FTM::StaticData::kMaxPatchIdx << "!";
2489 T::Error(str);
2490 return 2;
2491 }
2492 data.EnablePatch(*ip, false);
2493 }
2494 for (vector<uint16_t>::const_iterator ip=pix.begin(); ip!=pix.end(); ip++)
2495 {
2496 if (*ip>FTM::StaticData::kMaxPixelIdx)
2497 {
2498 ostringstream str;
2499 str << "trigger.disable-pixel.*=" << *ip << " exceeds allowed maximum of " << FTM::StaticData::kMaxPixelIdx << "!";
2500 T::Error(str);
2501 return 2;
2502 }
2503 data.EnablePixel(*ip, false);
2504 }
2505
2506 const uint16_t th0 = conf.GetDef<uint16_t>("trigger.threshold.patch.", *it);
2507 const uint16_t th1 = conf.GetDef<uint16_t>("trigger.threshold.logic.", *it);
2508
2509 for (int i=0; i<40; i++)
2510 {
2511 data[i].fDAC[0] = th0;
2512 data[i].fDAC[1] = th0;
2513 data[i].fDAC[2] = th0;
2514 data[i].fDAC[3] = th0;
2515 data[i].fDAC[4] = th1;
2516 }
2517
2518 fConfigs[*it] = data;
2519
2520 // trigger.threshold.dac-0:
2521
2522 /*
2523 threshold-A data[n].fDAC[0] = val
2524 threshold-B data[n].fDAC[1] = val
2525 threshold-C data[n].fDAC[2] = val
2526 threshold-D data[n].fDAC[3] = val
2527 threshold-H data[n].fDAC[4] = val
2528 */
2529
2530 // kMaxDAC = 0xfff,
2531 }
2532
2533 // FIXME: Add a check about unsused configurations
2534
2535 // ---------- FOR TESTING PURPOSE ---------
2536
2537 // fFTM.SetDefaultSetup(conf.Get<string>("default-setup"));
2538 fConfigs["test"] = FTM::StaticData();
2539
2540 // ---------- Setup connection endpoint ---------
2541 SetEndpoint(conf.Get<string>("addr"));
2542
2543 return -1;
2544 }
2545};
2546
2547// ------------------------------------------------------------------------
2548
2549#include "Main.h"
2550
2551template<class T, class S, class R>
2552int RunShell(Configuration &conf)
2553{
2554 return Main::execute<T, StateMachineFTM<S, R>>(conf);
2555}
2556
2557void SetupConfiguration(Configuration &conf)
2558{
2559 po::options_description control("Control options");
2560 control.add_options()
2561 ("no-dim", po_bool(), "Disable dim services")
2562 ("addr,a", var<string>("localhost:5000"), "Network address of FTM")
2563 ("quiet,q", po_bool(), "Disable printing contents of all received messages (except dynamic data) in clear text.")
2564 ("hex-out", po_bool(), "Enable printing contents of all printed messages also as hex data.")
2565 ("dynamic-out", po_bool(), "Enable printing received dynamic data.")
2566// ("default-setup", var<string>(), "Binary file with static data loaded whenever a connection to the FTM was established.")
2567 ;
2568
2569 po::options_description freq("Sampling frequency setup");
2570 freq.add_options()
2571 ("clock-conditioner.frequency", vars<uint16_t>(), "Frequencies for which to setup the clock-conditioner (replace the * in the following options by this definition)")
2572 ("clock-conditioner.R0.*", var<Hex<uint32_t>>(), "Clock-conditioner R0")
2573 ("clock-conditioner.R1.*", var<Hex<uint32_t>>(), "Clock-conditioner R1")
2574 ("clock-conditioner.R8.*", var<Hex<uint32_t>>(), "Clock-conditioner R8")
2575 ("clock-conditioner.R9.*", var<Hex<uint32_t>>(), "Clock-conditioner R9")
2576 ("clock-conditioner.R11.*", var<Hex<uint32_t>>(), "Clock-conditioner R11")
2577 ("clock-conditioner.R13.*", var<Hex<uint32_t>>(), "Clock-conditioner R13")
2578 ("clock-conditioner.R14.*", var<Hex<uint32_t>>(), "Clock-conditioner R14")
2579 ("clock-conditioner.R15.*", var<Hex<uint32_t>>(), "Clock-conditioner R15");
2580
2581 po::options_description runtype("Run type configuration");
2582 runtype.add_options()
2583 ("run-type", vars<string>(), "Name of run-types (replace the * in the following configuration by the case-sensitive names defined here)")
2584 ("sampling-frequency.*", var<uint16_t>(), "Sampling frequency as defined in the clock-conditioner.frequency")
2585 ("trigger.enable-trigger.*", var<bool>(), "Enable trigger output of physics trigger")
2586 ("trigger.enable-external-1.*", var<bool>(), "Enable external trigger line 1")
2587 ("trigger.enable-external-2.*", var<bool>(), "Enable external trigger line 2")
2588 ("trigger.enable-veto.*", var<bool>(), "Enable veto line")
2589 ("trigger.enable-clock-conditioner.*", var<bool>(), "")
2590 ("trigger.sequence.interval.*", var<uint16_t>(), "Interval between two artifical triggers in units of n*4ns+8ns")
2591 ("trigger.sequence.pedestal.*", var<uint16_t>(), "Number of pedestal events in the sequence of artificial triggers")
2592 ("trigger.sequence.lp-int.*", var<uint16_t>(), "Number of LPint events in the sequence of artificial triggers")
2593 ("trigger.sequence.lp-ext.*", var<uint16_t>(), "Number of LPext events in the sequence of artificial triggers")
2594 ("trigger.multiplicity-physics.*", var<uint16_t>(), "Multiplicity for physics events (n out of 40)")
2595 ("trigger.multiplicity-calib.*", var<uint16_t>(), "Multiplicity for LPext events (n out of 40)")
2596 ("trigger.coincidence-window-physics.*", var<uint16_t>(), "Coincidence window for physics triggers in units of n*4ns+8ns")
2597 ("trigger.coincidence-window-calib.*", var<uint16_t>(), "Coincidence window for LPext triggers in units of n*4ns+8ns")
2598 ("trigger.dead-time.*", var<uint16_t>(), "Dead time after trigger in units of n*4ns+8ns")
2599 ("trigger.delay.*", var<uint16_t>(), "Delay of the trigger send to the FAD boards after a trigger in units of n*4ns+8ns")
2600 ("trigger.time-marker-delay.*", var<uint16_t>(), "Delay of the time-marker after a trigger in units of n*4ns+8ns")
2601 ("trigger.disable-pixel.*", vars<uint16_t>(), "")
2602 ("trigger.disable-patch.*", vars<uint16_t>(), "")
2603 ("trigger.threshold.patch.*", var<uint16_t>(), "")
2604 ("trigger.threshold.logic.*", var<uint16_t>(), "")
2605 ("ftu-report-interval.*", var<uint16_t>(), "")
2606 ("disable-ftu.*", var<uint16_t>(), "")
2607 ("light-pulser.external.enable-group1.*", var<bool>(), "Enable LED group 1 of external light pulser")
2608 ("light-pulser.external.enable-group2.*", var<bool>(), "Enable LED group 2 of external light pulser")
2609 ("light-pulser.internal.enable-group1.*", var<bool>(), "Enable LED group 1 of internal light pulser")
2610 ("light-pulser.internal.enable-group2.*", var<bool>(), "Enable LED group 2 of internal light pulser")
2611 ("light-pulser.external.intensity.*", var<uint16_t>(), "Intensity of external light pulser")
2612 ("light-pulser.internal.intensity.*", var<uint16_t>(), "Intensity of internal light pulser")
2613 ;
2614
2615 conf.AddOptions(control);
2616 conf.AddOptions(freq);
2617 conf.AddOptions(runtype);
2618}
2619
2620/*
2621 Extract usage clause(s) [if any] for SYNOPSIS.
2622 Translators: "Usage" and "or" here are patterns (regular expressions) which
2623 are used to match the usage synopsis in program output. An example from cp
2624 (GNU coreutils) which contains both strings:
2625 Usage: cp [OPTION]... [-T] SOURCE DEST
2626 or: cp [OPTION]... SOURCE... DIRECTORY
2627 or: cp [OPTION]... -t DIRECTORY SOURCE...
2628 */
2629void PrintUsage()
2630{
2631 cout <<
2632 "The ftmctrl controls the FTM (FACT Trigger Master) board.\n"
2633 "\n"
2634 "The default is that the program is started without user intercation. "
2635 "All actions are supposed to arrive as DimCommands. Using the -c "
2636 "option, a local shell can be initialized. With h or help a short "
2637 "help message about the usuage can be brought to the screen.\n"
2638 "\n"
2639 "Usage: ftmctrl [-c type] [OPTIONS]\n"
2640 " or: ftmctrl [OPTIONS]\n";
2641 cout << endl;
2642}
2643
2644void PrintHelp()
2645{
2646 Main::PrintHelp<StateMachineFTM<StateMachine, ConnectionFTM>>();
2647
2648 /* Additional help text which is printed after the configuration
2649 options goes here */
2650
2651 /*
2652 cout << "bla bla bla" << endl << endl;
2653 cout << endl;
2654 cout << "Environment:" << endl;
2655 cout << "environment" << endl;
2656 cout << endl;
2657 cout << "Examples:" << endl;
2658 cout << "test exam" << endl;
2659 cout << endl;
2660 cout << "Files:" << endl;
2661 cout << "files" << endl;
2662 cout << endl;
2663 */
2664}
2665
2666int main(int argc, const char* argv[])
2667{
2668 Configuration conf(argv[0]);
2669 conf.SetPrintUsage(PrintUsage);
2670 Main::SetupConfiguration(conf);
2671 SetupConfiguration(conf);
2672
2673 if (!conf.DoParse(argc, argv, PrintHelp))
2674 return -1;
2675
2676 //try
2677 {
2678 // No console access at all
2679 if (!conf.Has("console"))
2680 {
2681 if (conf.Get<bool>("no-dim"))
2682 return RunShell<LocalStream, StateMachine, ConnectionFTM>(conf);
2683 else
2684 return RunShell<LocalStream, StateMachineDim, ConnectionDimFTM>(conf);
2685 }
2686 // Cosole access w/ and w/o Dim
2687 if (conf.Get<bool>("no-dim"))
2688 {
2689 if (conf.Get<int>("console")==0)
2690 return RunShell<LocalShell, StateMachine, ConnectionFTM>(conf);
2691 else
2692 return RunShell<LocalConsole, StateMachine, ConnectionFTM>(conf);
2693 }
2694 else
2695 {
2696 if (conf.Get<int>("console")==0)
2697 return RunShell<LocalShell, StateMachineDim, ConnectionDimFTM>(conf);
2698 else
2699 return RunShell<LocalConsole, StateMachineDim, ConnectionDimFTM>(conf);
2700 }
2701 }
2702 /*catch (std::exception& e)
2703 {
2704 cerr << "Exception: " << e.what() << endl;
2705 return -1;
2706 }*/
2707
2708 return 0;
2709}
Note: See TracBrowser for help on using the repository browser.