source: trunk/FACT++/src/fadctrl.cc@ 10795

Last change on this file since 10795 was 10784, checked in by tbretz, 15 years ago
Added some code to redirect error output to fadctrl (still commented); replaces stringstream by ostringstream where needed.
File size: 47.9 KB
Line 
1#include <boost/bind.hpp>
2#include <boost/array.hpp>
3#if BOOST_VERSION < 104400
4#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 4))
5#undef BOOST_HAS_RVALUE_REFS
6#endif
7#endif
8#include <boost/thread.hpp>
9//#include <boost/foreach.hpp>
10#include <boost/asio/error.hpp>
11#include <boost/asio/deadline_timer.hpp>
12
13#include "FACT.h"
14#include "Dim.h"
15#include "Event.h"
16#include "Shell.h"
17#include "StateMachineDim.h"
18#include "Connection.h"
19#include "Configuration.h"
20#include "Timers.h"
21#include "Console.h"
22#include "Converter.h"
23#include "LocalControl.h"
24#include "HeadersFAD.h"
25
26#include "tools.h"
27
28namespace ba = boost::asio;
29namespace bs = boost::system;
30
31using ba::ip::tcp;
32
33using namespace std;
34
35#undef FAKE
36
37// ------------------------------------------------------------------------
38
39class ConnectionFAD : public Connection
40{
41 vector<uint16_t> fBuffer;
42
43protected:
44 FAD::EventHeader fEventHeader;
45 FAD::ChannelHeader fChannelHeader[FAD::kNumChannels];
46
47private:
48 bool fIsVerbose;
49 bool fIsHexOutput;
50 bool fIsDataOutput;
51
52 uint64_t fCounter;
53
54protected:
55 virtual void UpdateFirstHeader()
56 {
57 }
58
59 virtual void UpdateEventHeader()
60 {
61 // emit service with trigger counter from header
62 if (!fIsVerbose)
63 return;
64
65 Out() << endl << kBold << "Header received (N=" << dec << fCounter << "):" << endl;
66 Out() << fEventHeader;
67 if (fIsHexOutput)
68 Out() << Converter::GetHex<uint16_t>(fEventHeader, 16) << endl;
69 }
70
71 virtual void UpdateChannelHeader(int i)
72 {
73 // emit service with trigger counter from header
74 if (!fIsVerbose)
75 return;
76
77 Out() << endl << kBold << "Channel " << i << " received:" << endl;
78 Out() << fChannelHeader[i];
79 if (fIsHexOutput)
80 Out() << Converter::GetHex<uint16_t>(fChannelHeader, 16) << endl;
81 }
82
83 virtual void UpdateData(const uint16_t *data, size_t sz)
84 {
85 // emit service with trigger counter from header
86 if (fIsVerbose && fIsDataOutput)
87 Out() << Converter::GetHex<uint16_t>(data, sz, 16, true) << endl;
88 }
89
90private:
91 void HandleReceivedData(const bs::error_code& err, size_t bytes_received, int/* type*/)
92 {
93 // Do not schedule a new read if the connection failed.
94 if (bytes_received==0 || err)
95 {
96 if (err==ba::error::eof)
97 Warn("Connection closed by remote host (FTM).");
98
99 // 107: Transport endpoint is not connected (bs::error_code(107, bs::system_category))
100 // 125: Operation canceled
101 if (err && err!=ba::error::eof && // Connection closed by remote host
102 err!=ba::error::basic_errors::not_connected && // Connection closed by remote host
103 err!=ba::error::basic_errors::operation_aborted) // Connection closed by us
104 {
105 ostringstream str;
106 str << "Reading from " << URL() << ": " << err.message() << " (" << err << ")";// << endl;
107 Error(str);
108 }
109 PostClose(err!=ba::error::basic_errors::operation_aborted);
110 return;
111 }
112
113 if (bytes_received == sizeof(FAD::EventHeader))
114 {
115 fEventHeader = fBuffer;
116
117 if (fEventHeader.fStartDelimiter!=FAD::kDelimiterStart)
118 {
119 ostringstream str;
120 str << "Invalid header received: start delimiter wrong, received ";
121 str << hex << fEventHeader.fStartDelimiter << ", expected " << FAD::kDelimiterStart << ".";
122 Error(str);
123 PostClose(false);
124 return;
125 }
126
127 if (fCounter==0)
128 UpdateFirstHeader();
129
130 UpdateEventHeader();
131
132 fCounter++;
133
134 fBuffer.resize(fEventHeader.fPackageLength-sizeof(FAD::EventHeader)/2);
135 AsyncRead(ba::buffer(fBuffer));
136
137 return;
138 }
139
140 if (ntohs(fBuffer.back())!=FAD::kDelimiterEnd)
141 {
142 ostringstream str;
143 str << "Invalid data received: end delimiter wrong, received ";
144 str << hex << ntohs(fBuffer.back()) << ", expected " << FAD::kDelimiterEnd << ".";
145 Error(str);
146 PostClose(false);
147 return;
148 }
149
150 /*
151 uint8_t *ptr = reinterpret_cast<uint8_t*>(fBuffer.data());
152 for (unsigned int i=0; i<FAD::kNumChannels; i++)
153 {
154 if (ptr+sizeof(FAD::ChannelHeader)/2 > reinterpret_cast<uint8_t*>(fBuffer.data())+fBuffer.size()*2)
155 {
156 Error("WRONG SIZE1");
157 break;
158 }
159
160 // FIXME: Size consistency check!!!!
161 fChannelHeader[i] = vector<uint16_t>((uint16_t*)ptr, (uint16_t*)ptr+sizeof(FAD::ChannelHeader)/2);
162 ptr += sizeof(FAD::ChannelHeader);
163
164 // FIXME CHECK: Event Size vs ROI
165
166 UpdateChannelHeader(i);
167
168 if (ptr+fChannelHeader[i].fRegionOfInterest*2 > reinterpret_cast<uint8_t*>(fBuffer.data())+fBuffer.size()*2)
169 {
170 Error("WRONG SIZE2");
171 break;
172 }
173
174 uint16_t *data = reinterpret_cast<uint16_t*>(ptr);
175 for (uint16_t *d=data; d<data+fChannelHeader[i].fRegionOfInterest; d++)
176 {
177 const bool sign = *d & 0x2000;
178 const bool overflow = *d & 0x1000;
179
180 if (sign)
181 *d |= 0xf000; // no overflow, nagative
182 else
183 *d &= 0x07ff; // no overlow, positive
184
185 // max = [-2047;2048]
186
187 if (overflow)
188 {
189 if (sign)
190 *d = 0xF800; // overflow, negative
191 else
192 *d = 0x0800; // overflow, positive
193 }
194 }
195
196 UpdateData(data, fChannelHeader[i].fRegionOfInterest*2);
197 ptr += fChannelHeader[i].fRegionOfInterest*2;
198 }*/
199
200 fBuffer.resize(sizeof(FAD::EventHeader)/2);
201 AsyncRead(ba::buffer(fBuffer));
202 }
203
204 // This is called when a connection was established
205 void ConnectionEstablished()
206 {
207 fEventHeader.clear();
208 for (unsigned int i=0; i<FAD::kNumChannels; i++)
209 fChannelHeader[i].clear();
210
211 fCounter = 0;
212
213 fBuffer.resize(sizeof(FAD::EventHeader)/2);
214 AsyncRead(ba::buffer(fBuffer));
215
216// for (int i=0; i<36; i++)
217// CmdSetRoi(i, 100);
218
219 Cmd(ConnectionFAD::kCmdTriggerLine, true);
220 Cmd(ConnectionFAD::kCmdSingleTrigger);
221 }
222
223 void HandleReadTimeout(const bs::error_code &error)
224 {
225 /*
226 return;
227 Warn("Reading header timed-out... restarting.");
228 StartReadHeader();
229 return;
230 */
231 if (error && error!=ba::error::basic_errors::operation_aborted)
232 {
233 ostringstream str;
234 str << "Read timeout of " << URL() << ": " << error.message() << " (" << error << ")";// << endl;
235 Error(str);
236
237 PostClose();
238 return;
239
240 }
241
242 if (!is_open())
243 {
244 // For example: Here we could schedule a new accept if we
245 // would not want to allow two connections at the same time.
246 return;
247 }
248
249 // Check whether the deadline has passed. We compare the deadline
250 // against the current time since a new asynchronous operation
251 // may have moved the deadline before this actor had a chance
252 // to run.
253 if (fInTimeout.expires_at() > ba::deadline_timer::traits_type::now())
254 return;
255
256 Error("Timeout reading data from "+URL());
257
258 PostClose();
259 }
260
261 void PostCmd(std::vector<uint16_t> cmd)
262 {
263 ostringstream msg;
264 msg << "Sending command:" << hex;
265 msg << " 0x" << setw(4) << setfill('0') << cmd[0];
266 Message(msg);
267
268 transform(cmd.begin(), cmd.end(), cmd.begin(), htons);
269
270 PostMessage(cmd);
271 }
272
273 void PostCmd(uint16_t cmd)
274 {
275 ostringstream msg;
276 msg << "Sending command:" << hex;
277 msg << " 0x" << setw(4) << setfill('0') << cmd;
278 Message(msg);
279
280 cmd = htons(cmd);
281 PostMessage(&cmd, sizeof(uint16_t));
282 }
283
284 void PostCmd(uint16_t cmd, uint16_t data)
285 {
286 ostringstream msg;
287 msg << "Sending command:" << hex;
288 msg << " 0x" << setw(4) << setfill('0') << cmd;
289 msg << " 0x" << setw(4) << setfill('0') << data;
290 Message(msg);
291
292 const uint16_t d[2] = { htons(cmd), htons(data) };
293 PostMessage(d, sizeof(d));
294 }
295
296public:
297 enum Enable_t
298 {
299 kCmdDrsEnable = 0x0600, // CMD_DENABLE/CMD_DISABLE
300 kCmdDwrite = 0x0800, // CMD_DWRITE_RUN/CMD_DWRITE_STOP
301 kCmdSclk = 0x1000, // CMD_SCLK_ON/OFF
302 kCmdSrclk = 0x1500, // CMD_SRCLK_ON/OFF
303 kCmdTriggerLine = 0x1800, // CMD_TRIGGERS_ON/CMD_TRIGGERS_OFF
304 //kCmdContTrigger = 0x1f00,
305 kCmdContTriggerOff = 0x2000,
306 kCmdRun = 0x2200, // CMD_Start/Stop
307 kCmdResetTriggerId = 0x2A00, //
308 kCmdSocket = 0x3000, // CMD_mode_command/CMD_mode_all_sockets
309 kCmdSingleTrigger = 0xA000, // CMD_Trigger
310 kCmdContTriggerOn = 0xB000,
311 };
312
313private:
314 enum
315 {
316 kCmdWrite = 0x0500, // write to Config-RAM
317 kCmdWriteRoi = kCmdWrite|0x00, // Baseaddress ROI-Values
318 kCmdWriteDac = kCmdWrite|0x24, // Baseaddress DAC-Values
319
320 kCmdWriteRate = kCmdWrite|0x2c, // Continous trigger rate
321 kCmdWriteRunNumber = kCmdWrite|0x2d, //
322
323 /*
324 kCmdRead = 0x0a00, // read from Config-RAM
325 kCmdReadRoi = kCmdRead|0x00, // Baseaddress ROI-Values
326 kCmdReadDac = kCmdRead|0x24, // Baseaddress DAC-Values
327 */
328
329 kCmdPhaseIncrease = 0x1200, // CMD_PS_DIRINC
330 kCmdPhaseDecrease = 0x1300, // CMD_PS_DIRDEC
331 kCmdPhaseApply = 0x1400, // CMD_PS_DO
332 kCmdPhaseReset = 0x1700, // CMD_PS_RESET
333 };
334
335public:
336 ConnectionFAD(ba::io_service& ioservice, MessageImp &imp) :
337 Connection(ioservice, imp()),
338 fIsVerbose(true), fIsHexOutput(false), fIsDataOutput(false), fCounter(0)
339
340 {
341 SetLogStream(&imp);
342
343#ifdef FAKE
344 for (int i=0; i<7; i++)
345 fake[i] = new Connection(ioservice, imp());
346#endif
347 }
348#ifdef FAKE
349 Connection *fake[7];
350
351 ~ConnectionFAD()
352 {
353 // WORKAROUND
354 for (int i=0; i<7; i++)
355 delete fake[i];
356 }
357 void StartConnect()
358 {
359 // WORKAROUND
360 Connection::StartConnect();
361 for (int i=0; i<7; i++)
362 fake[i]->StartConnect();
363 }
364 void SetEndpoint(const string &addr)
365 {
366 // WORKAROUND
367 Connection::SetEndpoint(addr);
368 for (int i=0; i<7; i++)
369 {
370 const size_t p0 = addr.find_first_of(':');
371
372 ostringstream p;
373 p << addr.substr(0, p0+1) << atoi(addr.substr(p0+1).c_str())+i+1;
374 fake[i]->SetEndpoint(p.str());
375 }
376 // ==========================================WORKAROUND
377 }
378#endif
379
380 void Cmd(Enable_t cmd, bool on=true)
381 {
382 PostCmd(cmd + (on ? 0 : 0x100));
383 }
384
385 // ------------------------------
386
387 // IMPLEMENT: Abs/Rel
388 void CmdPhaseShift(int16_t val)
389 {
390 vector<uint16_t> cmd(abs(val)+2, kCmdPhaseApply);
391 cmd[0] = kCmdPhaseReset;
392 cmd[1] = val<0 ? kCmdPhaseDecrease : kCmdPhaseIncrease;
393 PostCmd(cmd);
394 }
395
396 bool CmdSetTriggerRate(int32_t val)
397 {
398 if (val<0 || val>0xffff)
399 return false;
400
401 PostCmd(kCmdWriteRate, val);//uint8_t(1000./val/12.5));
402 //PostCmd(kCmdContTriggerRate, uint8_t(80/val));
403
404 return true;
405 }
406
407 void CmdSetRegister(uint8_t addr, uint16_t val)
408 {
409 // Allowed addr: [0, MAX_ADDR]
410 // Allowed value: [0, MAX_VAL]
411 PostCmd(kCmdWrite + addr, val);
412 }
413
414 bool CmdSetDacValue(uint8_t addr, uint16_t val)
415 {
416 if (addr>FAD::kMaxDacAddr) // NDAC
417 return false;
418
419 PostCmd(kCmdWriteDac + addr, val);
420 return true;
421 }
422
423 bool CmdSetRoi(int8_t addr, uint16_t val)
424 {
425 if (addr>FAD::kMaxRoiAddr)
426 return false;
427
428 if (val>FAD::kMaxRoiValue)
429 return false;
430
431 if (addr<0)
432 for (int i=0; i<FAD::kMaxRoiAddr; i++)
433 PostCmd(kCmdWriteRoi + i, val);
434 else
435 PostCmd(kCmdWriteRoi + addr, val);
436
437 return true;
438 }
439
440 bool CmdSetRoi(uint16_t val) { return CmdSetRoi(-1, val); }
441
442 void AmplitudeCalibration()
443 {
444 // ------------- case baseline -----------------
445
446 CmdSetRoi(-1, FAD::kMaxBins);
447
448 CmdSetDacValue(1, 0);
449 CmdSetDacValue(2, 0);
450 CmdSetDacValue(3, 0);
451
452 // Take N events
453
454 /*
455 // ====== Part B: Baseline calibration =====
456
457 // Loop over all channels(ch) and time-slices (t)
458 T0 = TriggerCell[chip]
459 Sum[ch][(t+T0) % kMaxBins] += Data[ch][t];
460 // FIXME: Determine median instead of average
461
462 Baseline[ch][slice] = MEDIAN( sum[ch][slice] )
463 */
464
465 // --------------- case gain -------------------
466
467 // Set new DAC values and start accumulation
468 CmdSetDacValue(1, 50000);
469 CmdSetDacValue(2, 50000);
470 CmdSetDacValue(3, 50000);
471
472 // Take N events
473
474 /*
475 // ====== Part C: Gain calibration =====
476
477 T0 = TriggerCell[chip]
478 Sum[ch][(t+T0) % kMaxBins] += Data[ch][t];
479 // FIXME: Determine median instead of average
480
481 Gain[ch][slice] = MEDIAN( sum[ch][slice] ) - Baseline[ch][slice]
482 */
483
484 // --------------- secondary ------------------
485
486 // FIXME: Can most probably be done together with the baseline calibration
487 // FIXME: Why does the secondary baseline not influence the baseline?
488
489 CmdSetDacValue(1, 0);
490 CmdSetDacValue(2, 0);
491 CmdSetDacValue(3, 0);
492
493 // Take N events
494
495 /*
496 // ====== Part D: Secondary calibration =====
497
498 T0 = TriggerCell[chip]
499 Sum[ch][t] = Data[ch][t] - Baseline[ch][(i-T0) % kMaxBins];
500
501 // Determine secondary baseline if integration finished
502 SecondaryBaseline[ch][t] = MEDIAN( Sum[ch][t] )
503 */
504 }
505
506 void SetVerbose(bool b)
507 {
508 fIsVerbose = b;
509 }
510
511 void SetHexOutput(bool b)
512 {
513 fIsHexOutput = b;
514 }
515
516 void SetDataOutput(bool b)
517 {
518 fIsDataOutput = b;
519 }
520
521};
522
523// ------------------------------------------------------------------------
524/*
525#include "DimDescriptionService.h"
526
527class ConnectionDimFAD : public ConnectionFAD
528{
529private:
530
531 DimDescribedService fDimPassport;
532 DimDescribedService fDimTemperatures;
533 DimDescribedService fDimSetup;
534 DimDescribedService fDimEventHeader;
535
536 template<class T>
537 void Update(DimDescribedService &svc, const T &data) const
538 {
539 //cout << "Update: " << svc.getName() << " (" << sizeof(T) << ")" << endl;
540 svc.setData(const_cast<T*>(&data), sizeof(T));
541 svc.updateService();
542 }
543
544 void UpdateFirstHeader()
545 {
546 ConnectionFAD::UpdateFirstHeader();
547
548 const FAD::DimPassport data(fEventHeader);
549 Update(fDimPassport, data);
550 }
551
552 void UpdateEventHeader()
553 {
554 ConnectionFAD::UpdateEventHeader();
555
556 const FAD::DimTemperatures data0(fEventHeader);
557 const FAD::DimSetup data1(fEventHeader);
558 const FAD::DimEventHeader data2(fEventHeader);
559
560 Update(fDimTemperatures, data0);
561 Update(fDimSetup, data1);
562 Update(fDimEventHeader, data2);
563 }
564
565public:
566 ConnectionDimFAD(ba::io_service& ioservice, MessageImp &imp) :
567 ConnectionFAD(ioservice, imp),
568 fDimPassport ("FAD_CONTROL/PASSPORT", "I:1;S:2;X:1", ""),
569 fDimTemperatures("FAD_CONTROL/TEMPERATURES", "I:1;F:4", ""),
570 fDimSetup ("FAD_CONTROL/SETUP", "I:2;S:12", ""),
571 fDimEventHeader ("FAD_CONTROL/EVENT_HEADER", "C", "")
572 {
573 }
574
575 // 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
576};
577*/
578// ------------------------------------------------------------------------
579extern "C"
580{
581 extern void *readFAD(void*);
582 extern void *procEvt(void*);
583 extern void *writeEvt(void*);
584 extern void initReadFAD();
585};
586
587#include "EventBuilder.h"
588
589class EventBuilderWrapper
590{
591public:
592 // FIXME
593 static EventBuilderWrapper *This;
594
595private:
596 boost::thread fThread;
597
598 enum CommandStates_t // g_runStat
599 {
600 kAbort = -2, // quit as soon as possible ('abort')
601 kExit = -1, // stop reading, quit when buffered events done ('exit')
602 kInitialize = 0, // 'initialize' (e.g. dim not yet started)
603 kHybernate = 1, // do nothing for long time ('hybernate') [wakeup within ~1sec]
604 kSleep = 2, // do nothing ('sleep') [wakeup within ~10msec]
605 kModeFlush = 10, // read data from camera, but skip them ('flush')
606 kModeTest = 20, // read data and process them, but do not write to disk ('test')
607 kModeFlag = 30, // read data, process and write all to disk ('flag')
608 kModeRun = 40, // read data, process and write selected to disk ('run')
609 };
610
611 MessageImp &fMsg;
612
613public:
614 EventBuilderWrapper(MessageImp &msg) : fMsg(msg)
615 {
616 if (This)
617 throw runtime_error("EventBuilderWrapper cannot be instantiated twice.");
618
619 This = this;
620 Start();
621 }
622
623 void Update(ostringstream &out, int severity)
624 {
625 fMsg.Update(out, severity);
626 }
627
628 void Start()
629 {
630 if (fThread.joinable())
631 {
632 fMsg.Warn("Start - EventBuilder still running");
633 return;
634 }
635
636 fMsg.Message("Initializing EventBuilder");
637 initReadFAD();
638
639 g_runStat = kHybernate;
640 fThread = boost::thread(readFAD, (void*)NULL);
641
642 fMsg.Message("EventBuilder started");
643 }
644 void Abort()
645 {
646 fMsg.Message("Waiting for EventBuilder to abort...");
647 g_runStat = kAbort;
648 fThread.join();
649 fMsg.Message("EventBuilder stopped.");
650 }
651
652 void Exit()
653 {
654 fMsg.Message("Waiting for EventBuilder to exit - be patient...");
655 g_runStat = kExit;
656 }
657
658 void Wait()
659 {
660 fThread.join();
661 fMsg.Message("EventBuilder stopped.");
662 }
663
664 void Hybernate() { g_runStat = kHybernate; }
665 void Sleep() { g_runStat = kSleep; }
666 void FlushMode() { g_runStat = kModeFlush; }
667 void TestMode() { g_runStat = kModeTest; }
668 void FlagMode() { g_runStat = kModeFlag; }
669 void RunMode() { g_runStat = kModeRun; }
670
671 // FIXME: To be removed
672 void SetMode(int mode) { g_runStat = mode; }
673
674 bool IsConnected(int i) const { return gi_NumConnect[i]==7; }
675 bool IsDisconnected(int i) const { return gi_NumConnect[i]==0; }
676 int GetNumConnected(int i) const { return gi_NumConnect[i]; }
677
678 void Restart()
679 {
680 Abort();
681 Start();
682 }
683
684 ~EventBuilderWrapper()
685 {
686 Abort();
687 }
688};
689/*
690extern "C" {
691
692void Error(int severity, int errnum, const char *fmt, ...)
693{
694 va_list ap;
695 va_start(ap, fmt);
696
697 int n=256;
698
699 char *ret=0;
700 while (1)
701 {
702 ret = new char[n+1];
703
704 const int sz = vsnprintf(ret, n, fmt, ap);
705 if (sz<=n)
706 break;
707
708 n *= 2;
709 delete [] ret;
710 };
711
712 va_end(ap);
713
714 ostringstream str;
715 str << ret << " (" << errnum << ":" << strerror(errnum) << ")";
716
717 delete [] ret;
718
719 EventBuilderWrapper::This->Update(str, severity);
720}
721
722}
723*/
724
725EventBuilderWrapper *EventBuilderWrapper::This = 0;
726
727// ------------------------------------------------------------------------
728
729template <class T>
730class StateMachineFAD : public T, public EventBuilderWrapper, public ba::io_service, public ba::io_service::work
731{
732private:
733 typedef pair<string, ConnectionFAD*> Connection;
734 typedef pair<const uint8_t, Connection> Board;
735 typedef map<uint8_t, Connection> BoardList;
736
737 BoardList fBoards;
738
739 bool fIsVerbose;
740 bool fIsHexOutput;
741 bool fIsDataOutput;
742
743 bool CheckEventSize(size_t has, const char *name, size_t size)
744 {
745 if (has==size)
746 return true;
747
748 ostringstream msg;
749 msg << name << " - Received event has " << has << " bytes, but expected " << size << ".";
750 T::Fatal(msg);
751 return false;
752 }
753
754 int Cmd(ConnectionFAD::Enable_t command)
755 {
756 for (BoardList::iterator i=fBoards.begin(); i!=fBoards.end(); i++)
757 i->second.second->Cmd(command);
758
759 return T::GetCurrentState();
760 }
761
762 int CmdEnable(const EventImp &evt, ConnectionFAD::Enable_t command)
763 {
764 if (!CheckEventSize(evt.GetSize(), "CmdEnable", 1))
765 return T::kSM_FatalError;
766
767 for (BoardList::iterator i=fBoards.begin(); i!=fBoards.end(); i++)
768 i->second.second->Cmd(command, evt.GetBool());
769
770 return T::GetCurrentState();
771 }
772
773 bool Check(const uint32_t *dat, uint32_t maxaddr, uint32_t maxval)
774 {
775 if (dat[0]>FAD::kMaxRegAddr)
776 {
777 ostringstream msg;
778 msg << hex << "Address " << dat[0] << " out of range, max=" << maxaddr << ".";
779 T::Error(msg);
780 return false;
781 }
782
783 if (dat[1]>FAD::kMaxRegValue)
784 {
785 ostringstream msg;
786 msg << hex << "Value " << dat[1] << " out of range, max=" << maxval << ".";
787 T::Error(msg);
788 return false;
789 }
790
791 return true;
792 }
793
794 int SetRegister(const EventImp &evt)
795 {
796 if (!CheckEventSize(evt.GetSize(), "SetRegister", 8))
797 return T::kSM_FatalError;
798
799 const uint32_t *dat = reinterpret_cast<const uint32_t*>(evt.GetData());
800
801 if (!Check(dat, FAD::kMaxRegAddr, FAD::kMaxRegValue))
802 return T::GetCurrentState();
803
804 for (BoardList::iterator i=fBoards.begin(); i!=fBoards.end(); i++)
805 i->second.second->CmdSetRegister(dat[0], dat[1]);
806
807 return T::GetCurrentState();
808 }
809
810 int SetRoi(const EventImp &evt)
811 {
812 if (!CheckEventSize(evt.GetSize(), "SetRoi", 8))
813 return T::kSM_FatalError;
814
815 // ---- was uint32_t
816 const int32_t *dat = reinterpret_cast<const int32_t*>(evt.GetData());
817
818 // ---- -1 for all
819 //if (!Check(dat, FAD::kMaxRoiAddr, FAD::kMaxRoiValue))
820 // return T::GetCurrentState();
821
822 for (BoardList::iterator i=fBoards.begin(); i!=fBoards.end(); i++)
823 i->second.second->CmdSetRoi(dat[0], dat[1]);
824
825 return T::GetCurrentState();
826 }
827
828 int SetDac(const EventImp &evt)
829 {
830 if (!CheckEventSize(evt.GetSize(), "SetDac", 8))
831 return T::kSM_FatalError;
832
833 const uint32_t *dat = reinterpret_cast<const uint32_t*>(evt.GetData());
834
835 if (!Check(dat, FAD::kMaxDacAddr, FAD::kMaxDacValue))
836 return T::GetCurrentState();
837
838 for (BoardList::iterator i=fBoards.begin(); i!=fBoards.end(); i++)
839 i->second.second->CmdSetDacValue(dat[0], dat[1]);
840
841 return T::GetCurrentState();
842 }
843
844 int Trigger(int n)
845 {
846 for (int nn=0; nn<n; nn++)
847 for (BoardList::iterator i=fBoards.begin(); i!=fBoards.end(); i++)
848 i->second.second->Cmd(ConnectionFAD::kCmdSingleTrigger);
849
850 return T::GetCurrentState();
851 }
852
853 int SendTriggers(const EventImp &evt)
854 {
855 if (!CheckEventSize(evt.GetSize(), "SendTriggers", 4))
856 return T::kSM_FatalError;
857
858 Trigger(evt.GetUInt());
859
860 return T::GetCurrentState();
861 }
862
863 int StartRun(const EventImp &evt, bool start)
864 {
865 if (!CheckEventSize(evt.GetSize(), "StartRun", 0))
866 return T::kSM_FatalError;
867
868 for (BoardList::iterator i=fBoards.begin(); i!=fBoards.end(); i++)
869 i->second.second->Cmd(ConnectionFAD::kCmdRun, start);
870
871 return T::GetCurrentState();
872 }
873
874 int PhaseShift(const EventImp &evt)
875 {
876 if (!CheckEventSize(evt.GetSize(), "PhaseShift", 2))
877 return T::kSM_FatalError;
878
879 for (BoardList::iterator i=fBoards.begin(); i!=fBoards.end(); i++)
880 i->second.second->CmdPhaseShift(evt.GetShort());
881
882 return T::GetCurrentState();
883 }
884
885 int SetTriggerRate(const EventImp &evt)
886 {
887 if (!CheckEventSize(evt.GetSize(), "SetTriggerRate", 4))
888 return T::kSM_FatalError;
889
890 if (evt.GetUShort()>0xff)
891 {
892 ostringstream msg;
893 msg << hex << "Value " << evt.GetUShort() << " out of range, max=" << 0xff << "(?)";
894 T::Error(msg);
895 return false;
896 }
897
898 for (BoardList::iterator i=fBoards.begin(); i!=fBoards.end(); i++)
899 i->second.second->CmdSetTriggerRate(evt.GetUInt());
900
901 return T::GetCurrentState();
902 }
903
904 int Test(const EventImp &evt)
905 {
906 if (!CheckEventSize(evt.GetSize(), "Test", 2))
907 return T::kSM_FatalError;
908
909
910 SetMode(evt.GetShort());
911
912 return T::GetCurrentState();
913 }
914
915
916 int SetVerbosity(const EventImp &evt)
917 {
918 if (!CheckEventSize(evt.GetSize(), "SetVerbosity", 1))
919 return T::kSM_FatalError;
920
921 for (BoardList::iterator i=fBoards.begin(); i!=fBoards.end(); i++)
922 i->second.second->SetVerbose(evt.GetText()[0]!=0);
923
924 return T::GetCurrentState();
925 }
926
927 int SetHexOutput(const EventImp &evt)
928 {
929 if (!CheckEventSize(evt.GetSize(), "SetHexOutput", 1))
930 return T::kSM_FatalError;
931
932 for (BoardList::iterator i=fBoards.begin(); i!=fBoards.end(); i++)
933 i->second.second->SetHexOutput(evt.GetText()[0]!=0);
934
935 return T::GetCurrentState();
936 }
937
938 int SetDataOutput(const EventImp &evt)
939 {
940 if (!CheckEventSize(evt.GetSize(), "SetDataOutput", 1))
941 return T::kSM_FatalError;
942
943 for (BoardList::iterator i=fBoards.begin(); i!=fBoards.end(); i++)
944 i->second.second->SetDataOutput(evt.GetText()[0]!=0);
945
946 return T::GetCurrentState();
947 }
948
949 const BoardList::iterator GetSlot(int slot)
950 {
951 const BoardList::iterator i = fBoards.find(slot);
952 if (i!=fBoards.end())
953 return i;
954
955 ostringstream str;
956 str << "Slot " << slot << " not found.";
957 T::Warn(str.str());
958 return fBoards.end();
959 }
960
961 int AddAddress(const EventImp &evt)
962 {
963 const string addr = Tools::Trim(evt.GetText());
964
965 for (BoardList::const_iterator i=fBoards.begin(); i!=fBoards.end(); i++)
966 {
967 if (i->second.first==addr)
968 {
969 T::Warn("Address "+addr+" already known.... ignored.");
970 return T::GetCurrentState();
971 }
972 }
973
974 AddEndpoint(addr);
975
976 return T::GetCurrentState();
977 }
978
979 int RemoveSlot(const EventImp &evt)
980 {
981 if (!CheckEventSize(evt.GetSize(), "RemoveSlot", 2))
982 return T::kSM_FatalError;
983
984 const int16_t slot = evt.GetShort();
985
986 const BoardList::iterator v = GetSlot(slot);
987 if (v!=fBoards.end())
988 {
989 delete v->second.second;
990 fBoards.erase(v);
991 }
992
993 return T::GetCurrentState();
994 }
995
996 int ListSlots()
997 {
998 for (BoardList::const_iterator i=fBoards.begin(); i!=fBoards.end(); i++)
999 {
1000 ostringstream str;
1001 str << "Slot " << setw(2) << (int)i->first << ": " << i->second.first;
1002
1003 const ConnectionFAD *c = i->second.second;
1004
1005 if (c->IsConnecting())
1006 str << " (0:connecting, ";
1007 else
1008 {
1009 if (c->IsClosed())
1010 str << " (0:disconnected, ";
1011 if (c->IsConnected())
1012 str << " (0:connected, ";
1013 }
1014
1015 switch (fStatus2[i->first])
1016 {
1017 case 0: str << "1-7:disconnected)"; break;
1018 case 1: str << "1-7:connecting [" << GetNumConnected(i->first) << "])"; break;
1019 case 2: str << "1-7:connected)"; break;
1020 }
1021
1022 T::Message(str.str());
1023 }
1024
1025 return T::GetCurrentState();
1026 }
1027
1028 void EnableSlot(BoardList::iterator i, bool enable=true)
1029 {
1030 if (i==fBoards.end())
1031 return;
1032
1033 ConnectionFAD* &ptr = i->second.second;
1034
1035 if (!enable)
1036 ptr->PostClose(false);
1037 else
1038 {
1039 ptr->SetEndpoint(i->second.first);
1040 ptr->StartConnect();
1041 }
1042 }
1043
1044 void EnableAll(bool enable=true)
1045 {
1046 for (BoardList::iterator i=fBoards.begin(); i!=fBoards.end(); i++)
1047 EnableSlot(i, enable);
1048 }
1049
1050 /*
1051 int Enable(const EventImp &evt)
1052 {
1053 if (!CheckEventSize(evt.GetSize(), "Enable", 3))
1054 return T::kSM_FatalError;
1055
1056 const int16_t slot = evt.GetShort();
1057 const bool enable = evt.GetText()[2]>0;
1058
1059 if (slot<0)
1060 {
1061 EnableAll(enable);
1062 return T::GetCurrentState();
1063 }
1064
1065 EnableSlot(GetSlot(slot), enable);
1066
1067 return T::GetCurrentState();
1068 }*/
1069
1070 int Disconnect()
1071 {
1072 Exit();
1073 EnableAll(false);
1074 return T::GetCurrentState();
1075 }
1076
1077 int Connect()
1078 {
1079 T::Error("FIXME - Propagate IP Addresses to EventBuilder");
1080
1081 Start();
1082 EnableAll(true);
1083
1084 return T::GetCurrentState();
1085 }
1086
1087 /*
1088 int Reconnect(const EventImp &evt)
1089 {
1090 if (!CheckEventSize(evt.GetSize(), "Reconnect", 2))
1091 return T::kSM_FatalError;
1092
1093 const int16_t slot = evt.GetShort();
1094
1095 if (slot<0)
1096 {
1097 // Close all connections to supress the warning in SetEndpoint
1098 for (BoardList::const_iterator i=fBoards.begin(); i!=fBoards.end(); i++)
1099 i->second.second->PostClose(false);
1100
1101 // Now wait until all connection have been closed and
1102 // all pending handlers have been processed
1103 poll();
1104
1105 // Now we can reopen the connection
1106 for (BoardList::const_iterator i=fBoards.begin(); i!=fBoards.end(); i++)
1107 i->second.second->PostClose(true);
1108
1109 return T::GetCurrentState();
1110 }
1111
1112 const BoardList::const_iterator v = GetSlot(slot);
1113 if (v==fBoards.end())
1114 return T::GetCurrentState();
1115
1116 // Close all connections to supress the warning in SetEndpoint
1117 v->second.second->PostClose(false);
1118
1119 // Now wait until all connection have been closed and
1120 // all pending handlers have been processed
1121 poll();
1122
1123 // Now we can reopen the connection
1124 v->second.second->PostClose(true);
1125
1126 return T::GetCurrentState();
1127 }*/
1128
1129 virtual void UpdateConnectionStatus()
1130 {
1131 //cout << "Connection Status changed prop to Dim." << endl;
1132 }
1133
1134 vector<char> fStatus1;
1135 vector<char> fStatus2;
1136
1137 int Execute()
1138 {
1139 // Dispatch (execute) at most one handler from the queue. In contrary
1140 // to run_one(), it doesn't wait until a handler is available
1141 // which can be dispatched, so poll_one() might return with 0
1142 // handlers dispatched. The handlers are always dispatched/executed
1143 // synchronously, i.e. within the call to poll_one()
1144 poll_one();
1145
1146 // ===== Evaluate connection status =====
1147
1148 uint16_t nconnecting1 = 0;
1149 uint16_t nconnecting2 = 0;
1150 uint16_t nconnected1 = 0;
1151 uint16_t nconnected2 = 0;
1152
1153 vector<char> stat1(40);
1154 vector<char> stat2(40);
1155 for (BoardList::const_iterator i=fBoards.begin(); i!=fBoards.end(); i++)
1156 {
1157 const ConnectionFAD &c = *i->second.second;
1158
1159 const int &idx = i->first;
1160
1161 // FIXME: There is a difference between
1162 // "connecting" and "disconnected"
1163
1164 // Check conistency eb/fadctrl
1165
1166 // ----- Command socket -----
1167 if (c.IsConnecting())
1168 {
1169 stat1[idx] = 1;
1170 nconnecting1++;
1171 }
1172 if (c.IsConnected())
1173 {
1174 stat1[idx] = 2;
1175 nconnected1++;
1176 }
1177
1178 // ----- Event builder -----
1179 if (!IsConnected(idx) && !IsDisconnected(idx))
1180 {
1181 stat2[idx] = 1;
1182 nconnecting2++;
1183 }
1184
1185 if (IsConnected(idx))
1186 {
1187 stat2[idx] = 2;
1188 nconnected2++;
1189 }
1190 }
1191
1192 // ===== Send connection status via dim =====
1193
1194 if (fStatus1!=stat1 || fStatus2!=stat2)
1195 {
1196 fStatus1 = stat1;
1197 fStatus2 = stat2;
1198 UpdateConnectionStatus();
1199 }
1200
1201 // ===== Return connection status =====
1202
1203 if (nconnected1==fBoards.size() && nconnected2==fBoards.size())
1204 return FAD::kConnected;
1205
1206 if (nconnected1==0 && nconnected2==0)
1207 return FAD::kDisconnected;
1208
1209 // FIXME: Evaluate event builder status
1210 return FAD::kConnecting;
1211 }
1212
1213 void AddEndpoint(const string &addr)
1214 {
1215 if (fBoards.size()==40)
1216 {
1217 T::Warn("Not more than 40 slots allowed.");
1218 return;
1219 }
1220
1221 int i=0;
1222 while (1)
1223 {
1224 const BoardList::const_iterator v = fBoards.find(i);
1225 if (v==fBoards.end())
1226 break;
1227 i++;
1228 }
1229
1230 fBoards[i] = make_pair(addr, new ConnectionFAD(*this, *this));
1231 fBoards[i].second->SetVerbose(fIsVerbose);
1232 fBoards[i].second->SetHexOutput(fIsHexOutput);
1233 fBoards[i].second->SetDataOutput(fIsDataOutput);
1234 }
1235
1236
1237
1238public:
1239 StateMachineFAD(ostream &out=cout) :
1240 T(out, "FAD_CONTROL"), EventBuilderWrapper(static_cast<MessageImp&>(*this)), ba::io_service::work(static_cast<ba::io_service&>(*this)),
1241 fStatus1(40), fStatus2(40)
1242 {
1243 // ba::io_service::work is a kind of keep_alive for the loop.
1244 // It prevents the io_service to go to stopped state, which
1245 // would prevent any consecutive calls to run()
1246 // or poll() to do nothing. reset() could also revoke to the
1247 // previous state but this might introduce some overhead of
1248 // deletion and creation of threads and more.
1249
1250 // State names
1251 T::AddStateName(FAD::kDisconnected, "Disconnected",
1252 "All enabled FAD boards are disconnected.");
1253
1254 T::AddStateName(FAD::kConnected, "Connected",
1255 "All enabled FAD boards are connected..");
1256
1257 T::AddStateName(FAD::kConnecting, "Connecting",
1258 "Only some enabled FAD boards are connected.");
1259
1260 // FAD Commands
1261 T::AddEvent("ENABLE_SRCLK", "B:1")
1262 (boost::bind(&StateMachineFAD::CmdEnable, this, _1, ConnectionFAD::kCmdSrclk))
1263 ("Set SRCLK");
1264 T::AddEvent("ENABLE_SCLK", "B:1")
1265 (boost::bind(&StateMachineFAD::CmdEnable, this, _1, ConnectionFAD::kCmdSclk))
1266 ("Set SCLK");
1267 T::AddEvent("ENABLE_DRS", "B:1")
1268 (boost::bind(&StateMachineFAD::CmdEnable, this, _1, ConnectionFAD::kCmdDrsEnable))
1269 ("Switch Domino wave");
1270 T::AddEvent("ENABLE_DWRITE", "B:1")
1271 (boost::bind(&StateMachineFAD::CmdEnable, this, _1, ConnectionFAD::kCmdDwrite))
1272 ("Set Dwrite (possibly high / always low)");
1273 T::AddEvent("SET_DEBUG_MODE", "B:1")
1274 (boost::bind(&StateMachineFAD::CmdEnable, this, _1, ConnectionFAD::kCmdSocket))
1275 ("Set debug mode (yes: dump events through command socket, no=dump events through other sockets)");
1276 T::AddEvent("ENABLE_TRIGGER_LINE", "B:1")
1277 (boost::bind(&StateMachineFAD::CmdEnable, this, _1, ConnectionFAD::kCmdTriggerLine))
1278 ("Incoming triggers can be accepted/will not be accepted");
1279 T::AddEvent("SET_TRIGGER_RATE", "I:1")
1280 (boost::bind(&StateMachineFAD::SetTriggerRate, this, _1))
1281 ("Enable continous trigger");
1282 T::AddEvent("SEND_SINGLE_TRIGGER")
1283 (boost::bind(&StateMachineFAD::Trigger, this, 1))
1284 ("Issue software triggers");
1285 T::AddEvent("SEND_N_TRIGGERS", "I")
1286 (boost::bind(&StateMachineFAD::SendTriggers, this, _1))
1287 ("Issue software triggers");
1288 T::AddEvent("START", "")
1289 (boost::bind(&StateMachineFAD::StartRun, this, _1, true))
1290 ("Set FAD DAQ mode. when started, no configurations must be send.");
1291 T::AddEvent("STOP")
1292 (boost::bind(&StateMachineFAD::StartRun, this, _1, false))
1293 ("");
1294 T::AddEvent("PHASE_SHIFT", "S:1")
1295 (boost::bind(&StateMachineFAD::PhaseShift, this, _1))
1296 ("Adjust ADC phase (in 'steps')");
1297
1298 T::AddEvent("CONTINOUS_TRIGGER_ON")
1299 (boost::bind(&StateMachineFAD::Cmd, this, ConnectionFAD::kCmdContTriggerOn))
1300 ("");
1301 T::AddEvent("CONTINOUS_TRIGGER_OFF")
1302 (boost::bind(&StateMachineFAD::Cmd, this, ConnectionFAD::kCmdContTriggerOff))
1303 ("");
1304
1305 T::AddEvent("RESET_TRIGGER_ID")
1306 (boost::bind(&StateMachineFAD::Cmd, this, ConnectionFAD::kCmdResetTriggerId))
1307 ("");
1308
1309 T::AddEvent("SET_REGISTER", "I:2")
1310 (boost::bind(&StateMachineFAD::SetRegister, this, _1))
1311 ("set register to value"
1312 "|addr[short]:Address of register"
1313 "|val[short]:Value to be set");
1314
1315 // FIXME: Maybe add a mask which channels should be set?
1316 T::AddEvent("SET_REGION_OF_INTEREST", "I:2")
1317 (boost::bind(&StateMachineFAD::SetRoi, this, _1))
1318 ("Set region-of-interest to value"
1319 "|addr[short]:Address of register"
1320 "|val[short]:Value to be set");
1321
1322 // FIXME: Maybe add a mask which channels should be set?
1323 T::AddEvent("SET_DAC_VALUE", "I:2")
1324 (boost::bind(&StateMachineFAD::SetDac, this, _1))
1325 ("Set DAC numbers in range to value"
1326 "|addr[short]:Address of register"
1327 "|val[short]:Value to be set");
1328
1329 // Verbosity commands
1330 T::AddEvent("SET_VERBOSE", "B")
1331 (boost::bind(&StateMachineFAD::SetVerbosity, this, _1))
1332 ("set verbosity state"
1333 "|verbosity[bool]:disable or enable verbosity for received data (yes/no), except dynamic data");
1334
1335 T::AddEvent("SET_HEX_OUTPUT", "B")
1336 (boost::bind(&StateMachineFAD::SetHexOutput, this, _1))
1337 ("enable or disable hex output for received data"
1338 "|hexout[bool]:disable or enable hex output for received data (yes/no)");
1339
1340 T::AddEvent("SET_DATA_OUTPUT", "B")
1341 (boost::bind(&StateMachineFAD::SetDataOutput, this, _1))
1342 ("");
1343
1344 // Conenction commands
1345 /*
1346 T::AddEvent("ENABLE", "S:1;B:1", FAD::kDisconnected)
1347 (boost::bind(&StateMachineFAD::Enable, this, _1))
1348 ("");*/
1349
1350 T::AddEvent("CONNECT", FAD::kDisconnected)
1351 (boost::bind(&StateMachineFAD::Connect, this))
1352 ("");
1353
1354 T::AddEvent("DISCONNECT")
1355 (boost::bind(&StateMachineFAD::Disconnect, this))
1356 ("");
1357
1358 T::AddEvent("TEST", "S:1")
1359 (boost::bind(&StateMachineFAD::Test, this, _1))
1360 ("");
1361
1362 T::AddEvent("ADD_ADDRESS", "C", FAD::kDisconnected)
1363 (boost::bind(&StateMachineFAD::AddAddress, this, _1))
1364 ("Add the address of a DRS4 board to the first free slot"
1365 "|IP[string]:address in the format <address:port>");
1366 T::AddEvent("REMOVE_SLOT", "S:1", FAD::kDisconnected)
1367 (boost::bind(&StateMachineFAD::RemoveSlot, this, _1))
1368 ("Remove the Iaddress in slot n. For a list see LIST"
1369 "|slot[int]:Remove the address in slot n from the list");
1370 T::AddEvent("LIST_SLOTS")
1371 (boost::bind(&StateMachineFAD::ListSlots, this))
1372 ("Print a list of all available board addressesa and whether they are enabled");
1373 }
1374
1375 ~StateMachineFAD()
1376 {
1377 for (BoardList::const_iterator i=fBoards.begin(); i!=fBoards.end(); i++)
1378 delete i->second.second;
1379 fBoards.clear();
1380 }
1381
1382 bool SetConfiguration(const Configuration &conf)
1383 {
1384 fIsVerbose = !conf.Get<bool>("quiet");
1385 fIsHexOutput = conf.Get<bool>("hex-out");
1386 fIsDataOutput = conf.Get<bool>("data-out");
1387
1388 if (!(conf.Has("base-addr") ^ conf.Has("addr")))
1389 {
1390 T::Out() << kRed << "SetConfiguration - Only --base-addr or --addr allowed." << endl;
1391 return false;
1392 }
1393
1394 if (conf.Has("base-addr"))
1395 {
1396 const string base = conf.Get<string>("base-addr");
1397
1398 const size_t p0 = base.find_first_of(':');
1399 const size_t p1 = base.find_last_of(':');
1400
1401 if (p0==string::npos || p0!=p1)
1402 {
1403 T::Out() << kRed << "SetConfiguration - Wrong format of argument --base-addr ('host:port' expected)" << endl;
1404 return false;
1405 }
1406
1407 tcp::resolver resolver(get_io_service());
1408
1409 boost::system::error_code ec;
1410
1411 const tcp::resolver::query query(base.substr(0, p0), base.substr(p0+1));
1412 const tcp::resolver::iterator iterator = resolver.resolve(query, ec);
1413
1414 if (ec)
1415 {
1416 T::Out() << " " << ec.message() << " (" << ec << ")";
1417 return false;
1418 }
1419
1420 const tcp::endpoint endpoint = *iterator;
1421
1422 const ba::ip::address_v4::bytes_type ip = endpoint.address().to_v4().to_bytes();
1423
1424 if (ip[2]>250 || ip[3]>244)
1425 {
1426 T::Out() << kRed << "SetConfiguration - IP address given by --base-addr out-of-range." << endl;
1427 return false;
1428 }
1429
1430 for (int crate=0; crate<2; crate++)
1431 for (int board=0; board<10; board++)
1432 {
1433 //if (crate==0 && board==2)
1434 // continue;
1435
1436 ostringstream str;
1437 str << (int)ip[0] << "." << (int)ip[1] << ".";
1438 str << (int)(ip[2]+crate) << "." << (int)(ip[3]+board) << ":";
1439 str << endpoint.port();
1440
1441 AddEndpoint(str.str());
1442 }
1443 }
1444
1445 if (conf.Has("addr"))
1446 {
1447 const vector<string> addrs = conf.Get<vector<string>>("addr");
1448 for (vector<string>::const_iterator i=addrs.begin(); i<addrs.end(); i++)
1449 AddEndpoint(*i);
1450 }
1451
1452 EnableAll();
1453
1454 return true;
1455 }
1456
1457};
1458
1459// ------------------------------------------------------------------------
1460
1461
1462void RunThread(StateMachineImp *io_service)
1463{
1464 // This is necessary so that the StateMachien Thread can signal the
1465 // Readline to exit
1466 io_service->Run();
1467 Readline::Stop();
1468}
1469
1470template<class S>
1471int RunDim(Configuration &conf)
1472{
1473 /*
1474 initscr(); // Start curses mode
1475 cbreak(); // Line buffering disabled, Pass on
1476 intrflush(stdscr, FALSE);
1477 start_color(); // Initialize ncurses colors
1478 use_default_colors(); // Assign terminal default colors to -1
1479 for (int i=1; i<8; i++)
1480 init_pair(i, i, -1); // -1: def background
1481 scrollok(stdscr, true);
1482 */
1483
1484 WindowLog wout;
1485
1486 //log.SetWindow(stdscr);
1487 if (conf.Has("log"))
1488 if (!wout.OpenLogFile(conf.Get<string>("log")))
1489 wout << kRed << "ERROR - Couldn't open log-file " << conf.Get<string>("log") << ": " << strerror(errno) << endl;
1490
1491 // Start io_service.Run to use the StateMachineImp::Run() loop
1492 // Start io_service.run to only use the commandHandler command detaching
1493 StateMachineFAD<S> io_service(wout);
1494 if (!io_service.SetConfiguration(conf))
1495 return -1;
1496
1497 io_service.Run();
1498
1499 return 0;
1500}
1501
1502template<class T, class S>
1503int RunShell(Configuration &conf)
1504{
1505 static T shell(conf.GetName().c_str(), conf.Get<int>("console")!=1);
1506
1507 WindowLog &win = shell.GetStreamIn();
1508 WindowLog &wout = shell.GetStreamOut();
1509
1510 if (conf.Has("log"))
1511 if (!wout.OpenLogFile(conf.Get<string>("log")))
1512 win << kRed << "ERROR - Couldn't open log-file " << conf.Get<string>("log") << ": " << strerror(errno) << endl;
1513
1514 StateMachineFAD<S> io_service(wout);
1515 if (!io_service.SetConfiguration(conf))
1516 return -1;
1517
1518 shell.SetReceiver(io_service);
1519
1520 boost::thread t(boost::bind(RunThread, &io_service));
1521 //boost::thread t(boost::bind(&StateMachineFAD<S>::Run, &io_service));
1522
1523 shell.Run(); // Run the shell
1524 io_service.Stop(); // Signal Loop-thread to stop
1525
1526 // Wait until the StateMachine has finished its thread
1527 // before returning and destroying the dim objects which might
1528 // still be in use.
1529 t.join();
1530
1531 return 0;
1532}
1533
1534void SetupConfiguration(Configuration &conf)
1535{
1536 const string n = conf.GetName()+".log";
1537
1538 po::options_description config("Program options");
1539 config.add_options()
1540 ("dns", var<string>("localhost"), "Dim nameserver host name (Overwites DIM_DNS_NODE environment variable)")
1541 ("log,l", var<string>(n), "Write log-file")
1542 ("no-dim,d", po_switch(), "Disable dim services")
1543 ("console,c", var<int>(), "Use console (0=shell, 1=simple buffered, X=simple unbuffered)")
1544 ;
1545
1546 po::options_description control("FTM control options");
1547 control.add_options()
1548// ("addr,a", var<string>("localhost:5000"), "Network address of FTM")
1549 ("quiet,q", po_bool(), "Disable printing contents of all received messages in clear text.")
1550 ("hex-out", po_bool(), "Enable printing contents of all printed messages also as hex data.")
1551 ("data-out", po_bool(), "Enable printing received event data.")
1552 ("addr", vars<string>(), "Network address of FAD")
1553 ("base-addr", var<string>(), "Base address of all FAD")
1554 ;
1555
1556 conf.AddEnv("dns", "DIM_DNS_NODE");
1557
1558 conf.AddOptions(config);
1559 conf.AddOptions(control);
1560}
1561
1562void PrintUsage()
1563{
1564 cout <<
1565 "The fadctrl controls the FAD boards.\n"
1566 "\n"
1567 "The default is that the program is started without user intercation. "
1568 "All actions are supposed to arrive as DimCommands. Using the -c "
1569 "option, a local shell can be initialized. With h or help a short "
1570 "help message about the usuage can be brought to the screen.\n"
1571 "\n"
1572 "Usage: fadctrl [-c type] [OPTIONS]\n"
1573 " or: fadctrl [OPTIONS]\n";
1574 cout << endl;
1575}
1576
1577void PrintHelp()
1578{
1579 /* Additional help text which is printed after the configuration
1580 options goes here */
1581}
1582
1583int main(int argc, const char* argv[])
1584{
1585 Configuration conf(argv[0]);
1586 SetupConfiguration(conf);
1587
1588 po::variables_map vm;
1589 try
1590 {
1591 vm = conf.Parse(argc, argv);
1592 }
1593#if BOOST_VERSION > 104000
1594 catch (po::multiple_occurrences &e)
1595 {
1596 cout << "Error: " << e.what() << " of '" << e.get_option_name() << "' option." << endl;
1597 cout << endl;
1598 return -1;
1599 }
1600#endif
1601 catch (std::exception &e)
1602 {
1603 cout << "Error: " << e.what() << endl;
1604 cout << endl;
1605
1606 return -1;
1607 }
1608
1609 if (conf.HasPrint())
1610 return -1;
1611
1612 if (conf.HasVersion())
1613 {
1614 FACT::PrintVersion(argv[0]);
1615 return -1;
1616 }
1617
1618 if (conf.HasHelp())
1619 {
1620 PrintHelp();
1621 return -1;
1622 }
1623
1624 Dim::Setup(conf.Get<string>("dns"));
1625
1626// try
1627 {
1628 // No console access at all
1629 if (!conf.Has("console"))
1630 {
1631 if (conf.Get<bool>("no-dim"))
1632 return RunDim<StateMachine>(conf);
1633 else
1634 return RunDim<StateMachineDim>(conf);
1635 }
1636 // Cosole access w/ and w/o Dim
1637 if (conf.Get<bool>("no-dim"))
1638 {
1639 if (conf.Get<int>("console")==0)
1640 return RunShell<LocalShell, StateMachine>(conf);
1641 else
1642 return RunShell<LocalConsole, StateMachine>(conf);
1643 }
1644 else
1645 {
1646 if (conf.Get<int>("console")==0)
1647 return RunShell<LocalShell, StateMachineDim>(conf);
1648 else
1649 return RunShell<LocalConsole, StateMachineDim>(conf);
1650 }
1651 }
1652/* catch (std::exception& e)
1653 {
1654 cerr << "Exception: " << e.what() << endl;
1655 return -1;
1656 }*/
1657
1658 return 0;
1659}
Note: See TracBrowser for help on using the repository browser.