Context Navigation

source: trunk/FACT++/src/smartfact.cc@ 19050

Visit:

Last change on this file since 19050 was 19015, checked in by tbretz, 6 years ago
Added rain sensor
File size: 119.2 KB

Line
1	#ifdef HAVE_NOVA
2	#include "Prediction.h"
3	#endif
4
5	#ifdef HAVE_SQL
6	#include "Database.h"
7	#endif
8
9	#include <sys/stat.h> //for file stats
10	#include <sys/statvfs.h> //for file statvfs
11
12	#include "Dim.h"
13	#include "Event.h"
14	#include "Shell.h"
15	#include "StateMachineDim.h"
16	#include "Connection.h"
17	#include "Configuration.h"
18	#include "Console.h"
19	#include "DimWriteStatistics.h"
20	#include "PixelMap.h"
21
22	#include "tools.h"
23
24	#include "LocalControl.h"
25
26	#include "HeadersFAD.h"
27	#include "HeadersBIAS.h"
28	#include "HeadersFTM.h"
29	#include "HeadersFSC.h"
30	#include "HeadersGPS.h"
31	#include "HeadersSQM.h"
32	#include "HeadersMCP.h"
33	#include "HeadersLid.h"
34	#include "HeadersDrive.h"
35	#include "HeadersPower.h"
36	#include "HeadersPFmini.h"
37	#include "HeadersBiasTemp.h"
38	#include "HeadersAgilent.h"
39	#include "HeadersFeedback.h"
40	#include "HeadersRateScan.h"
41	#include "HeadersRateControl.h"
42	#include "HeadersTNGWeather.h"
43	#include "HeadersMagicLidar.h"
44	#include "HeadersMagicWeather.h"
45	#include "HeadersTemperature.h"
46	#include "HeadersRainSensor.h"
47
48	#include <boost/filesystem.hpp>
49
50	using namespace std;
51
52	// ------------------------------------------------------------------------
53
54	#include "DimDescriptionService.h"
55	#include "DimState.h"
56
57	// ------------------------------------------------------------------------
58	/*
59	template<class T>
60	class buffer : public deque<T>
61	{
62	int32_t max_size;
63
64	public:
65	buffer(int32_t max=-1) : max_size(max) { }
66	const T &operator=(const T &t) const { push_back(t); if (max_size>0 && deque<T>::size()>max_size) deque<T>::pop_front(); }
67	operator T() const { return deque<T>::size()>0 ? deque<T>::back() : T(); }
68	bool valid() const { return deque<T>::size()>0; }
69	};
70	*/
71
72	// ------------------------------------------------------------------------
73
74	namespace HTML
75	{
76	const static string kWhite = "#ffffff";
77	const static string kYellow = "#fffff0";
78	const static string kRed = "#fff8f0";
79	const static string kGreen = "#f0fff0";
80	const static string kBlue = "#f0f0ff";
81	};
82
83	// ========================================================================
84	// ========================================================================
85	// ========================================================================
86
87	class Sun
88	{
89	public:
90	Time time;
91
92	// This is always the time of the next...
93	Time fSunRise00;
94	Time fSunRise06;
95	Time fSunRise12;
96	Time fSunRise18;
97
98	Time fSunSet00;
99	Time fSunSet06;
100	Time fSunSet12;
101	Time fSunSet18;
102
103	int state;
104	string description;
105	string color;
106
107	bool isday;
108	bool visible;
109
110	#ifdef HAVE_LIBNOVA
111	Nova::RstTime Rst(double jd, double hrz=LN_SOLAR_STANDART_HORIZON)
112	{
113	Nova::RstTime rs = Nova::GetSolarRst(jd-0.5, hrz);
114	if (jd>rs.rise \|\| jd>rs.set)
115	{
116	const Nova::RstTime rs2 = Nova::GetSolarRst(jd+0.5, hrz);
117	if (jd>rs.rise)
118	rs.rise = rs2.rise;
119	if (jd>rs.set)
120	rs.set = rs2.set;
121	}
122	return rs;
123	}
124	#endif
125
126	public:
127	Sun() : time(Time::none)
128	{
129	}
130
131	// Could be done more efficient: Only recalcuate if
132	// the current time exceeds at least on of the stored times
133	Sun(const Time &t) : time(t)
134	{
135	#ifdef HAVE_LIBNOVA
136	// get Julian day from local time
137	const double JD = time.JD();
138
139	// >0deg : day
140	// -6deg - 0deg : civil twilight
141	// -12deg - -6deg : nautical twilight
142	// -18deg - -12deg : astronomical twilight
143	// <-18deg : night
144
145	const Nova::RstTime sun00 = Rst(JD);
146	const Nova::RstTime sun06 = Rst(JD, -6);
147	const Nova::RstTime sun12 = Rst(JD, -12);
148	const Nova::RstTime sun18 = Rst(JD, -18);
149
150	fSunRise00 = sun00.rise;
151	fSunRise06 = sun06.rise;
152	fSunRise12 = sun12.rise;
153	fSunRise18 = sun18.rise;
154
155	fSunSet00 = sun00.set;
156	fSunSet06 = sun06.set;
157	fSunSet12 = sun12.set;
158	fSunSet18 = sun18.set;
159
160	array<double,8> arr =
161	{{
162	sun00.set,
163	sun06.set,
164	sun12.set,
165	sun18.set,
166	sun18.rise,
167	sun12.rise,
168	sun06.rise,
169	sun00.rise,
170	}};
171
172
173	state = std::min_element(arr.begin(), arr.end())-arr.begin();
174
175	string name[] =
176	{
177	"day time",
178	"civil twilight",
179	"nautical twilight",
180	"astron. twilight",
181	"dark time",
182	"astron. twilight",
183	"nautical twilight",
184	"civil twilight"
185	};
186
187	description = name[state];
188
189	const string txt = fSunRise18<fSunSet18 ?
190	time.MinutesTo(fSunRise18)+"↑" :
191	time.MinutesTo(fSunSet18)+"↓";
192
193	description += " ["+txt+"]";
194
195	isday = state==0;
196
197	switch (state)
198	{
199	case 0: color = HTML::kRed; break;
200	case 1: case 2: color = HTML::kYellow; break;
201	case 3: case 4: case 5: color = HTML::kGreen; break;
202	case 6: case 7: color = HTML::kYellow; break;
203	}
204
205	visible = state==0;
206
207	/*
208	// Warning: return code of 1 means circumpolar and is not checked!
209	Nova::RstTime sun_day = Nova::GetSolarRst(JD-0.5);
210	Nova::RstTime sun_civil = Nova::GetSolarRst(JD-0.5, -6);
211	Nova::RstTime sun_astronomical = Nova::GetSolarRst(JD-0.5, -12);
212	Nova::RstTime sun_dark = Nova::GetSolarRst(JD-0.5, -18);
213
214	fSetDayTime = Time(sun_day.set);
215	fSetCivil = Time(sun_civil.set);
216	fSetAstronomical = Time(sun_astronomical.set);
217	fSetDarkTime = Time(sun_dark.set);
218
219	fRiseDayTime = Time(sun_day.rise);
220	fRiseCivil = Time(sun_civil.rise);
221	fRiseAstronomical = Time(sun_astronomical.rise);
222	fRiseDarkTime = Time(sun_dark.rise);
223
224	const bool is_day = JD>sun_day.rise;
225	const bool is_night = JD>sun_dark.set;
226
227	sun_day = Nova::GetSolarRst(JD+0.5);
228	sun_civil = Nova::GetSolarRst(JD+0.5, -6);
229	sun_astronomical = Nova::GetSolarRst(JD+0.5, -12);
230	sun_dark = Nova::GetSolarRst(JD+0.5, -18);
231
232	if (is_day)
233	{
234	fRiseDayTime = Time(sun_day.rise);
235	fRiseCivil = Time(sun_civil.rise);
236	fRiseAstronomical = Time(sun_astronomical.rise);
237	fRiseDarkTime = Time(sun_dark.rise);
238	}
239
240	if (is_night)
241	{
242	fSetDayTime = Time(sun_day.set);
243	fSetCivil = Time(sun_civil.set);
244	fSetAstronomical = Time(sun_astronomical.set);
245	fSetDarkTime = Time(sun_dark.set);
246	}
247
248	// case 0: midnight to sun-rise \| !is_day && !is_night \| rise/set \| -> isday=0
249	// case 1: sun-rise to sun-set \| is_day && !is_night \| set /rise \| -> isday=1
250	// case 2: sun-set to midnight \| is_day && is_night \| rise/set \| -> isday=0
251
252	isday = is_day^is_night;
253
254	Time fRiseDayTime; // 0: Start of day time (=end of civil twilight)
255	Time fRiseCivil; // -6: End of nautical twilight
256	Time fRiseAstronomical; // -12: End of astron. twilight
257	Time fRiseDarkTime; // -18: End of dark time
258
259	Time fSetDayTime; // 0: End of day time (=start of civil twilight)
260	Time fSetCivil; // -6: Start of nautical twilight
261	Time fSetAstronomical; // -12: Start of astron. twilight
262	Time fSetDarkTime; // -18: Start of dark time
263
264	state = isday ? 4 : 0; // 0 [-> Day time ]
265	if (time>fSetDayTime) state++; // 1 [-> Civil twilight]
266	if (time>fSetCivil) state++; // 2 [-> Naut. twilight]
267	if (time>fSetAstronomical) state++; // 3 [-> Astro. twilight]
268	if (time>fSetDarkTime) state++; // 4 [-> Dark time ]
269
270	if (time>fRiseDarkTime) state++; // 5 [-> Astro. twilight]
271	if (time>fRiseAstronomical) state++; // 6 [-> Naut. twilight]
272	if (time>fRiseCivil) state++; // 7 [-> Civil twilight]
273	if (time>fRiseDayTime) state++; // 8 [-> Day time ]
274
275	string name[] =
276	{
277	"dark time", // 0
278	"astron. twilight", // 1
279	"civil twilight", // 2
280	"sunrise", // 3
281	"day time", // 4
282	"sunset", // 5
283	"civil twilight", // 6
284	"astron. twilight", // 7
285	"dark time" // 8
286	};
287
288	description = name[state];
289
290	const string arr = isday ?
291	fSetDarkTime.MinutesTo(time)+"↓" :
292	fRiseDarkTime.MinutesTo(time)+"↑";
293
294	description += " ["+arr+"]";
295
296	switch (state)
297	{
298	case 0: case 1: color = HTML::kGreen; break;
299	case 2: case 3: color = HTML::kYellow; break;
300	case 4: color = HTML::kRed; break;
301	case 5: case 6: color = HTML::kYellow; break;
302	case 7: case 8: color = HTML::kGreen; break;
303	}
304
305	visible = state>=3 && state<=5;
306	*/
307	#endif
308	}
309	};
310
311	class Moon
312	{
313	public:
314	Time time;
315
316	double ra;
317	double dec;
318
319	double zd;
320	double az;
321
322	double disk;
323
324	bool visible;
325
326	Time fRise;
327	Time fTransit;
328	Time fSet;
329
330	string description;
331	string color;
332
333	int state;
334
335	Moon() : time(Time::none)
336	{
337	}
338
339	// Could be done more efficient: Only recalcuate if
340	// the current time exceeds at least on of the stored times
341	Moon(const Time &t) : time(t)
342	{
343	#ifdef HAVE_LIBNOVA
344	const double JD = time.JD();
345
346	Nova::RstTime moon = Nova::GetLunarRst(JD-0.5);
347
348	fRise = Time(moon.rise);
349	fTransit = Time(moon.transit);
350	fSet = Time(moon.set);
351
352	//visible =
353	// ((JD>moon.rise && JD<moon.set ) && moon.rise<moon.set) \|\|
354	// ((JD<moon.set \|\| JD>moon.rise) && moon.rise>moon.set);
355
356	const bool is_up = JD>moon.rise;
357	const bool is_sinking = JD>moon.transit;
358	const bool is_dn = JD>moon.set;
359
360	moon = Nova::GetLunarRst(JD+0.5);
361	if (is_up)
362	fRise = Time(moon.rise);
363	if (is_sinking)
364	fTransit = Time(moon.transit);
365	if (is_dn)
366	fSet = Time(moon.set);
367
368	const Nova::EquPosn pos = Nova::GetLunarEquCoords(JD);
369	const Nova::ZdAzPosn hrz = Nova::GetHrzFromEqu(pos, JD);
370
371	az = hrz.az;
372	zd = hrz.zd;
373
374	ra = pos.ra/15;
375	dec = pos.dec;
376
377	disk = Nova::GetLunarDisk(JD)*100;
378	state = 0;
379	if (fRise <fTransit && fRise <fSet) state = 0; // not visible
380	if (fTransit<fSet && fTransit<fRise) state = 1; // before culm
381	if (fSet <fRise && fSet <fTransit) state = 2; // after culm
382
383	visible = state!=0;
384
385	// 0: not visible
386	// 1: visible before cul
387	// 2: visible after cul
388
389	if (!visible \|\| disk<25)
390	color = HTML::kGreen;
391	else
392	color = disk>75 ? HTML::kRed : HTML::kYellow;
393
394	const string arr = fSet<fRise ?
395	fSet.MinutesTo(time) +"↓" :
396	fRise.MinutesTo(time)+"↑";
397
398	ostringstream out;
399	out << setprecision(2);
400	out << (visible?"visible ":"") << (disk<0.1?0:disk) << "% [" << arr << "]";
401
402	description = out.str();
403	#endif
404	}
405
406	double Angle(double r, double d) const
407	{
408	const double theta0 = M_PI/2-d*M_PI/180;
409	const double phi0 = r*M_PI/12;
410
411	const double theta1 = M_PI/2-dec*M_PI/180;
412	const double phi1 = ra*M_PI/12;
413
414	const double x0 = sin(theta0) * cos(phi0);
415	const double y0 = sin(theta0) * sin(phi0);
416	const double z0 = cos(theta0);
417
418	const double x1 = sin(theta1) * cos(phi1);
419	const double y1 = sin(theta1) * sin(phi1);
420	const double z1 = cos(theta1);
421
422	double arg = x0x1 + y0y1 + z0*z1;
423	if(arg > 1.0) arg = 1.0;
424	if(arg < -1.0) arg = -1.0;
425
426	return acos(arg) * 180/M_PI;
427	}
428
429	static string Color(double angle)
430	{
431	if (angle<10 \|\| angle>150)
432	return HTML::kRed;
433	if (angle<20 \|\| angle>140)
434	return HTML::kYellow;
435	return HTML::kGreen;
436	}
437	};
438
439	// ========================================================================
440	// ========================================================================
441	// ========================================================================
442
443	class StateMachineSmartFACT : public StateMachineDim
444	{
445	public:
446	static bool fIsServer;
447
448	private:
449	enum states_t
450	{
451	kStateDimNetworkNA = 1,
452	kStateRunning,
453	};
454
455	// ------------------------- History classes -----------------------
456
457	struct EventElement
458	{
459	Time time;
460	string msg;
461
462	EventElement(const Time &t, const string &s) : time(t), msg(s) { }
463	};
464
465	class EventHist : public list<EventElement>
466	{
467	const boost::posix_time::time_duration deltat; //boost::posix_time::pos_infin
468	const uint64_t max;
469
470	public:
471	EventHist(const boost::posix_time::time_duration &dt=boost::posix_time::hours(12), uint64_t mx=UINT64_MAX) : deltat(dt), max(mx) { }
472
473	void add(const string &s, const Time &t=Time())
474	{
475	while (!empty() && (front().time+deltat<t \|\| size()>max))
476	pop_front();
477
478	emplace_back(t, s);
479	}
480
481	void clean()
482	{
483	for (auto it=begin(); it!=end();)
484	if (!it->time)
485	{
486	const auto is = it++;
487	erase(is);
488	}
489	}
490
491	string get() const
492	{
493	ostringstream out;
494
495	string last = "";
496	for (auto it=begin(); it!=end(); it++)
497	{
498	const string tm = it->time.GetAsStr("%H:%M:%S ");
499	out << (tm!=last?tm:"--:--:-- ") << it->msg << "<br/>";
500	last = tm;
501	}
502
503	return out.str();
504	}
505	string rget() const
506	{
507	ostringstream out;
508
509	for (auto it=rbegin(); it!=rend(); it++)
510	out << it->time.GetAsStr("%H:%M:%S ") << it->msg << "<br/>";
511
512	return out.str();
513	}
514	};
515
516	// ------------------------- Internal variables -----------------------
517
518	const Time fRunTime;
519
520	PixelMap fPixelMap;
521
522	string fDatabase;
523
524	Time fLastUpdate;
525	Time fLastAstroCalc;
526
527	string fPath;
528
529	// ----------------------------- Data storage -------------------------
530
531	EventHist fControlMessageHist;
532	EventHist fControlAlarmHist;
533
534	int32_t fMcpConfigurationState; // For consistency
535	int64_t fMcpConfigurationMaxTime;
536	int64_t fMcpConfigurationMaxEvents;
537	string fMcpConfigurationName;
538	Time fMcpConfigurationRunStart;
539	EventHist fMcpConfigurationHist;
540	bool fLastRunFinishedWithZeroEvents;
541
542	enum weather_t { kWeatherBegin=0, kTemp = kWeatherBegin, kDew, kHum, kPress, kWind, kGusts, kDir, kWeatherEnd = kDir+1 };
543	deque<float> fMagicWeatherHist[kWeatherEnd];
544
545	deque<float> fTngWeatherDustHist;
546	Time fTngWeatherDustTime;
547
548	deque<float> fRainSensorDataHist;
549	Time fRainSensorDataTime;
550
551	vector<float> fBiasControlVoltageVec;
552
553	float fBiasControlPowerTot;
554	float fBiasControlVoltageMed;
555	float fBiasControlCurrentMed;
556	float fBiasControlCurrentMax;
557
558	deque<float> fBiasControlCurrentHist;
559	deque<float> fFscControlTemperatureHist;
560
561	float fFscControlHumidityAvg;
562
563	deque<float> fPfMiniHumidityHist;
564	deque<float> fPfMiniTemperatureHist;
565
566	deque<float> fTemperatureControlHist;
567
568	float fDriveControlPointingZd;
569	string fDriveControlPointingAz;
570	string fDriveControlSourceName;
571	float fDriveControlMoonDist;
572
573	deque<float> fDriveControlTrackingDevHist;
574
575	int64_t fFadControlNumEvents;
576	int64_t fFadControlStartRun;
577	int32_t fFadControlDrsStep;
578	vector<uint32_t> fFadControlDrsRuns;
579
580	deque<float> fFtmControlTriggerRateHist;
581	int32_t fFtmControlTriggerRateTooLow;
582	int fFtmControlState;
583
584	float fFtmPatchThresholdMed;
585	float fFtmBoardThresholdMed;
586
587	bool fFtmControlFtuOk;
588
589	deque<float> fRateControlThreshold;
590
591	uint64_t fRateScanDataId;
592	uint8_t fRateScanBoard;
593	deque<float> fRateScanDataHist[41];
594
595	set<string> fErrorList;
596	EventHist fErrorHist;
597	EventHist fChatHist;
598
599	uint64_t fFreeSpace;
600
601	Sun fSun;
602	Moon fMoon;
603
604	// --------------------------- File header ----------------------------
605
606	Time fAudioTime;
607	string fAudioName;
608
609	string Header(const Time &d)
610	{
611	ostringstream msg;
612	msg << d.JavaDate() << '\t' << fAudioTime.JavaDate() << '\t' << fAudioName;
613	return msg.str();
614	}
615
616	string Header(const EventImp &d)
617	{
618	return Header(d.GetTime());
619	}
620
621	void SetAudio(const string &name)
622	{
623	fAudioName = name;
624	fAudioTime = Time();
625	}
626
627	// ------------- Initialize variables before the Dim stuff ------------
628
629	DimVersion fDimDNS;
630	DimControl fDimControl;
631	DimDescribedState fDimMcp;
632	DimDescribedState fDimDataLogger;
633	DimDescribedState fDimDriveControl;
634	DimDescribedState fDimTimeCheck;
635	DimDescribedState fDimMagicWeather;
636	DimDescribedState fDimMagicLidar;
637	DimDescribedState fDimTngWeather;
638	DimDescribedState fDimTemperature;
639	DimDescribedState fDimRainSensor;
640	DimDescribedState fDimFeedback;
641	DimDescribedState fDimBiasControl;
642	DimDescribedState fDimFtmControl;
643	DimDescribedState fDimFadControl;
644	DimDescribedState fDimFscControl;
645	DimDescribedState fDimPfMiniControl;
646	DimDescribedState fDimBiasTemp;
647	DimDescribedState fDimGpsControl;
648	DimDescribedState fDimSqmControl;
649	DimDescribedState fDimAgilentControl24;
650	DimDescribedState fDimAgilentControl50;
651	DimDescribedState fDimAgilentControl80;
652	DimDescribedState fDimPwrControl;
653	DimDescribedState fDimLidControl;
654	DimDescribedState fDimRateControl;
655	DimDescribedState fDimRateScan;
656	DimDescribedState fDimChat;
657	DimDescribedState fDimSkypeClient;
658
659	// -------------------------------------------------------------------
660
661	string GetDir(const double angle)
662	{
663	static const char *dir[] =
664	{
665	"N", "NNE", "NE", "ENE",
666	"E", "ESE", "SE", "SSE",
667	"S", "SSW", "SW", "WSW",
668	"W", "WNW", "NW", "NNW"
669	};
670
671	const uint16_t idx = uint16_t(floor(angle/22.5+16.5))%16;
672	return dir[idx];
673	}
674
675	// -------------------------------------------------------------------
676
677	bool CheckDataSize(const EventImp &d, const char *name, size_t size, bool min=false)
678	{
679	if (d.GetSize()==0)
680	return false;
681
682	if ((!min && d.GetSize()==size) \|\| (min && d.GetSize()>size))
683	return true;
684
685	ostringstream msg;
686	msg << name << " - Received service has " << d.GetSize() << " bytes, but expected ";
687	if (min)
688	msg << "more than ";
689	msg << size << ".";
690	Warn(msg);
691	return false;
692	}
693
694	// -------------------------------------------------------------------
695
696	template<class T>
697	void WriteBinaryVec(const Time &tm, const string &fname, const vector<T> &vec, double scale, double offset=0, const string &title="", const string &col="")
698	{
699	if (vec.empty())
700	return;
701
702	ostringstream out;
703	out << tm.JavaDate() << '\n';
704	out << offset << '\n';
705	out << offset+scale << '\n';
706	out << setprecision(3);
707	if (!title.empty())
708	out << title << '\x7f';
709	else
710	{
711	const Statistics stat(vec[0]);
712	out << stat.min << '\n';
713	out << stat.med << '\n';
714	out << stat.max << '\x7f';
715	}
716	if (!col.empty())
717	out << col;
718	for (auto it=vec.cbegin(); it!=vec.cend(); it++)
719	{
720	// The valid range is from 1 to 127
721	// \0 is used to seperate different curves
722	vector<uint8_t> val(it->size());
723	for (uint64_t i=0; i<it->size(); i++)
724	{
725	float range = nearbyint(126*(double(it->at(i))-offset)/scale); // [-2V; 2V]
726	if (range>126)
727	range=126;
728	if (range<0)
729	range=0;
730	val[i] = (uint8_t)range;
731	}
732
733	const char ptr = reinterpret_cast<char>(val.data());
734	out.write(ptr, val.size()*sizeof(uint8_t));
735	out << '\x7f';
736	}
737
738	ofstream(fPath+"/"+fname+".bin") << out.str();
739	}
740	/*
741	template<class T>
742	void WriteBinaryVec(const EventImp &d, const string &fname, const vector<T> &vec, double scale, double offset=0, const string &title="")
743	{
744	WriteBinaryVec(d.GetTime(), fname, vec, scale, offset, title);
745	}
746
747	template<class T>
748	void WriteBinary(const Time &tm, const string &fname, const T &t, double scale, double offset=0)
749	{
750	WriteBinaryVec(tm, fname, vector<T>(&t, &t+1), scale, offset);
751	}
752
753	template<class T>
754	void WriteBinary(const EventImp &d, const string &fname, const T &t, double scale, double offset=0)
755	{
756	WriteBinaryVec(d.GetTime(), fname, vector<T>(&t, &t+1), scale, offset);
757	}*/
758
759	template<class T>
760	void WriteHist(const EventImp &d, const string &fname, const T &t, double scale, double offset=0)
761	{
762	WriteBinaryVec(d.GetTime(), fname, vector<T>(&t, &t+1), scale, offset, "", "000");
763	}
764
765	template<class T>
766	void WriteCam(const EventImp &d, const string &fname, const T &t, double scale, double offset=0)
767	{
768	WriteBinaryVec(d.GetTime(), fname, vector<T>(&t, &t+1), scale, offset, "", "");
769	}
770
771
772	// -------------------------------------------------------------------
773
774	struct Statistics
775	{
776	float min;
777	float max;
778	float med;
779	float avg;
780	//float rms;
781
782	template<class T>
783	Statistics(const T &t, size_t offset_min=0, size_t offset_max=0)
784	: min(0), max(0), med(0), avg(0)
785	{
786	if (t.empty())
787	return;
788
789	T copy(t);
790	sort(copy.begin(), copy.end());
791
792	if (offset_min>t.size())
793	offset_min = 0;
794	if (offset_max>t.size())
795	offset_max = 0;
796
797	min = copy[offset_min];
798	max = copy[copy.size()-1-offset_max];
799	avg = accumulate (t.begin(), t.end(), 0.)/t.size();
800
801	const size_t p = copy.size()/2;
802	med = copy.size()%2 ? copy[p] : (copy[p-1]+copy[p])/2.;
803	}
804	};
805
806	void HandleControlMessageImp(const EventImp &d)
807	{
808	if (d.GetSize()==0)
809	return;
810
811	fControlMessageHist.add(d.GetText(), d.GetTime());
812
813	ostringstream out;
814	out << setprecision(3);
815	out << Header(d) << '\n';
816	out << HTML::kWhite << '\t';
817	out << "<->" << fControlMessageHist.get() << "</->";
818	out << '\n';
819
820	ofstream(fPath+"/scriptlog.data") << out.str();
821	}
822
823	int HandleDimControlMessage(const EventImp &d)
824	{
825	if (d.GetSize()==0)
826	return GetCurrentState();
827
828	if (d.GetQoS()==MessageImp::kAlarm)
829	{
830	if (d.GetSize()<2)
831	for (auto it=fControlAlarmHist.begin(); it!=fControlAlarmHist.end(); it++)
832	it->time = Time(Time::none);
833	else
834	fControlAlarmHist.add(d.GetText(), d.GetTime());
835	}
836
837	if (d.GetQoS()==MessageImp::kComment && d.GetSize()>1)
838	HandleControlMessageImp(d);
839
840	return GetCurrentState();
841	}
842
843	int HandleControlStateChange(const EventImp &d)
844	{
845	if (d.GetSize()==0)
846	return StateMachineImp::kSM_KeepState;
847
848	if (fDimControl.scriptdepth>0)
849	return StateMachineImp::kSM_KeepState;
850
851	if (d.GetQoS()>=2)
852	return StateMachineImp::kSM_KeepState;
853
854	#if BOOST_VERSION < 104600
855	const string file = boost::filesystem::path(fDimControl.file).filename();
856	#else
857	const string file = boost::filesystem::path(fDimControl.file).filename().string();
858	#endif
859
860	// [0] DimControl::kIdle
861	// [1] DimControl::kLoading
862	// [2] DimControl::kCompiling
863	// [3] DimControl::kRunning
864	if (d.GetQoS()==1)
865	{
866	fControlMessageHist.clear();
867	HandleControlMessageImp(Event(d, "========================================", 41));
868	}
869
870	HandleControlMessageImp(Event(d, ("----- "+fDimControl.shortmsg+" -----").data(), fDimControl.shortmsg.length()+13));
871	if (!file.empty() && d.GetQoS()<2)
872	HandleControlMessageImp(Event(d, file.data(), file.length()+1));
873
874	// Note that this will also "ding" just after program startup
875	// if the dimctrl is still in state -3
876	if (d.GetQoS()==0)
877	{
878	HandleControlMessageImp(Event(d, "========================================", 41));
879	if (fDimControl.last.second!=DimState::kOffline)
880	SetAudio("ding");
881	}
882
883	return StateMachineImp::kSM_KeepState;
884	}
885
886	void AddMcpConfigurationHist(const EventImp &d, const string &msg)
887	{
888	fMcpConfigurationHist.add(msg, d.GetTime());
889
890	ostringstream out;
891	out << d.GetJavaDate() << '\n';
892	out << HTML::kWhite << '\t';
893	out << "<->" << fMcpConfigurationHist.rget() << "</->";
894	out << '\n';
895
896	ofstream(fPath+"/observations.data") << out.str();
897	}
898
899	int HandleFscControlStateChange(const EventImp &d)
900	{
901	const int32_t &last = fDimFscControl.last.second;
902	const int32_t &state = fDimFscControl.state();
903
904	if (last==DimState::kOffline \|\| state==DimState::kOffline)
905	return StateMachineImp::kSM_KeepState;
906
907	if (last<FSC::State::kConnected && state==FSC::State::kConnected)
908	{
909	AddMcpConfigurationHist(d, "<B>FSC swiched on</B>");
910	//SetAudio("startup");
911	}
912
913	if (last==FSC::State::kConnected && state<FSC::State::kConnected)
914	{
915	AddMcpConfigurationHist(d, "<B>FSC swiched off</B>");
916	//SetAudio("shutdown");
917	}
918
919	return StateMachineImp::kSM_KeepState;
920	}
921
922	int HandleMcpConfiguration(const EventImp &d)
923	{
924	if (!CheckDataSize(d, "Mcp:Configuration", 16, true))
925	{
926	fMcpConfigurationState = DimState::kOffline;
927	fMcpConfigurationMaxTime = 0;
928	fMcpConfigurationMaxEvents = 0;
929	fMcpConfigurationName = "";
930	fMcpConfigurationRunStart = Time(Time::none);
931	return GetCurrentState();
932	}
933
934	// If a run ends...
935	if (fMcpConfigurationState==MCP::State::kTakingData && d.GetQoS()==MCP::State::kIdle)
936	{
937	// ...and no script is running just play a simple 'tick'
938	// ...and a script is running just play a simple 'tick'
939	if (/fDimControl.state()<-2 &&/ fDimControl.scriptdepth==0)
940	SetAudio("dong");
941	else
942	SetAudio("losticks");
943
944	fLastRunFinishedWithZeroEvents = fFadControlNumEvents==0;
945
946	ostringstream out;
947	out << "<#darkred>" << d.Ptr<char>(16);
948	if (!fDriveControlSourceName.empty())
949	out << " [" << fDriveControlSourceName << ']';
950	out << " (N=" << fFadControlNumEvents << ')';
951	out << "</#>";
952
953	AddMcpConfigurationHist(d, out.str());
954	}
955
956	if (d.GetQoS()==MCP::State::kTakingData)
957	{
958	fMcpConfigurationRunStart = Time();
959	SetAudio("losticks");
960
961	ostringstream out;
962	out << "<#darkgreen>" << fMcpConfigurationName;
963	if (!fDriveControlSourceName.empty())
964	out << " [" << fDriveControlSourceName << ']';
965	if (fFadControlStartRun>0)
966	out << " (Run " << fFadControlStartRun << ')';
967	out << "</#>";
968
969	AddMcpConfigurationHist(d, out.str());
970	}
971
972	fMcpConfigurationState = d.GetQoS();
973	fMcpConfigurationMaxTime = d.Get<uint64_t>();
974	fMcpConfigurationMaxEvents = d.Get<uint64_t>(8);
975	fMcpConfigurationName = d.Ptr<char>(16);
976
977	return GetCurrentState();
978	}
979
980	void WriteWeather(const EventImp &d, const string &name, int i, float min, float max)
981	{
982	const Statistics stat(fMagicWeatherHist[i]);
983
984	ostringstream out;
985	out << setprecision(3);
986	out << d.GetJavaDate() << '\n';
987
988	out << HTML::kWhite << '\t' << fMagicWeatherHist[i].back() << '\n';
989	out << HTML::kWhite << '\t' << stat.min << '\n';
990	out << HTML::kWhite << '\t' << stat.avg << '\n';
991	out << HTML::kWhite << '\t' << stat.max << '\n';
992
993	ofstream(fPath+"/"+name+".data") << out.str();
994
995	WriteHist(d, "hist-magicweather-"+name, fMagicWeatherHist[i], max-min, min);
996	}
997
998	int HandleMagicWeatherData(const EventImp &d)
999	{
1000	if (!CheckDataSize(d, "MagicWeather:Data", 7*4+2))
1001	return GetCurrentState();
1002
1003	// Store a history of the last 300 entries
1004	for (int i=kWeatherBegin; i<kWeatherEnd; i++)
1005	{
1006	fMagicWeatherHist[i].push_back(d.Ptr<float>(2)[i]);
1007	if (fMagicWeatherHist[i].size()>300)
1008	fMagicWeatherHist[i].pop_front();
1009	}
1010
1011	ostringstream out;
1012	out << d.GetJavaDate() << '\n';
1013	if (fSun.time.IsValid() && fMoon.time.IsValid())
1014	{
1015	out << fSun.color << '\t' << fSun.description << '\n';
1016	out << setprecision(2);
1017	out << (fSun.isday?HTML::kWhite:fMoon.color) << '\t' << fMoon.description << '\n';
1018	}
1019	else
1020	out << "\n\n";
1021	out << setprecision(3);
1022	for (int i=0; i<6; i++)
1023	out << HTML::kWhite << '\t' << fMagicWeatherHist[i].back() << '\n';
1024	out << HTML::kWhite << '\t' << GetDir(fMagicWeatherHist[kDir].back()) << '\n';
1025	out << HTML::kWhite << '\t';
1026	if (!fTngWeatherDustHist.empty())
1027	out << fTngWeatherDustHist.back() << '\t' << fTngWeatherDustTime.GetAsStr("%H:%M") << '\n';
1028	else
1029	out << "\t\n";
1030
1031	ofstream(fPath+"/weather.data") << out.str();
1032
1033	WriteWeather(d, "temp", kTemp, -5, 35);
1034	WriteWeather(d, "dew", kDew, -5, 35);
1035	WriteWeather(d, "hum", kHum, 0, 100);
1036	WriteWeather(d, "wind", kWind, 0, 100);
1037	WriteWeather(d, "gusts", kGusts, 0, 100);
1038	WriteWeather(d, "press", kPress, 700, 1000);
1039
1040	return GetCurrentState();
1041	}
1042
1043	int HandleTngWeatherDust(const EventImp &d)
1044	{
1045	if (!CheckDataSize(d, "TngWeather:Dust", 4))
1046	return GetCurrentState();
1047
1048	fTngWeatherDustTime = d.GetTime();
1049
1050	fTngWeatherDustHist.push_back(d.GetFloat());
1051	if (fTngWeatherDustHist.size()>300)
1052	fTngWeatherDustHist.pop_front();
1053
1054	const Statistics stat(fTngWeatherDustHist);
1055
1056	const double scale = stat.max>0 ? pow(10, ceil(log10(stat.max))) : 0;
1057
1058	WriteHist(d, "hist-tng-dust", fTngWeatherDustHist, scale);
1059
1060	ostringstream out;
1061	out << d.GetJavaDate() << '\n';
1062
1063	ofstream(fPath+"/tngdust.data") << out.str();
1064
1065	return GetCurrentState();
1066	}
1067
1068	int HandleRainSensorData(const EventImp &d)
1069	{
1070	if (!CheckDataSize(d, "RainSensor:Data", 12)) // F:1;X:1
1071	return GetCurrentState();
1072
1073	fRainSensorDataTime = d.GetTime();
1074
1075	fRainSensorDataHist.push_back(d.GetFloat());
1076	if (fRainSensorDataHist.size()>300)
1077	fRainSensorDataHist.pop_front();
1078
1079	const Statistics stat(fRainSensorDataHist);
1080
1081	const double scale = stat.max>0 ? pow(10, ceil(log10(stat.max))) : 0;
1082
1083	WriteHist(d, "hist-rain-sensor-data", fRainSensorDataHist, scale);
1084
1085	ostringstream out;
1086	out << d.GetJavaDate() << '\n';
1087
1088	ofstream(fPath+"/rainsensor.data") << out.str();
1089
1090	return GetCurrentState();
1091	}
1092
1093	int HandleDriveControlStateChange(const EventImp &d)
1094	{
1095	const int32_t &last = fDimFscControl.last.second;
1096	const int32_t &state = fDimFscControl.state();
1097
1098	if (last==DimState::kOffline \|\| state==DimState::kOffline)
1099	return StateMachineImp::kSM_KeepState;
1100
1101	if (last<Drive::State::kInitialized && state>=Drive::State::kInitialized)
1102	AddMcpConfigurationHist(d, "Drive ready");
1103
1104	if (last>=Drive::State::kInitialized && state<Drive::State::kInitialized)
1105	AddMcpConfigurationHist(d, "Drive not ready");
1106
1107	return StateMachineImp::kSM_KeepState;
1108	}
1109
1110	int HandleDrivePointing(const EventImp &d)
1111	{
1112	if (!CheckDataSize(d, "DriveControl:Pointing", 16))
1113	return GetCurrentState();
1114
1115	fDriveControlPointingZd = d.Get<double>();
1116
1117	const double az = d.Get<double>(8);
1118
1119	fDriveControlPointingAz = GetDir(az);
1120
1121	ostringstream out;
1122	out << d.GetJavaDate() << '\n';
1123
1124	out << setprecision(0) << fixed;
1125	out << HTML::kWhite << '\t' << az << '\t' << fDriveControlPointingAz << '\n';
1126	out << HTML::kWhite << '\t' << fDriveControlPointingZd << '\n';
1127
1128	ofstream(fPath+"/pointing.data") << out.str();
1129
1130	return GetCurrentState();
1131	}
1132
1133	int HandleDriveTracking(const EventImp &d)
1134	{
1135	if (!CheckDataSize(d, "DriveControl:Tracking", 96))
1136	return GetCurrentState();
1137
1138
1139
1140	const double Ra = d.Get<double>(0*8);
1141	const double Dec = d.Get<double>(1*8);
1142	const double Zd = d.Get<double>(6*8);
1143	const double Az = d.Get<double>(7*8);
1144
1145	const double dev = d.Get<double>(11*8);
1146
1147	fDriveControlTrackingDevHist.push_back(dev);
1148	if (fDriveControlTrackingDevHist.size()>300)
1149	fDriveControlTrackingDevHist.pop_front();
1150
1151	WriteHist(d, "hist-control-deviation", fDriveControlTrackingDevHist, 120);
1152
1153	ostringstream out;
1154	out << d.GetJavaDate() << '\n';
1155
1156	out << HTML::kWhite << '\t' << fDriveControlSourceName << '\n';
1157	out << setprecision(5);
1158	out << HTML::kWhite << '\t' << Ra << '\n';
1159	out << HTML::kWhite << '\t' << Dec << '\n';
1160	out << setprecision(3);
1161	out << HTML::kWhite << '\t' << Zd << '\n';
1162	out << HTML::kWhite << '\t' << Az << '\n';
1163	out << HTML::kWhite << '\t' << dev << '\n';
1164
1165	fDriveControlMoonDist = -1;
1166
1167	if (fMoon.visible)
1168	{
1169	const double angle = fMoon.Angle(Ra, Dec);
1170	out << Moon::Color(angle) << '\t' << setprecision(3) << angle << '\n';
1171
1172	fDriveControlMoonDist = angle;
1173	}
1174	else
1175	out << HTML::kWhite << "\t— \n";
1176
1177	ofstream(fPath+"/tracking.data") << out.str();
1178
1179	return GetCurrentState();
1180	}
1181
1182	int HandleDriveSource(const EventImp &d)
1183	{
1184	if (!CheckDataSize(d, "DriveControl:Source", 5*8+31))
1185	return GetCurrentState();
1186
1187	const double *ptr = d.Ptr<double>();
1188
1189	const double ra = ptr[0]; // Ra[h]
1190	const double dec = ptr[1]; // Dec[deg]
1191	const double woff = ptr[2]; // Wobble offset [deg]
1192	const double wang = ptr[3]; // Wobble angle [deg]
1193	const double period = ptr[4]; // Wobble angle [deg]
1194
1195	fDriveControlSourceName = d.Ptr<char>(5*8);
1196
1197	ostringstream out;
1198	out << d.GetJavaDate() << '\n';
1199
1200	out << HTML::kWhite << '\t' << fDriveControlSourceName << '\n';
1201	out << setprecision(5);
1202	out << HTML::kWhite << '\t' << ra << '\n';
1203	out << HTML::kWhite << '\t' << dec << '\n';
1204	out << setprecision(3);
1205	out << HTML::kWhite << '\t' << woff << '\n';
1206	out << HTML::kWhite << '\t' << wang << '\n';
1207	out << HTML::kWhite << '\t' << period << '\n';
1208
1209	ofstream(fPath+"/source.data") << out.str();
1210
1211	return GetCurrentState();
1212	}
1213
1214	int HandleFeedbackCalibratedCurrents(const EventImp &d)
1215	{
1216	if (!CheckDataSize(d, "Feedback:CalibratedCurrents", (416+1+1+1+1+1+416+1+1)*sizeof(float)+sizeof(uint32_t)))
1217	return GetCurrentState();
1218
1219	const float *ptr = d.Ptr<float>();
1220
1221	double power_tot = 0;
1222	double power_apd = 0;
1223
1224	if (fBiasControlVoltageVec.size()>0)
1225	{
1226	// Calibrate the data (subtract offset)
1227	for (int i=0; i<320; i++)
1228	{
1229	// Exclude crazy pixels
1230	if (i==66 \|\| i==191 \|\| i==193)
1231	continue;
1232
1233	// Group index (0 or 1) of the of the pixel (4 or 5 pixel patch)
1234	const int N = fPixelMap.hv(i).count();
1235
1236	// Serial resistor of the individual G-APDs
1237	double R5 = 3900/N;
1238
1239	// This is also valid for the patches with wrong resistors,
1240	// because Iapd is a factor f larger but R a factor f smaller
1241	double Iapd = ptr[i] * 1e-6; // [A]
1242	double Iout = Iapd*N; // [A]
1243
1244	double UdrpCam = 1000 *Iout; // Voltage seen by everything in Camera
1245	double UdrpApd = (R5+2000)*Iout; // Voltage seen by G-APD
1246
1247	const double pwrCam = Iout * (fBiasControlVoltageVec[i]-UdrpCam);
1248	const double pwrApd = Iout * (fBiasControlVoltageVec[i]-UdrpApd);
1249
1250	// Total power participated in the camera at the G-APD
1251	// and the serial resistors (total voltage minus voltage
1252	// drop at resistors in bias crate)
1253	power_tot += pwrCam;
1254
1255	// Power consumption per G-APD
1256	power_apd += pwrApd;
1257	}
1258	}
1259
1260	// Divide by number of summed channels, convert to mW
1261	power_apd /= (320-3)*1e-3; // [mW]
1262
1263	if (power_tot<1e-3)
1264	power_tot = 0;
1265	if (power_apd<1e-3)
1266	power_apd = 0;
1267
1268	fBiasControlPowerTot = power_tot;
1269
1270	// --------------------------------------------------------
1271
1272	// Get the maximum of each patch
1273	vector<float> val(320, 0);
1274	for (int i=0; i<320; i++)
1275	{
1276	const int idx = (fPixelMap.hv(i).hw()/9)*2+fPixelMap.hv(i).group();
1277	val[idx] = ptr[i];
1278	}
1279
1280	// Write the 160 patch values to a file
1281	WriteCam(d, "cam-biascontrol-current", val, 100);
1282
1283	// --------------------------------------------------------
1284
1285	// After being displayed, exclude the patches with
1286	// the crazy pixels from the statsitics
1287
1288	vector<float> cpy(ptr, ptr+320);
1289	cpy[66] = 0;
1290	cpy[191] = 0;
1291	cpy[193] = 0;
1292	const Statistics stat(cpy);
1293
1294	// Exclude the three crazy channels
1295	fBiasControlCurrentMed = stat.med;
1296	fBiasControlCurrentMax = stat.max;
1297
1298	// Store a history of the last 60 entries
1299	fBiasControlCurrentHist.push_back(fBiasControlCurrentMed);
1300	if (fBiasControlCurrentHist.size()>360)
1301	fBiasControlCurrentHist.pop_front();
1302
1303	// write the history to a file
1304	WriteHist(d, "hist-biascontrol-current", fBiasControlCurrentHist, 125);
1305
1306	// --------------------------------------------------------
1307
1308	string col1 = HTML::kGreen;
1309	string col2 = HTML::kGreen;
1310	string col3 = HTML::kGreen;
1311	string col4 = HTML::kGreen;
1312
1313	if (stat.min>90)
1314	col1 = HTML::kYellow;
1315	if (stat.min>110)
1316	col1 = HTML::kRed;
1317
1318	if (stat.med>90)
1319	col2 = HTML::kYellow;
1320	if (stat.med>110)
1321	col2 = HTML::kRed;
1322
1323	if (stat.avg>90)
1324	col3 = HTML::kYellow;
1325	if (stat.avg>110)
1326	col3 = HTML::kRed;
1327
1328	if (stat.max>90)
1329	col4 = HTML::kYellow;
1330	if (stat.max>110)
1331	col4 = HTML::kRed;
1332
1333	ostringstream out;
1334	out << setprecision(3);
1335	out << d.GetJavaDate() << '\n';
1336	out << HTML::kGreen << '\t' << "yes" << '\n';
1337	out << col1 << '\t' << stat.min << '\n';
1338	out << col2 << '\t' << stat.med << '\n';
1339	out << col3 << '\t' << stat.avg << '\n';
1340	out << col4 << '\t' << stat.max << '\n';
1341	out << HTML::kWhite << '\t' << power_tot << "W [" << power_apd << "mW]\n";
1342	ofstream(fPath+"/current.data") << out.str();
1343
1344	// --------------------------------------------------------
1345
1346	const float Unom = ptr[2*416+6];
1347	const float Utmp = ptr[2*416+7];
1348
1349	vector<float> Uov(ptr+416+6, ptr+416+6+320);
1350
1351	WriteCam(d, "cam-feedback-overvoltage", Uov, 0.2, -0.1);
1352
1353	const Statistics stat2(Uov);
1354
1355	out.str("");
1356	out << d.GetJavaDate() << '\n';
1357	out << setprecision(3);
1358	out << HTML::kWhite << '\t' << Utmp << '\n';
1359	out << HTML::kWhite << '\t' << Unom << '\n';
1360	out << HTML::kWhite << '\t' << stat2.min << '\n';
1361	out << HTML::kWhite << '\t' << stat2.med << '\n';
1362	out << HTML::kWhite << '\t' << stat2.avg << '\n';
1363	out << HTML::kWhite << '\t' << stat2.max << '\n';
1364	ofstream(fPath+"/feedback.data") << out.str();
1365
1366	return GetCurrentState();
1367	}
1368
1369	int HandleBiasCurrent(const EventImp &d)
1370	{
1371	if (fDimFeedback.state()>=Feedback::State::kCalibrated)
1372	return GetCurrentState();
1373
1374	if (!CheckDataSize(d, "BiasControl:Current", 832))
1375	return GetCurrentState();
1376
1377	// Convert dac counts to uA
1378	vector<float> v(320);
1379	for (int i=0; i<320; i++)
1380	v[i] = d.Ptr<uint16_t>()[i] * 5000./4096;
1381
1382	fBiasControlPowerTot = 0;
1383
1384	// Get the maximum of each patch
1385	vector<float> val(320, 0);
1386	for (int i=0; i<320; i++)
1387	{
1388	const PixelMapEntry &hv = fPixelMap.hv(i);
1389	if (!hv)
1390	continue;
1391
1392	const int idx = (hv.hw()/9)*2+hv.group();
1393	val[idx] = v[i];
1394	}
1395
1396	// Write the 160 patch values to a file
1397	WriteCam(d, "cam-biascontrol-current", val, 1000);
1398
1399	const Statistics stat(v, 0, 3);
1400
1401	// Exclude the three crazy channels
1402	fBiasControlCurrentMed = stat.med;
1403	fBiasControlCurrentMax = stat.max;
1404
1405	// Store a history of the last 60 entries
1406	fBiasControlCurrentHist.push_back(fBiasControlCurrentMed);
1407	if (fBiasControlCurrentHist.size()>360)
1408	fBiasControlCurrentHist.pop_front();
1409
1410	// write the history to a file
1411	WriteHist(d, "hist-biascontrol-current", fBiasControlCurrentHist, 1000);
1412
1413	ostringstream out;
1414	out << setprecision(3);
1415	out << d.GetJavaDate() << '\n';
1416	out << HTML::kWhite<< '\t' << "no" << '\n';
1417	out << HTML::kWhite << '\t' << stat.min << '\n';
1418	out << HTML::kWhite << '\t' << stat.med << '\n';
1419	out << HTML::kWhite << '\t' << stat.avg << '\n';
1420	out << HTML::kWhite << '\t' << stat.max << '\n';
1421	out << HTML::kWhite << '\t' << "---\n";
1422	ofstream(fPath+"/current.data") << out.str();
1423
1424	return GetCurrentState();
1425	}
1426
1427	int HandleBiasVoltage(const EventImp &d)
1428	{
1429	if (!CheckDataSize(d, "BiasControl:Voltage", 1664))
1430	{
1431	fBiasControlVoltageVec.clear();
1432	return GetCurrentState();
1433	}
1434
1435	fBiasControlVoltageVec.assign(d.Ptr<float>(), d.Ptr<float>()+320);
1436
1437	const Statistics stat(fBiasControlVoltageVec);
1438
1439	fBiasControlVoltageMed = stat.med;
1440
1441	vector<float> val(320, 0);
1442	for (int i=0; i<320; i++)
1443	{
1444	const int idx = (fPixelMap.hv(i).hw()/9)*2+fPixelMap.hv(i).group();
1445	val[idx] = fBiasControlVoltageVec[i];
1446	}
1447
1448	if (fDimBiasControl.state()==BIAS::State::kVoltageOn \|\| fDimBiasControl.state()==BIAS::State::kRamping)
1449	WriteCam(d, "cam-biascontrol-voltage", val, 10, 65);
1450	else
1451	WriteCam(d, "cam-biascontrol-voltage", val, 75);
1452
1453	ostringstream out;
1454	out << setprecision(3);
1455	out << d.GetJavaDate() << '\n';
1456	out << HTML::kWhite << '\t' << stat.min << '\n';
1457	out << HTML::kWhite << '\t' << stat.med << '\n';
1458	out << HTML::kWhite << '\t' << stat.avg << '\n';
1459	out << HTML::kWhite << '\t' << stat.max << '\n';
1460	ofstream(fPath+"/voltage.data") << out.str();
1461
1462	return GetCurrentState();
1463	}
1464
1465	int HandleFadEvents(const EventImp &d)
1466	{
1467	if (!CheckDataSize(d, "FadControl:Events", 4*4))
1468	{
1469	fFadControlNumEvents = -1;
1470	return GetCurrentState();
1471	}
1472
1473	fFadControlNumEvents = d.Get<uint32_t>();
1474
1475	return GetCurrentState();
1476	}
1477
1478	int HandleFadStartRun(const EventImp &d)
1479	{
1480	if (!CheckDataSize(d, "FadControl:StartRun", 16))
1481	{
1482	fFadControlStartRun = -1;
1483	return GetCurrentState();
1484	}
1485
1486	fFadControlStartRun = d.Get<int64_t>();
1487
1488	return GetCurrentState();
1489	}
1490
1491	int HandleFadDrsRuns(const EventImp &d)
1492	{
1493	if (!CheckDataSize(d, "FadControl:DrsRuns", 5*4))
1494	{
1495	fFadControlDrsStep = -1;
1496	return GetCurrentState();
1497	}
1498
1499	const uint32_t *ptr = d.Ptr<uint32_t>();
1500	fFadControlDrsStep = ptr[0];
1501	fFadControlDrsRuns[0] = ptr[1];
1502	fFadControlDrsRuns[1] = ptr[2];
1503	fFadControlDrsRuns[2] = ptr[3];
1504
1505	return GetCurrentState();
1506	}
1507
1508	int HandleFadConnections(const EventImp &d)
1509	{
1510	if (!CheckDataSize(d, "FadControl:Connections", 41))
1511	{
1512	//fStatusEventBuilderLabel->setText("Offline");
1513	return GetCurrentState();
1514	}
1515
1516	string rc(40, '-'); // orange/red [45]
1517
1518	const uint8_t *ptr = d.Ptr<uint8_t>();
1519
1520	int c[4] = { '.', '.', '.', '.' };
1521
1522	for (int i=0; i<40; i++)
1523	{
1524	const uint8_t stat1 = ptr[i]&3;
1525	const uint8_t stat2 = ptr[i]>>3;
1526
1527	if (stat1==0 && stat2==0)
1528	rc[i] = '.'; // gray [46]
1529	else
1530	if (stat1>=2 && stat2==8)
1531	rc[i] = stat1==2?'+':'*'; // green [43] : check [42]
1532
1533	if (rc[i]<c[i/10])
1534	c[i/10] = rc[i];
1535	}
1536
1537	string col[4];
1538	for (int i=0; i<4; i++)
1539	switch (c[i])
1540	{
1541	case '.': col[i]=HTML::kWhite; break;
1542	case '-': col[i]=HTML::kRed; break;
1543	case '+': col[i]=HTML::kYellow; break;
1544	case '*': col[i]=HTML::kGreen; break;
1545	}
1546
1547	ostringstream out;
1548	out << setprecision(3);
1549	out << d.GetJavaDate() << '\n';
1550	out << col[0] << '\t' << rc.substr( 0, 10) << '\n';
1551	out << col[1] << '\t' << rc.substr(10, 10) << '\n';
1552	out << col[2] << '\t' << rc.substr(20, 10) << '\n';
1553	out << col[3] << '\t' << rc.substr(30, 10) << '\n';
1554	ofstream(fPath+"/fad.data") << out.str();
1555
1556	return GetCurrentState();
1557	}
1558
1559	/*
1560	int HandleFtmControlStateChange()
1561	{
1562	const int32_t &last = fDimFtmControl.last.second;
1563	const int32_t &state = fDimFtmControl.state();
1564
1565	// If a new run has been started ensure that the counter
1566	// is reset. The reset in HandleFtmTriggerRates might
1567	// arrive only after the run was started.
1568	if (last!=FTM::State::kTriggerOn && state==MCP::State::kTriggerOn)
1569	fFtmControlTriggerRateTooLow = -1;
1570
1571	return StateMachineImp::kSM_KeepState;
1572	}*/
1573
1574
1575	int HandleFtmTriggerRates(const EventImp &d)
1576	{
1577	if (!CheckDataSize(d, "FtmControl:TriggerRates", 24+160+640+8))
1578	{
1579	fFtmControlTriggerRateTooLow = 0;
1580	return GetCurrentState();
1581	}
1582
1583	const FTM::DimTriggerRates &dim = d.Ref<FTM::DimTriggerRates>();
1584
1585	// If the trigger rate is too low...
1586	// ... and the run was not just started (can lead to very small elapsed times)
1587	// ... and the trigger is switched on
1588	// ... and there was no state change (then the trigger was started or stopped)
1589	fFtmControlTriggerRateTooLow =
1590	dim.fTriggerRate<1 && dim.fElapsedTime>0.45 &&
1591	(fFtmControlState&FTM::kFtmStates)==FTM::kFtmRunning &&
1592	(fFtmControlState&FTM::kFtmStates)==(d.GetQoS()&FTM::kFtmStates);
1593
1594	fFtmControlState = d.GetQoS();
1595
1596	const float *brates = dim.fBoardRate; // Board rate
1597	const float *prates = dim.fPatchRate; // Patch rate
1598
1599	// Store a history of the last 60 entries
1600	fFtmControlTriggerRateHist.push_back(dim.fTriggerRate);
1601	if (fFtmControlTriggerRateHist.size()>300)
1602	fFtmControlTriggerRateHist.pop_front();
1603
1604	// FIXME: Add statistics for all kind of rates
1605
1606	WriteHist(d, "hist-ftmcontrol-triggerrate",
1607	fFtmControlTriggerRateHist, 100);
1608	WriteCam(d, "cam-ftmcontrol-boardrates",
1609	vector<float>(brates, brates+40), 10);
1610	WriteCam(d, "cam-ftmcontrol-patchrates",
1611	vector<float>(prates, prates+160), 10);
1612
1613	ostringstream out;
1614	out << setprecision(3);
1615	out << d.GetJavaDate() << '\n';
1616	out << HTML::kWhite << '\t' << dim.fTriggerRate << '\n';
1617
1618	ofstream(fPath+"/trigger.data") << out.str();
1619
1620	const Statistics bstat(vector<float>(brates, brates+ 40));
1621	const Statistics pstat(vector<float>(prates, prates+160));
1622
1623	out.str("");
1624	out << d.GetJavaDate() << '\n';
1625	out << HTML::kWhite << '\t' << bstat.min << '\n';
1626	out << HTML::kWhite << '\t' << bstat.med << '\n';
1627	out << HTML::kWhite << '\t' << bstat.avg << '\n';
1628	out << HTML::kWhite << '\t' << bstat.max << '\n';
1629	ofstream(fPath+"/boardrates.data") << out.str();
1630
1631	out.str("");
1632	out << d.GetJavaDate() << '\n';
1633	out << HTML::kWhite << '\t' << pstat.min << '\n';
1634	out << HTML::kWhite << '\t' << pstat.med << '\n';
1635	out << HTML::kWhite << '\t' << pstat.avg << '\n';
1636	out << HTML::kWhite << '\t' << pstat.max << '\n';
1637	ofstream(fPath+"/patchrates.data") << out.str();
1638
1639	return GetCurrentState();
1640	}
1641
1642	int HandleFtmStaticData(const EventImp &d)
1643	{
1644	if (!CheckDataSize(d, "FtmControl:StaticData", sizeof(FTM::DimStaticData)))
1645	return GetCurrentState();
1646
1647	// If the FTM is in state Configuring, the clock conditioner
1648	// is always reported to be unlocked
1649	fFtmControlState = d.GetQoS();
1650
1651	const FTM::DimStaticData &dat = d.Ref<FTM::DimStaticData>();
1652
1653	vector<uint16_t> vecp(dat.fThreshold, dat.fThreshold+160);
1654	vector<uint16_t> vecb(dat.fMultiplicity, dat.fMultiplicity+40);
1655
1656	WriteCam(d, "cam-ftmcontrol-thresholds-patch", vecp, 1000);
1657	WriteCam(d, "cam-ftmcontrol-thresholds-board", vecb, 100);
1658
1659	const Statistics statp(vecp);
1660	const Statistics statb(vecb);
1661
1662	fFtmPatchThresholdMed = statp.med;
1663	fFtmBoardThresholdMed = statb.med;
1664
1665	ostringstream out;
1666	out << d.GetJavaDate() << '\n';
1667	out << HTML::kWhite << '\t' << statb.min << '\n';
1668	out << HTML::kWhite << '\t' << statb.med << '\n';
1669	out << HTML::kWhite << '\t' << statb.max << '\n';
1670	ofstream(fPath+"/thresholds-board.data") << out.str();
1671
1672	out.str("");
1673	out << d.GetJavaDate() << '\n';
1674	out << HTML::kWhite << '\t' << statp.min << '\n';
1675	out << HTML::kWhite << '\t' << statp.med << '\n';
1676	out << HTML::kWhite << '\t' << statp.max << '\n';
1677	ofstream(fPath+"/thresholds-patch.data") << out.str();
1678
1679	out.str("");
1680	out << d.GetJavaDate() << '\n';
1681	out << HTML::kWhite << '\t' << statb.med << '\n';
1682	out << HTML::kWhite << '\t' << statp.med << '\n';
1683	ofstream(fPath+"/thresholds.data") << out.str();
1684
1685	out.str("");
1686	out << d.GetJavaDate() << '\n';
1687	out << HTML::kWhite << '\t' << dat.fTriggerInterval << '\n';
1688	out << HTML::kWhite << '\t';
1689	if (dat.HasPedestal())
1690	out << dat.fTriggerSeqPed;
1691	else
1692	out << "–";
1693	out << ':';
1694	if (dat.HasLPext())
1695	out << dat.fTriggerSeqLPext;
1696	else
1697	out << "–";
1698	out << ':';
1699	if (dat.HasLPint())
1700	out << dat.fTriggerSeqLPint;
1701	else
1702	out << "–";
1703	out << '\n';
1704
1705	out << HTML::kWhite << '\t' << (dat.HasTrigger()?"on":"off") << " / " << (dat.HasExt1()?"on":"off") << " / " << (dat.HasExt2()?"on":"off") << '\n';
1706	out << HTML::kWhite << '\t' << (dat.HasVeto()?"on":"off") << " / " << (dat.HasClockConditioner()?"time cal":"marker") << '\n';
1707	out << HTML::kWhite << '\t' << dat.fMultiplicityPhysics << " / " << dat.fMultiplicityCalib << '\n';
1708	out << HTML::kWhite << '\t' << dat.fWindowPhysics << '\t' << dat.fWindowCalib << '\n';
1709	out << HTML::kWhite << '\t' << dat.fDelayTrigger << '\t' << dat.fDelayTimeMarker << '\n';
1710	out << HTML::kWhite << '\t' << dat.fDeadTime << '\n';
1711
1712	int64_t vp = dat.fPrescaling[0];
1713	for (int i=1; i<40; i++)
1714	if (vp!=dat.fPrescaling[i])
1715	vp = -1;
1716
1717	if (vp<0)
1718	out << HTML::kYellow << "\tdifferent\n";
1719	else
1720	out << HTML::kWhite << '\t' << 0.5*vp << "\n";
1721
1722	ofstream(fPath+"/ftm.data") << out.str();
1723
1724	// Active FTUs: IsActive(i)
1725	// Enabled Pix: IsEnabled(i)
1726
1727	return GetCurrentState();
1728	}
1729
1730	int HandleFtmFtuList(const EventImp &d)
1731	{
1732	if (!CheckDataSize(d, "FtmControl:FtuList", sizeof(FTM::DimFtuList)))
1733	return GetCurrentState();
1734
1735	const FTM::DimFtuList &sdata = d.Ref<FTM::DimFtuList>();
1736
1737	ostringstream out;
1738	out << d.GetJavaDate() << '\n';
1739
1740	int cnt = 0;
1741	for (int i=0; i<4; i++)
1742	{
1743	out << HTML::kWhite << '\t';
1744	for (int j=0; j<10; j++)
1745	if (sdata.IsActive(i*10+j))
1746	{
1747	if (sdata.fPing[i*10+j]==1)
1748	{
1749	out << '*';
1750	cnt++;
1751	}
1752	else
1753	out << sdata.fPing[i*10+j];
1754	}
1755	else
1756	out << '-';
1757	out << '\n';
1758	}
1759
1760	fFtmControlFtuOk = cnt==40;
1761
1762	ofstream(fPath+"/ftu.data") << out.str();
1763
1764	return GetCurrentState();
1765	}
1766
1767	int HandleFadEventData(const EventImp &d)
1768	{
1769	if (!CheckDataSize(d, "FadControl:EventData", 23048))
1770	return GetCurrentState();
1771
1772	//const uint32_t run = d.GetUint();
1773	//const uint32_t evt = d.GetUint(4);
1774
1775	const float dat = d.Ptr<float>(8+1440sizeof(float)*2);
1776
1777	/*
1778	vector<float> max(320, 0);
1779	for (int i=0; i<1440; i++)
1780	{
1781	if (i%9==8)
1782	continue;
1783
1784	const int idx = (fPixelMap.hw(i).hw()/9)*2+fPixelMap.hw(i).group();
1785	const double v = dat[i]/1000;
1786	//if (v>max[idx])
1787	// max[idx]=v;
1788
1789	max[idx] += v/4;
1790	} */
1791
1792	vector<float> val(1440);
1793	for (int i=0; i<1440; i++)
1794	val[i] = dat[i%9==8 ? i-2 : i]/1000;
1795
1796	vector<float> sorted(val);
1797	nth_element(sorted.begin(), sorted.begin()+3, sorted.end(),
1798	std::greater<float>());
1799
1800	const uint32_t trig = d.GetQoS() & FAD::EventHeader::kLPext;
1801
1802	const float min = fFadControlDrsRuns[0]==0 ? -1 : 0;
1803
1804	float scale = 2;
1805	if (trig&FAD::EventHeader::kLPext)
1806	scale = 1;
1807	if (trig&FAD::EventHeader::kPedestal)
1808	scale = 0.25;
1809	if (trig==0)
1810	scale = max(0.25f, sorted[3]);
1811
1812	// assume it is drs-gain
1813	//if ((trig&FAD::EventHeader::kPedestal) && fFadControlDrsRuns[0]>0 && fFadControlDrsRuns[1]==0)
1814	// min = 0.75;
1815
1816	WriteCam(d, "cam-fadcontrol-eventdata", val, scale, min);
1817
1818	return GetCurrentState();
1819	}
1820
1821	int HandleStats(const EventImp &d)
1822	{
1823	if (!CheckDataSize(d, "Stats", 4*8))
1824	{
1825	fFreeSpace = UINT64_MAX;
1826	return GetCurrentState();
1827	}
1828
1829	const DimWriteStatistics::Stats &s = d.Ref<DimWriteStatistics::Stats>();
1830	fFreeSpace = s.freeSpace;
1831
1832	return GetCurrentState();
1833	}
1834
1835	int HandleFscTemperature(const EventImp &d)
1836	{
1837	if (!CheckDataSize(d, "FscControl:Temperature", 240))
1838	return GetCurrentState();
1839
1840	const float *ptr = d.Ptr<float>(4);
1841
1842	double avg = 0;
1843	double rms = 0;
1844	double min = 99;
1845	double max = -99;
1846
1847	int num = 0;
1848	for (const float *t=ptr; t<ptr+31; t++)
1849	{
1850	if (*t==0)
1851	continue;
1852
1853	if (*t>max)
1854	max = *t;
1855
1856	if (*t<min)
1857	min = *t;
1858
1859	avg += *t;
1860	rms += t *t;
1861
1862	num++;
1863	}
1864
1865	avg /= num;
1866	rms /= num;
1867	rms += avg*avg;
1868	rms = rms<0 ? 0 : sqrt(rms);
1869
1870	// Clean broken reports
1871	static double pre_rms1 = 1.5;
1872	static double pre_rms2 = 0;
1873
1874	const double cut = pre_rms1 + 0.1;
1875
1876	const bool reject = rms>cut && pre_rms2<cut;
1877
1878	pre_rms2 = pre_rms1;
1879	pre_rms1 = rms;
1880
1881	if (reject)
1882	return GetCurrentState();
1883
1884
1885	if (!fMagicWeatherHist[kTemp].empty())
1886	{
1887	fFscControlTemperatureHist.push_back(avg-fMagicWeatherHist[kTemp].back());
1888	if (fFscControlTemperatureHist.size()>300)
1889	fFscControlTemperatureHist.pop_front();
1890	}
1891
1892	const Statistics stat(fFscControlTemperatureHist);
1893
1894	ostringstream out;
1895	out << setprecision(3);
1896	out << d.GetJavaDate() << '\n';
1897	out << HTML::kWhite << '\t' << fFscControlHumidityAvg << '\n';
1898	out << HTML::kWhite << '\t' << stat.min << '\n';
1899	out << HTML::kWhite << '\t' << stat.avg << '\n';
1900	out << HTML::kWhite << '\t' << stat.max << '\n';
1901
1902	ofstream(fPath+"/fsc.data") << out.str();
1903
1904	WriteHist(d, "hist-fsccontrol-temperature",
1905	fFscControlTemperatureHist, 10);
1906
1907	out.str("");
1908	out << setprecision(3);
1909	out << d.GetJavaDate() << '\n';
1910	out << HTML::kWhite << '\t' << max << '\n';
1911	out << HTML::kWhite << '\t' << avg << '\n';
1912	out << HTML::kWhite << '\t' << min << '\n';
1913
1914	ofstream(fPath+"/camtemp.data") << out.str();
1915
1916	return GetCurrentState();
1917	}
1918
1919	int HandleFscBiasTemp(const EventImp &d)
1920	{
1921	if (!CheckDataSize(d, "FscControl:BiasTemp", 323*4))
1922	return GetCurrentState();
1923
1924	const float *ptr = d.Ptr<float>(4);
1925	const float avg = d.Get<float>(321*4);
1926	//const float rms = d.Get<float>(322*4);
1927
1928	vector<double> tout(320);
1929	for (int i=0; i<320; i++)
1930	{
1931	const int idx = (fPixelMap.hv(i).hw()/9)*2+fPixelMap.hv(i).group();
1932	tout[idx] = ptr[i];
1933	}
1934
1935	WriteCam(d, "cam-fsccontrol-temperature", tout, 3, avg-1.75);
1936
1937	return GetCurrentState();
1938	}
1939
1940	int HandleFscHumidity(const EventImp &d)
1941	{
1942	if (!CheckDataSize(d, "FscControl:Humidity", 5*4))
1943	return GetCurrentState();
1944
1945	const float *ptr = d.Ptr<float>(4);
1946
1947	double avg =0;
1948	int num = 0;
1949
1950	for (const float *t=ptr; t<ptr+4; t++)
1951	if (t>0 && t<=100 && t!=ptr+2 /excl broken sensor/)
1952	{
1953	avg += *t;
1954	num++;
1955	}
1956
1957	fFscControlHumidityAvg = num>0 ? avg/num : 0;
1958
1959	return GetCurrentState();
1960	}
1961
1962	int HandlePfMiniData(const EventImp &d)
1963	{
1964	if (!CheckDataSize(d, "PfMini:Data", sizeof(PFmini::Data)))
1965	return GetCurrentState();
1966
1967	const PFmini::Data &data = d.Ref<PFmini::Data>();
1968
1969	ostringstream out;
1970
1971	out << fixed << setprecision(1);
1972	out << d.GetJavaDate() << '\n';
1973
1974	out << HTML::kGreen << '\t' << data.temp << '\n';
1975	out << HTML::kGreen << '\t' << data.hum << '\n';
1976
1977	ofstream(fPath+"/pfmini.data") << out.str();
1978
1979	fPfMiniTemperatureHist.push_back(data.temp);
1980	if (fPfMiniTemperatureHist.size()>60*4) // 1h
1981	fPfMiniTemperatureHist.pop_front();
1982
1983	fPfMiniHumidityHist.push_back(data.hum);
1984	if (fPfMiniHumidityHist.size()>60*4) // 1h
1985	fPfMiniHumidityHist.pop_front();
1986
1987	WriteHist(d, "hist-pfmini-temp",
1988	fPfMiniTemperatureHist, 45, 0);
1989
1990	WriteHist(d, "hist-pfmini-hum",
1991	fPfMiniHumidityHist, 100, 0);
1992
1993	return GetCurrentState();
1994	}
1995
1996	int HandleBiasTemp(const EventImp &d)
1997	{
1998	if (!CheckDataSize(d, "BiasTemp:Data", sizeof(BiasTemp::Data)))
1999	return GetCurrentState();
2000
2001	const BiasTemp::Data &data = d.Ref<BiasTemp::Data>();
2002
2003	ostringstream out;
2004
2005	out << fixed << setprecision(1);
2006	out << d.GetJavaDate() << '\n';
2007
2008	out << HTML::kGreen << '\t' << data.time << '\n';
2009	out << HTML::kGreen << '\t' << data.avg << '\n';
2010	out << HTML::kGreen << '\t' << data.rms << '\n';
2011
2012	ofstream(fPath+"/biastemp.data") << out.str();
2013
2014	return GetCurrentState();
2015	}
2016
2017	int HandleGpsNema(const EventImp &d)
2018	{
2019	if (!CheckDataSize(d, "GpsControl:Nema", sizeof(GPS::NEMA)))
2020	return GetCurrentState();
2021
2022	const GPS::NEMA &nema = d.Ref<GPS::NEMA>();
2023
2024	ostringstream out;
2025
2026	out << fixed;
2027	out << d.GetJavaDate() << '\n';
2028
2029	switch (nema.qos)
2030	{
2031	case 1: out << HTML::kGreen << "\tGPS fix [1]\n"; break;
2032	case 2: out << HTML::kGreen << "\tDifferential fix [2]\n"; break;
2033	default: out << HTML::kRed << "\tinvalid [" << nema.qos << "]\n"; break;
2034	}
2035
2036	out << HTML::kWhite << '\t' << nema.count << '\n';
2037	out << HTML::kWhite << '\t' << Time(floor(Time().Mjd())+nema.time).GetAsStr("%H:%M:%S") << '\n';
2038	out << HTML::kWhite << '\t' << setprecision(4) << nema.lat << '\n';
2039	out << HTML::kWhite << '\t' << setprecision(4) << nema.lng << '\n';
2040	out << HTML::kWhite << '\t' << setprecision(1) << nema.height << "\n";
2041	out << HTML::kWhite << '\t' << setprecision(1) << nema.hdop << "\n";
2042	out << HTML::kWhite << '\t' << setprecision(1) << nema.geosep << "\n";
2043
2044	ofstream(fPath+"/gps.data") << out.str();
2045
2046	return GetCurrentState();
2047	}
2048
2049	int HandleSqmData(const EventImp &d)
2050	{
2051	if (!CheckDataSize(d, "SqmControl:Data", sizeof(SQM::Data)))
2052	return GetCurrentState();
2053
2054	const SQM::Data &data = d.Ref<SQM::Data>();
2055
2056	ostringstream out;
2057
2058	out << fixed;
2059	out << d.GetJavaDate() << '\n';
2060	out << HTML::kWhite << '\t' << setprecision(2) << data.mag << '\n';
2061	out << HTML::kWhite << '\t' << data.freq << '\n';
2062	out << HTML::kWhite << '\t' << data.counts << '\n';
2063	out << HTML::kWhite << '\t' << setprecision(3) << data.period << '\n';
2064	out << HTML::kWhite << '\t' << setprecision(1) << data.temp << "\n";
2065
2066	ofstream(fPath+"/sqm.data") << out.str();
2067
2068	return GetCurrentState();
2069	}
2070
2071	string GetTempColor(float t)
2072	{
2073	if (t>25 && t<30)
2074	return HTML::kGreen;
2075
2076	if (t<20 \|\| t>35)
2077	return HTML::kRed;
2078
2079	return HTML::kYellow;
2080	}
2081
2082	int HandleTemperatureData(const EventImp &d)
2083	{
2084	if (!CheckDataSize(d, "Temperature:Data", 3*sizeof(float)))
2085	return GetCurrentState();
2086
2087	const float *temp = d.Ptr<float>();
2088
2089	ostringstream out;
2090
2091	out << fixed << setprecision(1);
2092	out << d.GetJavaDate() << '\n';
2093
2094	out << GetTempColor(temp[1]) << '\t' << temp[1] << '\n';
2095	out << GetTempColor(temp[0]) << '\t' << temp[0] << '\n';
2096	out << GetTempColor(temp[2]) << '\t' << temp[2] << '\n';
2097
2098	ofstream(fPath+"/temperature.data") << out.str();
2099
2100	fTemperatureControlHist.push_back(temp[0]);
2101	if (fTemperatureControlHist.size()>60) // 1h
2102	fTemperatureControlHist.pop_front();
2103
2104	WriteHist(d, "hist-temperaturecontrol",
2105	fTemperatureControlHist, 45, 0);
2106
2107	return GetCurrentState();
2108	}
2109
2110	int HandleAgilentData(const EventImp &d, const string &ext)
2111	{
2112	if (!CheckDataSize(d, ("Agilent"+ext+":Data").c_str(), 4*sizeof(float)))
2113	return GetCurrentState();
2114
2115	const float *data = d.Ptr<float>();
2116
2117	ostringstream out;
2118
2119	out << fixed << setprecision(1);
2120	out << d.GetJavaDate() << '\n';
2121
2122	out << HTML::kWhite << '\t' << data[0] << '\n';
2123	out << HTML::kWhite << '\t' << data[1] << '\n';
2124	out << HTML::kWhite << '\t' << data[2] << '\n';
2125	out << HTML::kWhite << '\t' << data[3] << '\n';
2126
2127	ofstream(fPath+"/agilent"+ext+".data") << out.str();
2128
2129	return GetCurrentState();
2130	}
2131
2132	int HandleRateScanData(const EventImp &d)
2133	{
2134	if (!CheckDataSize(d, "RateScan:Data", 824))
2135	return GetCurrentState();
2136
2137	const uint64_t id = d.Get<uint64_t>();
2138	const float *rate = d.Ptr<float>(20);
2139
2140	if (fRateScanDataId!=id)
2141	{
2142	for (int i=0; i<41; i++)
2143	fRateScanDataHist[i].clear();
2144	fRateScanDataId = id;
2145	}
2146	fRateScanDataHist[0].push_back(log10(rate[0]));
2147
2148	double max = 0;
2149	for (int i=1; i<41; i++)
2150	{
2151	fRateScanDataHist[i].push_back(log10(rate[i]));
2152	if (rate[i]>max)
2153	max = rate[i];
2154	}
2155
2156	// Cycle by time!
2157	fRateScanBoard ++;
2158	fRateScanBoard %= 40;
2159
2160	WriteHist(d, "hist-ratescan", fRateScanDataHist[0], 10, -2);
2161	WriteCam(d, "cam-ratescan-board", fRateScanDataHist[fRateScanBoard+1], 10, -4);
2162
2163	ostringstream out;
2164	out << setprecision(3);
2165	out << d.GetJavaDate() << '\n';
2166	out << HTML::kWhite << '\t' << fFtmBoardThresholdMed << '\n';
2167	out << HTML::kWhite << '\t' << fFtmPatchThresholdMed << '\n';
2168	out << HTML::kWhite << '\t' << floor(pow(10, fRateScanDataHist[0].back())+.5) << '\n';
2169	out << HTML::kWhite << '\t' << floor(max+.5) << '\n';
2170
2171	ofstream(fPath+"/ratescan.data") << out.str();
2172
2173	out.str("");
2174	out << d.GetJavaDate() << '\n';
2175	out << HTML::kWhite << '\t' << int(fRateScanBoard) << '\n';
2176	out << HTML::kWhite << '\t' << pow(10, fRateScanDataHist[fRateScanBoard+1].back()) << '\n';
2177
2178	ofstream(fPath+"/ratescan_board.data") << out.str();
2179
2180	return GetCurrentState();
2181	}
2182
2183	int HandleRateControlThreshold(const EventImp &d)
2184	{
2185	if (!CheckDataSize(d, "RateControl:Threshold", 18))
2186	return GetCurrentState();
2187
2188	const uint16_t th = d.Get<uint16_t>();
2189
2190	fRateControlThreshold.push_back(th);
2191	if (fRateControlThreshold.size()>300)
2192	fRateControlThreshold.pop_front();
2193
2194	WriteHist(d, "hist-ratecontrol-threshold", fRateControlThreshold, 1000);
2195
2196	return GetCurrentState();
2197	}
2198
2199	int HandleChatMsg(const EventImp &d)
2200	{
2201	if (d.GetSize()==0 \|\| d.GetQoS()!=MessageImp::kComment)
2202	return GetCurrentState();
2203
2204	if (Time()<d.GetTime()+boost::posix_time::minutes(1))
2205	SetAudio("message");
2206
2207	fChatHist.add(d.GetText(), d.GetTime());
2208
2209	ostringstream out;
2210	out << setprecision(3);
2211	out << Header(d) << '\n';
2212	out << HTML::kWhite << '\t';
2213	out << "<->" << fChatHist.rget() << "</->";
2214	out << '\n';
2215
2216	ofstream(fPath+"/chat.data") << out.str();
2217
2218	return GetCurrentState();
2219	}
2220
2221	// -------------------------------------------------------------------
2222
2223	int HandleDoTest(const EventImp &d)
2224	{
2225	ostringstream out;
2226	out << d.GetJavaDate() << '\n';
2227
2228	switch (d.GetQoS())
2229	{
2230	case -3: out << HTML::kWhite << "\tNot running\n"; break;
2231	case -2: out << HTML::kBlue << "\tLoading\n"; break;
2232	case -1: out << HTML::kBlue << "\tStarted\n"; break;
2233	default: out << HTML::kGreen << "\tRunning [" << d.GetQoS() << "]\n"; break;
2234	}
2235
2236	ofstream(fPath+"/dotest.data") << out.str();
2237
2238	return StateMachineImp::kSM_KeepState;
2239	}
2240
2241	// -------------------------------------------------------------------
2242
2243	/*
2244	bool CheckEventSize(size_t has, const char *name, size_t size)
2245	{
2246	if (has==size)
2247	return true;
2248
2249	ostringstream msg;
2250	msg << name << " - Received event has " << has << " bytes, but expected " << size << ".";
2251	Fatal(msg);
2252	return false;
2253	}*/
2254
2255	int Print() const
2256	{
2257	Out() << fDimDNS << endl;
2258	Out() << fDimMcp << endl;
2259	Out() << fDimControl << endl;
2260	Out() << fDimDataLogger << endl;
2261	Out() << fDimDriveControl << endl;
2262	Out() << fDimTimeCheck << endl;
2263	Out() << fDimFadControl << endl;
2264	Out() << fDimFtmControl << endl;
2265	Out() << fDimBiasControl << endl;
2266	Out() << fDimFeedback << endl;
2267	Out() << fDimRateControl << endl;
2268	Out() << fDimFscControl << endl;
2269	Out() << fDimAgilentControl24 << endl;
2270	Out() << fDimAgilentControl50 << endl;
2271	Out() << fDimAgilentControl80 << endl;
2272	Out() << fDimPwrControl << endl;
2273	Out() << fDimLidControl << endl;
2274	Out() << fDimMagicWeather << endl;
2275	Out() << fDimTngWeather << endl;
2276	Out() << fDimMagicLidar << endl;
2277	Out() << fDimTemperature << endl;
2278	Out() << fDimRainSensor << endl;
2279	Out() << fDimRateScan << endl;
2280	Out() << fDimChat << endl;
2281	Out() << fDimSkypeClient << endl;
2282
2283	return GetCurrentState();
2284	}
2285
2286	string GetStateHtml(const DimState &state, int green) const
2287	{
2288	if (!state.online())
2289	return HTML::kWhite+"\t—\n";
2290
2291	if (&state==&fDimControl)
2292	return HTML::kGreen +'\t'+(state.state()==0?"Idle":fDimControl.shortmsg)+'\n';
2293
2294	const State rc = state.description();
2295
2296	// Sate not found in list, server online (-3: offline; -2: not found)
2297	if (rc.index==-2)
2298	{
2299	ostringstream out;
2300	out << HTML::kWhite << '\t' << state.state() << '\n';
2301	return out.str();
2302	}
2303
2304	//ostringstream msg;
2305	//msg << HTML::kWhite << '\t' << rc.name << " [" << rc.index << "]\n";
2306	//return msg.str();
2307
2308	if (rc.index<0)
2309	return HTML::kWhite + "\t—\n";
2310
2311	string col = HTML::kGreen;
2312	if (rc.index<green)
2313	col = HTML::kYellow;
2314	if (rc.index>0xff)
2315	col = HTML::kRed;
2316
2317	return col + '\t' + rc.name + '\n';
2318	}
2319
2320	bool SetError(bool b, const string &err)
2321	{
2322	if (!b)
2323	{
2324	fErrorList.erase(err);
2325	return 0;
2326	}
2327
2328	const bool isnew = fErrorList.insert(err).second;
2329	if (isnew)
2330	fErrorHist.add(err);
2331
2332	return isnew;
2333	}
2334
2335	#ifdef HAVE_NOVA
2336
2337	//vector<pair<Nova::EquPosn, double>> fMoonCoords;
2338
2339	vector<Nova::SolarObjects> fCoordinates;
2340
2341	void CalcCoordinates(double jd)
2342	{
2343	jd = floor(jd);
2344
2345	fCoordinates.clear();
2346	for (double h=0; h<1; h+=1./(24*12))
2347	fCoordinates.emplace_back(jd+h);
2348	}
2349
2350	pair<vector<float>, pair<Time, float>> GetVisibility(Nova::EquPosn *src=0)
2351	{
2352	const double sunset = fSun.fSunSet12.JD()-1;
2353	const double sunrise = fSun.fSunRise12.JD();
2354
2355	Nova::EquPosn moon;
2356	Nova::EquPosn *pos = src ? src : &moon;
2357
2358	double max = 0;
2359	double maxjd = 0;
2360
2361	int cnt = 0;
2362
2363	vector<float> alt;
2364	for (auto it=fCoordinates.begin(); it!=fCoordinates.end(); it++)
2365	{
2366	if (src==0)
2367	moon = it->fMoonEqu;
2368
2369	const Nova::HrzPosn hrz = Nova::GetHrzFromEqu(*pos, it->fJD);
2370
2371	if (it->fJD>sunset && it->fJD<sunrise)
2372	alt.push_back(hrz.alt);
2373
2374	if (hrz.alt>max)
2375	{
2376	max = hrz.alt;
2377	maxjd = it->fJD;
2378	}
2379
2380	if (it->fJD>sunset && it->fJD<sunrise && hrz.alt>15)
2381	cnt++;
2382	}
2383
2384	if (max<=15 \|\| cnt==0)
2385	return make_pair(vector<float>(), make_pair(Time(), 0));
2386
2387	return make_pair(alt, make_pair(maxjd, maxjd>sunset&&maxjd<sunrise?max:0));
2388	}
2389
2390	pair<vector<float>, pair<Time, float>> GetLightCondition(const Nova::EquPosn &src_pos)
2391	{
2392	const double sunset = fSun.fSunSet12.JD()-1;
2393	const double sunrise = fSun.fSunRise12.JD();
2394
2395	double max = -1;
2396	double maxjd = 0;
2397
2398	int cnt = 0;
2399
2400	vector<float> vec;
2401	for (auto it=fCoordinates.begin(); it!=fCoordinates.end(); it++)
2402	{
2403	double cur = -1;
2404
2405	if (it->fJD>sunset && it->fJD<sunrise)
2406	{
2407	cur = FACT::PredictI(*it, src_pos);
2408	vec.push_back(cur);
2409	}
2410
2411	if (cur>max)
2412	{
2413	max = cur;
2414	maxjd = it->fJD;
2415	}
2416
2417	if (it->fJD>sunset && it->fJD<sunrise && cur>0)
2418	cnt++;
2419	}
2420
2421	if (max<=0 \|\| cnt==0)
2422	return make_pair(vector<float>(), make_pair(Time(), 0));
2423
2424	return make_pair(vec, make_pair(maxjd, maxjd>sunset&&maxjd<sunrise?max:-1));
2425	}
2426	#endif
2427
2428	void UpdateAstronomy()
2429	{
2430	Time now;
2431
2432	#ifdef HAVE_NOVA
2433	CalcCoordinates(now.JD());
2434	#endif
2435
2436	fSun = Sun (now);
2437	fMoon = Moon(now);
2438
2439	vector<string> color(8, HTML::kWhite);
2440	color[fSun.state] = HTML::kBlue;
2441
2442	ostringstream out;
2443	out << setprecision(3);
2444	out << now.JavaDate() << '\n';
2445	out << color[4] << '\t' << fSun.fSunRise18.GetAsStr("%H:%M") << '\n';
2446	out << color[5] << '\t' << fSun.fSunRise12.GetAsStr("%H:%M") << '\n';
2447	out << color[6] << '\t' << fSun.fSunRise06.GetAsStr("%H:%M") << '\n';
2448	out << color[7] << '\t' << fSun.fSunRise00.GetAsStr("%H:%M") << '\n';
2449
2450	out << color[0] << '\t' << fSun.fSunSet00.GetAsStr("%H:%M") << '\n';
2451	out << color[1] << '\t' << fSun.fSunSet06.GetAsStr("%H:%M") << '\n';
2452	out << color[2] << '\t' << fSun.fSunSet12.GetAsStr("%H:%M") << '\n';
2453	out << color[3] << '\t' << fSun.fSunSet18.GetAsStr("%H:%M") << '\n';
2454
2455	ofstream(fPath+"/sun.data") << out.str();
2456
2457	color.assign(3, HTML::kWhite);
2458	color[fMoon.state%3] = HTML::kBlue;
2459
2460	out.str("");
2461	out << now.JavaDate() << '\n';
2462
2463	out << color[0] << '\t' << fMoon.fRise.GetAsStr("%H:%M") << '\n';
2464	out << color[1] << '\t' << fMoon.fTransit.GetAsStr("%H:%M") << '\n';
2465	out << color[2] << '\t' << fMoon.fSet.GetAsStr("%H:%M") << '\n';
2466
2467	out << (fSun.isday?HTML::kWhite:fMoon.color) << '\t' << fMoon.description << '\n';
2468
2469	if (!fMoon.visible)
2470	out << HTML::kWhite << "\t—\t\n";
2471	else
2472	{
2473	string col = HTML::kWhite;
2474	if (!fSun.isday)
2475	{
2476	col = HTML::kGreen;
2477	if (fMoon.zd>25)
2478	col = HTML::kYellow;
2479	if (fMoon.zd>45 && fMoon.zd<80)
2480	col = HTML::kRed;
2481	if (fMoon.zd>=80)
2482	col = HTML::kRed;
2483	}
2484	out << col << '\t' << fMoon.zd << '\t' << GetDir(fMoon.az) << '\n';
2485	}
2486
2487	ostringstream out2, out3, out4;
2488	out2 << setprecision(3);
2489	out2 << now.JavaDate() << '\n';
2490	out3 << now.JavaDate() << '\n';
2491	out4 << now.JavaDate() << '\n';
2492
2493	struct Entry
2494	{
2495	string name;
2496	float value;
2497	int color;
2498	Entry(const string &n, float v, int c) : name(n), value(v), color(c%8) { }
2499
2500	const string &Col() const
2501	{
2502	// If this list is updatd the number count in the constructor needs
2503	// to be updated, too
2504	static const string hcol[] = { "888", "8cf", "c8f", "bbb", "8fc", "cf8", "f8c", "fc8" };
2505	return hcol[color];
2506	}
2507
2508	vector<float> GetColor(double scale, double offset=0) const
2509	{
2510	vector<float> rc(3);
2511	rc[0] = double(Col()[0])*scale/126+offset;
2512	rc[1] = double(Col()[1])*scale/126+offset;
2513	rc[2] = double(Col()[2])*scale/126+offset;
2514	return rc;
2515	}
2516	};
2517
2518	multimap<Time, Entry> culmination;
2519	multimap<Time, Entry> lightcond;
2520	vector<vector<float>> alt;
2521	vector<vector<float>> cur;
2522
2523	#ifdef HAVE_NOVA
2524	int ccol = 0;
2525	int lcol = 0;
2526
2527	/const/ pair<vector<float>, pair<Time, float>> vism = GetVisibility();
2528	if (!vism.first.empty())
2529	{
2530	const Entry entry("Moon", vism.second.second, ccol);
2531	culmination.insert(make_pair(vism.second.first, entry));
2532	const vector<float> col = entry.GetColor(75, 15);
2533	vism.first.insert(vism.first.begin(), col.begin(), col.end());
2534	alt.push_back(vism.first);
2535
2536	ccol++;
2537	}
2538	#endif
2539
2540	#ifdef HAVE_SQL
2541	try
2542	{
2543	const mysqlpp::StoreQueryResult res =
2544	Database(fDatabase).query("SELECT fSourceName, fRightAscension, fDeclination FROM Source WHERE fSourceTypeKEY=1").store();
2545
2546	out << HTML::kWhite << '\t';
2547	out2 << HTML::kWhite << '\t';
2548	out3 << HTML::kWhite << '\t';
2549	out4 << HTML::kWhite << '\t';
2550
2551	for (vector<mysqlpp::Row>::const_iterator v=res.begin(); v<res.end(); v++)
2552	{
2553	const string name = (*v)[0].c_str();
2554	const double ra = (*v)[1];
2555	const double dec = (*v)[2];
2556	#ifdef HAVE_NOVA
2557	Nova::EquPosn pos;
2558	pos.ra = ra*15;
2559	pos.dec = dec;
2560
2561	const Nova::ZdAzPosn hrz = Nova::GetHrzFromEqu(pos, now.JD());
2562
2563	/const/ pair<vector<float>, pair<Time, float>> vis = GetVisibility(&pos);
2564	if (!vis.first.empty())
2565	{
2566	const Entry entry(name, vis.second.second, ccol);
2567	culmination.insert(make_pair(vis.second.first, entry));
2568	const vector<float> col = entry.GetColor(75, 15);
2569	vis.first.insert(vis.first.begin(), col.begin(), col.end());
2570	alt.push_back(vis.first);
2571
2572	ccol++;
2573
2574	/const/ pair<vector<float>, pair<Time, float>> lc = GetLightCondition(pos);
2575	if (!lc.first.empty())
2576	{
2577	const Entry entry2(name, lc.second.second, lcol);
2578	lightcond.insert(make_pair(lc.second.first, entry2));
2579	const vector<float> col2 = entry2.GetColor(100);
2580	lc.first.insert(lc.first.begin(), col2.begin(), col2.end());
2581	cur.push_back(lc.first);
2582
2583	lcol++;
2584	}
2585	}
2586
2587	string col = HTML::kWhite;
2588	if (hrz.zd<85)
2589	col = HTML::kRed;
2590	if (hrz.zd<65)
2591	col = HTML::kYellow;
2592	if (hrz.zd<30)
2593	col = HTML::kGreen;
2594
2595	out2 << "<tr bgcolor='" << col << "'>";
2596	out2 << "<td>" << name << "</td>";
2597	if (hrz.zd<85)
2598	{
2599	out2 << "<td>" << hrz.zd << "°</td>";
2600	out2 << "<td>" << GetDir(hrz.az) << "</td>";
2601	}
2602	else
2603	out2 << "<td/><td/>";
2604	out2 << "</tr>";
2605	#endif
2606	const int32_t angle = fMoon.Angle(ra, dec);
2607
2608	out << "<tr bgcolor='" << Moon::Color(angle) << "'>";
2609	out << "<td>" << name << "</td>";
2610	out << "<td>" << round(angle) << "°</td>";
2611	out << "</tr>";
2612	}
2613
2614	for (auto it=culmination.begin(); it!=culmination.end(); it++)
2615	{
2616	const Entry &e = it->second;
2617	if (it!=culmination.begin())
2618	out3 << ", ";
2619	out3 << "<B#" << e.Col() << ">" << e.name << "</B>";
2620	if (e.value>0)
2621	out3 << " [" << nearbyint(90-e.value) << "°]";
2622	}
2623
2624	out4 << setprecision(3);
2625
2626	for (auto it=lightcond.begin(); it!=lightcond.end(); it++)
2627	{
2628	const Entry &e = it->second;
2629	if (it!=lightcond.begin())
2630	out4 << ", ";
2631	out4 << "<B#" << e.Col() << ">" << e.name << "</B>";
2632	if (e.value>0)
2633	out4 << " [" << nearbyint(e.value) << "]";
2634	}
2635
2636	const Time st = fSun.fSunSet12;;
2637	const Time rs = fSun.fSunRise12;
2638
2639	ostringstream title;
2640	title << st.GetAsStr("%H:%M");
2641	title << " / ";
2642	title << ((rs>st?rs-st:st-rs)/20).minutes();
2643	title << "' / ";
2644	title << rs.GetAsStr("%H:%M");
2645
2646	out << '\n';
2647	out2 << '\n';
2648	out3 << '\n';
2649	out4 << '\n';
2650	out << HTML::kWhite << '\t' << Time()-now << '\n';
2651	out2 << HTML::kWhite << '\t' << Time()-now << '\n';
2652
2653	WriteBinaryVec(now, "hist-visibility", alt, 75, 15, "Alt "+title.str());
2654	WriteBinaryVec(now, "hist-current-prediction", cur, 100, 0, "I " +title.str());
2655	}
2656	catch (const exception &e)
2657	{
2658	out << '\n';
2659	out2 << '\n';
2660	out << HTML::kWhite << '\t' << "ERROR - "+string(e.what()) << '\n';
2661	out2 << HTML::kWhite << '\t' << "ERROR - "+string(e.what()) << '\n';
2662	out3 << HTML::kWhite << '\t' << "ERROR - "+string(e.what()) << '\n';
2663	out4 << HTML::kWhite << '\t' << "ERROR - "+string(e.what()) << '\n';
2664	}
2665	#endif
2666
2667	ofstream(fPath+"/moon.data") << out.str();
2668	ofstream(fPath+"/source-list.data") << out2.str();
2669	ofstream(fPath+"/visibility.data") << out3.str();
2670	ofstream(fPath+"/current-prediction.data") << out4.str();
2671	}
2672
2673	int Execute()
2674	{
2675	Time now;
2676	if (now-fLastUpdate<boost::posix_time::seconds(1))
2677	return fDimDNS.online() ? kStateRunning : kStateDimNetworkNA;
2678	fLastUpdate=now;
2679
2680	// ==============================================================
2681
2682	bool reqscript = false;
2683
2684	#ifdef HAVE_SQL
2685	try
2686	{
2687	const string query = Tools::Form("SELECT COUNT(*) FROM calendar.Data WHERE NOT u LIKE 'moon' AND y=%d AND m=%d AND d=%d",
2688	now.NightAsInt()/10000, (now.NightAsInt()/100)%100-1, now.NightAsInt()%100);
2689
2690	const mysqlpp::StoreQueryResult res = Database(fDatabase).query(query).store();
2691
2692	const uint32_t cnt = res[0][0];
2693
2694	reqscript = cnt>0 && (fSun.state==3 \|\| fSun.state==4);
2695	}
2696	catch (const exception &e)
2697	{
2698	Out() << e.what() << endl;
2699	}
2700	#endif
2701	// ==============================================================
2702
2703	struct statvfs vfs;
2704	statvfs("/newdata", &vfs);
2705
2706	const uint64_t free_newdata = vfs.f_bsize*vfs.f_bavail;
2707
2708	// ==============================================================
2709
2710	const bool data_taking =
2711	fDimMcp.state()==MCP::State::kTriggerOn \|\|
2712	fDimMcp.state()==MCP::State::kTakingData;
2713
2714	const bool data_run =
2715	fMcpConfigurationName=="data" \|\|
2716	fMcpConfigurationName=="data-rt";
2717
2718	const bool bias_on =
2719	fDimBiasControl.state()==BIAS::State::kRamping \|\|
2720	fDimBiasControl.state()==BIAS::State::kOverCurrent \|\|
2721	fDimBiasControl.state()==BIAS::State::kVoltageOn;
2722
2723	const bool calibrated =
2724	fDimFeedback.state()>=Feedback::State::kCalibrated;
2725
2726	const bool haderr = !fErrorList.empty();
2727
2728	bool newerr = false;
2729
2730	newerr \|= SetError(!fDimDNS.online(),
2731	"<b><#darkred>DIM network not available</#></b>");
2732	newerr \|= SetError(!fDimControl.online(),
2733	"<b>no dimctrl server available</b>");
2734	newerr \|= SetError(fDimDataLogger.state()<20 \|\| fDimDataLogger.state()>40,
2735	"<b>datalogger not ready</b>");
2736
2737	newerr \|= SetError(fDimControl.state()!=3 && reqscript,
2738	"<b>No script running during datataking time.</b>");
2739
2740	//newerr \|= SetError(fDimDriveControl.state()==Drive::State::kLocked,
2741	// "<b><#darkred>Drive in LOCKED state, drive was automatically parked</#></b>");
2742
2743	newerr \|= SetError(fDimDriveControl.state()>0xff && data_taking && data_run,
2744	"Drive in ERROR state during data-run");
2745	newerr \|= SetError(fDriveControlMoonDist>155,
2746	"Moon within the field-of-view of the cones");
2747	newerr \|= SetError(fDriveControlMoonDist>=0 && fDriveControlMoonDist<3,
2748	"Moon within the field-of-view of the camera");
2749
2750	newerr \|= SetError(fDimBiasControl.state()<BIAS::State::kRamping && data_taking && data_run,
2751	"BIAS not operating during data-run");
2752	newerr \|= SetError(fDimBiasControl.state()==BIAS::State::kOverCurrent,
2753	"BIAS channels in OverCurrent");
2754	newerr \|= SetError(fDimBiasControl.state()==BIAS::State::kNotReferenced,
2755	"BIAS voltage not at reference");
2756
2757	newerr \|= SetError(fDimFeedback.state()==Feedback::State::kOnStandby,
2758	"Feedback in standby due to high currents");
2759
2760
2761	newerr \|= SetError(bias_on && calibrated && fBiasControlCurrentMed>115,
2762	"Median current (excl. crazy) exceeds 115µA/pix");
2763	newerr \|= SetError(bias_on && calibrated && fBiasControlCurrentMax>160,
2764	"Maximum current (excl. crazy) exceeds 160µA/pix");
2765
2766	newerr \|= SetError(fFscControlHumidityAvg>60,
2767	"Average camera humidity exceed 60%");
2768
2769	newerr \|= SetError(!fPfMiniHumidityHist.empty() && fPfMiniHumidityHist.back()>50,
2770	"Camera humidity inside camera exceeds 50% (PFmini)");
2771	newerr \|= SetError(!fTemperatureControlHist.empty() && (fTemperatureControlHist.back()<18.0 \|\| fTemperatureControlHist.back()>22.0),
2772	"Container temperature outside [18.0;22.0]°C");
2773
2774	newerr \|= SetError(!fMagicWeatherHist[kHum].empty() && fMagicWeatherHist[kHum].back()>98 && fDimLidControl.state()==Lid::State::kOpen,
2775	"Outside humidity exceeds 98% while lid is open");
2776	newerr \|= SetError(!fMagicWeatherHist[kGusts].empty() && fMagicWeatherHist[kGusts].back()>50 && (fDimDriveControl.state()==Drive::State::kTracking\|\|fDimDriveControl.state()==Drive::State::kOnTrack),
2777	"Wind gusts exceed 50km/h during tracking");
2778
2779	newerr \|= SetError(fDimFscControl.state()>=FSC::State::kConnected && !fFscControlTemperatureHist.empty() && fFscControlTemperatureHist.back()>15,
2780	"Sensor temperature exceeds outside temperature by more than 15°C");
2781
2782	newerr \|= SetError(fFtmControlTriggerRateTooLow>0,
2783	"Trigger rate below 1Hz while trigger switched on");
2784
2785	newerr \|= SetError(fFtmControlState!=FTM::kFtmConfig && (fFtmControlState&FTM::kFtmLocked)==0,
2786	"FTM - clock conditioner not locked!");
2787
2788	newerr \|= SetError(fDimTimeCheck.state()==1,
2789	"Warning NTP time difference of drive PC exceeds 1s");
2790	newerr \|= SetError(fDimTimeCheck.state()<1,
2791	"Warning timecheck not running");
2792
2793	newerr \|= SetError(fDimBiasControl.state()==BIAS::State::kVoltageOn &&
2794	fDimFeedback.state()<Feedback::State::kCalibrating &&
2795	fBiasControlVoltageMed>3,
2796	"Bias voltage switched on, but bias crate not calibrated");
2797
2798	newerr \|= SetError(fLastRunFinishedWithZeroEvents,
2799	"Last run finshed, but contained zero events.");
2800
2801	newerr \|= SetError(fFreeSpace<uint64_t(50000000000),
2802	"Less than 50GB disk space left on newdaq.");
2803
2804	newerr \|= SetError(free_newdata<uint64_t(800000000000),
2805	"Less than 800GB disk space left on /newdata.");
2806
2807	newerr \|= SetError(fDimPwrControl.state()==Power::State::kCoolingFailure,
2808	"Cooling unit reports failure!");
2809
2810	for (auto it=fControlAlarmHist.begin(); it!=fControlAlarmHist.end(); it++)
2811	newerr \|= SetError(it->time.IsValid(), it->msg);
2812	fControlAlarmHist.clean();;
2813
2814	fLastRunFinishedWithZeroEvents = false;
2815
2816	// FTM in Connected instead of Idle --> power cyclen
2817
2818	/* // Check offline and disconnected status?
2819	Out() << fDimMcp << endl;
2820	Out() << fDimControl << endl;
2821	Out() << fDimDataLogger << endl;
2822	Out() << fDimDriveControl << endl;
2823	Out() << fDimFadControl << endl;
2824	Out() << fDimFtmControl << endl;
2825	Out() << fDimBiasControl << endl;
2826	Out() << fDimFeedback << endl;
2827	Out() << fDimRateControl << endl;
2828	Out() << fDimFscControl << endl;
2829	Out() << fDimMagicWeather << endl;
2830	Out() << fDimRateScan << endl;
2831	Out() << fDimChat << endl;
2832	*/
2833
2834	// FTU in error
2835	// FAD lost
2836
2837	// --------------------------------------------------------------
2838	ostringstream out;
2839
2840	if (newerr)
2841	{
2842	SetAudio("error");
2843
2844	out << now.JavaDate() << '\n';
2845	out << HTML::kWhite << '\t';
2846	out << "<->" << fErrorHist.rget() << "<->";
2847	out << '\n';
2848
2849	ofstream(fPath+"/errorhist.data") << out.str();
2850	}
2851
2852	out.str("");
2853	out << Header(now) << '\t' << (!fErrorList.empty()) << '\t' << (fDimControl.state()>0) << '\n';
2854	out << setprecision(3);
2855	out << HTML::kWhite << '\t';
2856	for (auto it=fErrorList.begin(); it!=fErrorList.end(); it++)
2857	out << *it << "<br/>";
2858	out << '\n';
2859
2860	if (haderr \|\| !fErrorList.empty())
2861	ofstream(fPath+"/error.data") << out.str();
2862
2863	// ==============================================================
2864
2865	out.str("");
2866	out << Header(now) << '\t' << (!fErrorList.empty()) << '\t' << (fDimControl.state()>0) << '\n';
2867	out << setprecision(3);
2868
2869	// -------------- System status --------------
2870	if (fDimDNS.online() && fDimMcp.state()>=MCP::State::kIdle) // Idle
2871	{
2872	string col = HTML::kBlue;
2873	switch (fMcpConfigurationState)
2874	{
2875	case MCP::State::kIdle:
2876	case DimState::kOffline:
2877	col = HTML::kWhite;
2878	break;
2879	case MCP::State::kConfiguring1:
2880	case MCP::State::kConfiguring2:
2881	case MCP::State::kConfiguring3:
2882	case MCP::State::kConfigured:
2883	case MCP::State::kTriggerOn:
2884	col = HTML::kBlue;
2885	break;
2886	case MCP::State::kTakingData:
2887	col = HTML::kBlue;
2888	if (fDimFadControl.state()==FAD::State::kRunInProgress)
2889	col = HTML::kGreen;
2890	break;
2891	}
2892
2893	const bool other =
2894	fDimRateControl.state()==RateControl::State::kSettingGlobalThreshold \|\|
2895	fDimLidControl.state()==Lid::State::kMoving \|\|
2896	fDimRateScan.state()==RateScan::State::kInProgress;
2897
2898	if (other)
2899	col = HTML::kBlue;
2900
2901	out << col << '\t';
2902
2903	if (!other)
2904	{
2905	const string conf = fMcpConfigurationName.length()>0?" ["+fMcpConfigurationName+"]":"";
2906	switch (fMcpConfigurationState)
2907	{
2908	case MCP::State::kIdle:
2909	out << "Idle" << conf;
2910	break;
2911	case MCP::State::kConfiguring1:
2912	case MCP::State::kConfiguring2:
2913	case MCP::State::kConfiguring3:
2914	out << "Configuring" << conf;
2915	break;
2916	case MCP::State::kConfigured:
2917	out << "Configured" << conf;
2918	break;
2919	case MCP::State::kTriggerOn:
2920	case MCP::State::kTakingData:
2921	out << fMcpConfigurationName;
2922	if (fFadControlDrsRuns[2]>0)
2923	out << "(" << fFadControlDrsRuns[2] << ")";
2924	break;
2925
2926	case MCP::State::kCrateReset0:
2927	out << "Crate reset phase 0";
2928	break;
2929	case MCP::State::kCrateReset1:
2930	out << "Crate reset phase 1";
2931	break;
2932	case MCP::State::kCrateReset2:
2933	out << "Crate reset phase 2";
2934	break;
2935	case MCP::State::kCrateReset3:
2936	out << "Crate reset phase 3";
2937	break;
2938	}
2939	}
2940	else
2941	if (fDimRateControl.state()==RateControl::State::kSettingGlobalThreshold)
2942	out << "Calibrating threshold";
2943	else
2944	if (fDimRateScan.state()==RateScan::State::kInProgress)
2945	out << "Rate scan in progress";
2946	else
2947	if (fDimLidControl.state()==Lid::State::kMoving)
2948	out << "Lid moving";
2949
2950
2951	if (fMcpConfigurationState>MCP::State::kConfigured &&
2952	fDimRateControl.state()!=RateControl::State::kSettingGlobalThreshold)
2953	{
2954	ostringstream evt;
2955	if (fMcpConfigurationMaxEvents>0)
2956	{
2957	const int64_t de = int64_t(fMcpConfigurationMaxEvents) - int64_t(fFadControlNumEvents);
2958	if (de>=0 && fMcpConfigurationState==MCP::State::kTakingData)
2959	evt << de;
2960	else
2961	evt << fMcpConfigurationMaxEvents;
2962	}
2963	else
2964	{
2965	if (fMcpConfigurationState==MCP::State::kTakingData)
2966	{
2967	if (fFadControlNumEvents>2999)
2968	evt << floor(fFadControlNumEvents/1000) << 'k';
2969	else
2970	evt << fFadControlNumEvents;
2971	}
2972	}
2973
2974	ostringstream tim;
2975	if (fMcpConfigurationMaxTime>0)
2976	{
2977	const uint32_t dt = (Time()-fMcpConfigurationRunStart).total_seconds();
2978	if (dt<=fMcpConfigurationMaxTime && fMcpConfigurationState==MCP::State::kTakingData)
2979	tim << fMcpConfigurationMaxTime-dt << 's';
2980	else
2981	tim << fMcpConfigurationMaxTime << 's';
2982	}
2983	else
2984	{
2985	if (fMcpConfigurationState==MCP::State::kTakingData)
2986	tim << fMcpConfigurationRunStart.SecondsTo();
2987	}
2988
2989	const bool has_evt = !evt.str().empty();
2990	const bool has_tim = !tim.str().empty();
2991
2992	if (has_evt \|\| has_tim)
2993	out << " [";
2994	out << evt.str();
2995	if (has_evt && has_tim)
2996	out << '/';
2997	out << tim.str();
2998	if (has_evt \|\| has_tim)
2999	out << ']';
3000	}
3001	}
3002	else
3003	out << HTML::kWhite;
3004	out << '\n';
3005
3006	// ------------------ Drive -----------------
3007	if (fDimDNS.online() && fDimDriveControl.state()>=Drive::State::kInitialized) // Armed, Moving, Tracking, OnTrack, Error
3008	{
3009	const uint32_t dev = !fDriveControlTrackingDevHist.empty() ? round(fDriveControlTrackingDevHist.back()) : 0;
3010	const State rc = fDimDriveControl.description();
3011	string col = HTML::kGreen;
3012	if (fDimDriveControl.state()==Drive::State::kInitialized) // Armed
3013	col = HTML::kWhite;
3014	if (fDimDriveControl.state()>Drive::State::kInitialized && // Moving
3015	fDimDriveControl.state()<Drive::State::kTracking)
3016	col = HTML::kBlue;
3017	if (fDimDriveControl.state()==Drive::State::kTracking \|\| // Tracking
3018	fDimDriveControl.state()==Drive::State::kOnTrack)
3019	{
3020	if (dev>60) // ~1.5mm
3021	col = HTML::kYellow;
3022	if (dev>120) // ~1/4 of a pixel ~ 2.5mm
3023	col = HTML::kRed;
3024	}
3025	if (fDimDriveControl.state()>0xff)
3026	col = HTML::kRed;
3027	out << col << '\t';
3028
3029	//out << rc.name << '\t';
3030	out << fDriveControlPointingAz << ' ';
3031	out << fDriveControlPointingZd << "°";
3032	out << setprecision(2);
3033	if (fDimDriveControl.state()==Drive::State::kTracking \|\|
3034	fDimDriveControl.state()==Drive::State::kOnTrack) // Tracking
3035	{
3036	out << " ± " << dev << '"';
3037	if (!fDriveControlSourceName.empty())
3038	out << " [" << fDriveControlSourceName << ']';
3039	}
3040	if (fDimDriveControl.state()>Drive::State::kInitialized && // Moving
3041	fDimDriveControl.state()<Drive::State::kTracking)
3042	out << " ⟳";
3043	out << setprecision(3);
3044	}
3045	else
3046	out << HTML::kWhite << '\t';
3047
3048	if (fSun.time.IsValid() && fMoon.time.IsValid())
3049	{
3050	if (fSun.visible)
3051	{
3052	out << " ☼";
3053	if (fDimDriveControl.state()<Drive::State::kInitialized)
3054	out << " [" << fSun.fSunSet12.MinutesTo() << "↓]";
3055	}
3056	else
3057	if (!fSun.visible && fMoon.visible)
3058	{
3059	out << " ☾";
3060	if (fDimDriveControl.state()<Drive::State::kInitialized)
3061	out << " [" << fMoon.disk << "%]";
3062	}
3063	}
3064	if (fDimDNS.online() && fDimDriveControl.state()>0xff)
3065	out << " <ERR>";
3066	if (fDimDNS.online() && fDimDriveControl.state()==Drive::State::kLocked)
3067	out << " &otimes;";
3068	out << '\n';
3069
3070	// ------------------- FSC ------------------
3071	if (fDimDNS.online() && fDimFscControl.state()>FSC::State::kDisconnected && !fFscControlTemperatureHist.empty())
3072	{
3073	string col = HTML::kGreen;
3074	if (fFscControlTemperatureHist.back()>9)
3075	col = HTML::kYellow;
3076	if (fFscControlTemperatureHist.back()>15)
3077	col = HTML::kRed;
3078
3079	out << col << '\t' << fFscControlTemperatureHist.back() << '\n';
3080	}
3081	else
3082	out << HTML::kWhite << '\n';
3083
3084	// --------------- MagicWeather -------------
3085	if (fDimDNS.online() && fDimMagicWeather.state()==MagicWeather::State::kReceiving && !fMagicWeatherHist[kWeatherBegin].empty())
3086	{
3087	/*
3088	const float diff = fMagicWeatherHist[kTemp].back()-fMagicWeatherHist[kDew].back();
3089	string col1 = HTML::kRed;
3090	if (diff>0.3)
3091	col1 = HTML::kYellow;
3092	if (diff>0.7)
3093	col1 = HTML::kGreen;
3094	*/
3095
3096	const float wind = fMagicWeatherHist[kGusts].back();
3097	const float hum = fMagicWeatherHist[kHum].back();
3098	string col = HTML::kGreen;
3099	if (wind>35 \|\| hum>95)
3100	col = HTML::kYellow;
3101	if (wind>45 \|\| hum>98)
3102	col = HTML::kRed;
3103
3104	if (fDimRainSensor.state()==RainSensor::State::kValid && !fRainSensorDataHist.empty() && fRainSensorDataHist.back()>0)
3105	{
3106	out << HTML::kRed << '\t';
3107	out << "RAIN" << '\t';
3108	}
3109	else
3110	{
3111	out << col << '\t';
3112	out << fMagicWeatherHist[kHum].back() << '\t';
3113	}
3114	out << setprecision(2);
3115	out << fMagicWeatherHist[kGusts].back() << '\n';
3116	out << setprecision(3);
3117	}
3118	else
3119	out << HTML::kWhite << "\n";
3120
3121	// --------------- FtmControl -------------
3122	if (fDimDNS.online() && fDimFtmControl.state()==FTM::State::kTriggerOn)
3123	{
3124	string col = HTML::kGreen;
3125	if (!fFtmControlTriggerRateHist.empty())
3126	{
3127	if (fFtmControlTriggerRateHist.back()<15)
3128	col = HTML::kYellow;
3129	if (fFtmControlTriggerRateHist.back()>100)
3130	col = HTML::kRed;
3131
3132	out << col << '\t' << fFtmControlTriggerRateHist.back() << " Hz";
3133	}
3134
3135	if (bias_on)
3136	out << " (" << setprecision(4) << fFtmPatchThresholdMed << ')';
3137	out << '\n';
3138	}
3139	else
3140	out << HTML::kWhite << '\n';
3141
3142	// --------------- BiasControl -------------
3143	const bool bias_off = fDimBiasControl.state()==BIAS::State::kVoltageOff;
3144	const bool bias_oc = fDimBiasControl.state()==BIAS::State::kOverCurrent;
3145
3146	if (fDimDNS.online() && (bias_on \|\| bias_off))
3147	{
3148
3149	string col = fBiasControlVoltageMed>3?HTML::kGreen:HTML::kWhite;
3150	if (bias_on)
3151	{
3152	if (fBiasControlCurrentMed>95 \|\| fBiasControlCurrentMax>135)
3153	col = HTML::kYellow;
3154	if (fBiasControlCurrentMed>100 \|\| fBiasControlCurrentMax>140)
3155	col = HTML::kRed;
3156	}
3157
3158	// Bias in overcurrent => Red
3159	if (bias_oc)
3160	col = HTML::kRed;
3161
3162	// MCP in ReadyForDatataking/Configuring/Configured/TriggerOn/TakingData
3163	// and Bias not in "data-taking state' => Red
3164	if (fMcpConfigurationState>MCP::State::kIdle && !bias_on)
3165	col = HTML::kWhite;
3166
3167	const bool cal = fDimFeedback.state()>=Feedback::State::kCalibrated;
3168
3169	// Feedback is currently calibrating => Blue
3170	if (fDimFeedback.state()==Feedback::State::kCalibrating)
3171	{
3172	out << HTML::kBlue << '\t';
3173	out << "***\t";
3174	out << "***\t";
3175	}
3176	else
3177	{
3178	out << col << '\t';
3179	out << setprecision(fBiasControlCurrentMed<100?2:3);
3180	out << (bias_off ? 0 : (fBiasControlCurrentMed<10?fBiasControlCurrentMed:floor(fBiasControlCurrentMed))) << '\t';
3181	if (bias_oc)
3182	out << "(OC) ";
3183	else
3184	{
3185	if (cal)
3186	{
3187	out << setprecision(fBiasControlCurrentMax<100?2:3);
3188	out << (bias_off ? 0 : (fBiasControlCurrentMax<10?fBiasControlCurrentMax:floor(fBiasControlCurrentMax)));
3189	}
3190	else
3191	out << "— ";
3192	}
3193	out << '\t';
3194	}
3195	if (cal && fDimFeedback.state()!=Feedback::State::kCalibrating)
3196	out << setprecision(2) << fBiasControlPowerTot << " W";
3197	else
3198	out << setprecision(3) << (bias_off ? 0 : fBiasControlVoltageMed) << " V";
3199	out << '\n';
3200	}
3201	else
3202	out << HTML::kWhite << '\n';
3203
3204	ofstream(fPath+"/fact.data") << out.str();
3205
3206	// ==============================================================
3207
3208	out.str("");
3209	out << Header(now) << '\t' << (!fErrorList.empty()) << '\t' << (fDimControl.state()>0) << '\n';
3210
3211	if (!fDimDNS.online())
3212	out << HTML::kWhite << "\tOffline\n\n\n\n\n\n\n\n\n\n\n\n\n";
3213	else
3214	{
3215	ostringstream dt;
3216	dt << (Time()-fRunTime);
3217
3218	out << HTML::kGreen << '\t' << fDimDNS.version() << '\n';
3219
3220	out << GetStateHtml(fDimControl, 0);
3221	out << GetStateHtml(fDimMcp, MCP::State::kConnected);
3222	out << GetStateHtml(fDimDataLogger, 1);
3223	out << GetStateHtml(fDimDriveControl, Drive::State::kConnected);
3224	out << GetStateHtml(fDimTimeCheck, 1);
3225	out << GetStateHtml(fDimFadControl, FAD::State::kConnected);
3226	out << GetStateHtml(fDimFtmControl, FTM::State::kConnected);
3227	out << GetStateHtml(fDimBiasControl, BIAS::State::kConnected);
3228	out << GetStateHtml(fDimFeedback, Feedback::State::kConnected);
3229	out << GetStateHtml(fDimRateControl, RateControl::State::kConnected);
3230	out << GetStateHtml(fDimFscControl, FSC::State::kConnected);
3231	out << GetStateHtml(fDimPfMiniControl, PFmini::State::kConnected);
3232	out << GetStateHtml(fDimBiasTemp, BiasTemp::State::kConnected);
3233	out << GetStateHtml(fDimGpsControl, GPS::State::kConnected);
3234	out << GetStateHtml(fDimSqmControl, SQM::State::kConnected);
3235	out << GetStateHtml(fDimAgilentControl24, Agilent::State::kVoltageOff);
3236	out << GetStateHtml(fDimAgilentControl50, Agilent::State::kVoltageOff);
3237	out << GetStateHtml(fDimAgilentControl80, Agilent::State::kVoltageOff);
3238	out << GetStateHtml(fDimPwrControl, Power::State::kSystemOff);
3239	out << GetStateHtml(fDimLidControl, Lid::State::kConnected);
3240	out << GetStateHtml(fDimRateScan, RateScan::State::kConnected);
3241	out << GetStateHtml(fDimMagicWeather, MagicWeather::State::kConnected);
3242	out << GetStateHtml(fDimTngWeather, TNGWeather::State::kConnected);
3243	out << GetStateHtml(fDimMagicLidar, MagicLidar::State::kConnected);
3244	out << GetStateHtml(fDimTemperature, Temperature::State::kValid);
3245	out << GetStateHtml(fDimRainSensor, RainSensor::State::kValid);
3246	out << GetStateHtml(fDimChat, 0);
3247	out << GetStateHtml(fDimSkypeClient, 1);
3248
3249	string col = HTML::kRed;
3250	if (fFreeSpace>uint64_t(199999999999))
3251	col = HTML::kYellow;
3252	if (fFreeSpace>uint64_t(999999999999))
3253	col = HTML::kGreen;
3254	if (fFreeSpace==UINT64_MAX)
3255	col = HTML::kWhite;
3256
3257	out << col << '\t' << Tools::Scientific(fFreeSpace) << "B\n";
3258
3259	col = HTML::kRed;
3260	if (free_newdata > uint64_t(999999999999))
3261	col = HTML::kYellow;
3262	if (free_newdata > uint64_t(149999999999))
3263	col = HTML::kGreen;
3264	if (free_newdata == UINT64_MAX)
3265	col = HTML::kWhite;
3266
3267	out << col << '\t' << Tools::Scientific(free_newdata) << "B\n";
3268
3269	out << HTML::kGreen << '\t' << dt.str().substr(0, dt.str().length()-7) << '\n';
3270	}
3271
3272	ofstream(fPath+"/status.data") << out.str();
3273
3274	if (now-fLastAstroCalc>boost::posix_time::seconds(15))
3275	{
3276	UpdateAstronomy();
3277	fLastAstroCalc = now;
3278	}
3279
3280	return fDimDNS.online() ? kStateRunning : kStateDimNetworkNA;
3281	}
3282
3283
3284	public:
3285	StateMachineSmartFACT(ostream &out=cout) : StateMachineDim(out, fIsServer?"SMART_FACT":""),
3286	fLastAstroCalc(boost::date_time::neg_infin),
3287	fPath("www/smartfact/data"),
3288	fMcpConfigurationState(DimState::kOffline),
3289	fMcpConfigurationMaxTime(0),
3290	fMcpConfigurationMaxEvents(0),
3291	fLastRunFinishedWithZeroEvents(false),
3292	fTngWeatherDustTime(Time::none),
3293	fBiasControlVoltageMed(0),
3294	fBiasControlCurrentMed(0),
3295	fBiasControlCurrentMax(0),
3296	fFscControlHumidityAvg(0),
3297	fDriveControlMoonDist(-1),
3298	fFadControlNumEvents(0),
3299	fFadControlDrsRuns(3),
3300	fFtmControlState(FTM::kFtmLocked),
3301	fRateScanDataId(0),
3302	fRateScanBoard(0),
3303	fFreeSpace(UINT64_MAX),
3304	// ---
3305	fDimMcp ("MCP"),
3306	fDimDataLogger ("DATA_LOGGER"),
3307	fDimDriveControl ("DRIVE_CONTROL"),
3308	fDimTimeCheck ("TIME_CHECK"),
3309	fDimMagicWeather ("MAGIC_WEATHER"),
3310	fDimMagicLidar ("MAGIC_LIDAR"),
3311	fDimTngWeather ("TNG_WEATHER"),
3312	fDimTemperature ("TEMPERATURE"),
3313	fDimRainSensor ("RAIN_SENSOR"),
3314	fDimFeedback ("FEEDBACK"),
3315	fDimBiasControl ("BIAS_CONTROL"),
3316	fDimFtmControl ("FTM_CONTROL"),
3317	fDimFadControl ("FAD_CONTROL"),
3318	fDimFscControl ("FSC_CONTROL"),
3319	fDimPfMiniControl ("PFMINI_CONTROL"),
3320	fDimBiasTemp ("BIAS_TEMP"),
3321	fDimGpsControl ("GPS_CONTROL"),
3322	fDimSqmControl ("SQM_CONTROL"),
3323	fDimAgilentControl24("AGILENT_CONTROL_24V"),
3324	fDimAgilentControl50("AGILENT_CONTROL_50V"),
3325	fDimAgilentControl80("AGILENT_CONTROL_80V"),
3326	fDimPwrControl ("PWR_CONTROL"),
3327	fDimLidControl ("LID_CONTROL"),
3328	fDimRateControl ("RATE_CONTROL"),
3329	fDimRateScan ("RATE_SCAN"),
3330	fDimChat ("CHAT"),
3331	fDimSkypeClient ("SKYPE_CLIENT")
3332	{
3333	fDimDNS.Subscribe(*this);
3334	fDimControl.Subscribe(*this);
3335	fDimMcp.Subscribe(*this);
3336	fDimDataLogger.Subscribe(*this);
3337	fDimDriveControl.Subscribe(*this);
3338	fDimTimeCheck.Subscribe(*this);
3339	fDimMagicWeather.Subscribe(*this);
3340	fDimMagicLidar.Subscribe(*this);
3341	fDimTngWeather.Subscribe(*this);
3342	fDimTemperature.Subscribe(*this);
3343	fDimRainSensor.Subscribe(*this);
3344	fDimFeedback.Subscribe(*this);
3345	fDimBiasControl.Subscribe(*this);
3346	fDimFtmControl.Subscribe(*this);
3347	fDimFadControl.Subscribe(*this);
3348	fDimFscControl.Subscribe(*this);
3349	fDimPfMiniControl.Subscribe(*this);
3350	fDimBiasTemp.Subscribe(*this);
3351	fDimGpsControl.Subscribe(*this);
3352	fDimSqmControl.Subscribe(*this);
3353	fDimAgilentControl24.Subscribe(*this);
3354	fDimAgilentControl50.Subscribe(*this);
3355	fDimAgilentControl80.Subscribe(*this);
3356	fDimPwrControl.Subscribe(*this);
3357	fDimLidControl.Subscribe(*this);
3358	fDimRateControl.Subscribe(*this);
3359	fDimRateScan.Subscribe(*this);
3360	fDimChat.Subscribe(*this);
3361	fDimSkypeClient.Subscribe(*this);
3362
3363	fDimFscControl.SetCallback(bind(&StateMachineSmartFACT::HandleFscControlStateChange, this, placeholders::_1));
3364	//fDimFtmControl.SetCallback(bind(&StateMachineSmartFACT::HandleFtmControlStateChange, this));
3365	fDimDriveControl.SetCallback(bind(&StateMachineSmartFACT::HandleDriveControlStateChange, this, placeholders::_1));
3366	fDimControl.SetCallback(bind(&StateMachineSmartFACT::HandleControlStateChange, this, placeholders::_1));
3367	fDimControl.AddCallback("dotest.dim", bind(&StateMachineSmartFACT::HandleDoTest, this, placeholders::_1));
3368
3369	Subscribe("DIM_CONTROL/MESSAGE")
3370	(bind(&StateMachineSmartFACT::HandleDimControlMessage, this, placeholders::_1));
3371
3372	Subscribe("MCP/CONFIGURATION")
3373	(bind(&StateMachineSmartFACT::HandleMcpConfiguration, this, placeholders::_1));
3374
3375	Subscribe("DRIVE_CONTROL/POINTING_POSITION")
3376	(bind(&StateMachineSmartFACT::HandleDrivePointing, this, placeholders::_1));
3377	Subscribe("DRIVE_CONTROL/TRACKING_POSITION")
3378	(bind(&StateMachineSmartFACT::HandleDriveTracking, this, placeholders::_1));
3379	Subscribe("DRIVE_CONTROL/SOURCE_POSITION")
3380	(bind(&StateMachineSmartFACT::HandleDriveSource, this, placeholders::_1));
3381
3382	Subscribe("FSC_CONTROL/TEMPERATURE")
3383	(bind(&StateMachineSmartFACT::HandleFscTemperature, this, placeholders::_1));
3384	Subscribe("FSC_CONTROL/HUMIDITY")
3385	(bind(&StateMachineSmartFACT::HandleFscHumidity, this, placeholders::_1));
3386	Subscribe("FSC_CONTROL/BIAS_TEMP")
3387	(bind(&StateMachineSmartFACT::HandleFscBiasTemp, this, placeholders::_1));
3388
3389	Subscribe("PFMINI_CONTROL/DATA")
3390	(bind(&StateMachineSmartFACT::HandlePfMiniData, this, placeholders::_1));
3391
3392	Subscribe("BIAS_TEMP/DATA")
3393	(bind(&StateMachineSmartFACT::HandleBiasTemp, this, placeholders::_1));
3394
3395	Subscribe("GPS_CONTROL/NEMA")
3396	(bind(&StateMachineSmartFACT::HandleGpsNema, this, placeholders::_1));
3397
3398	Subscribe("SQM_CONTROL/DATA")
3399	(bind(&StateMachineSmartFACT::HandleSqmData, this, placeholders::_1));
3400
3401	Subscribe("TEMPERATURE/DATA")
3402	(bind(&StateMachineSmartFACT::HandleTemperatureData, this, placeholders::_1));
3403
3404	Subscribe("AGILENT_CONTROL_24V/DATA")
3405	(bind(&StateMachineSmartFACT::HandleAgilentData, this, placeholders::_1, "24"));
3406	Subscribe("AGILENT_CONTROL_50V/DATA")
3407	(bind(&StateMachineSmartFACT::HandleAgilentData, this, placeholders::_1, "50"));
3408	Subscribe("AGILENT_CONTROL_80V/DATA")
3409	(bind(&StateMachineSmartFACT::HandleAgilentData, this, placeholders::_1, "80"));
3410
3411	Subscribe("MAGIC_WEATHER/DATA")
3412	(bind(&StateMachineSmartFACT::HandleMagicWeatherData, this, placeholders::_1));
3413	Subscribe("TNG_WEATHER/DUST")
3414	(bind(&StateMachineSmartFACT::HandleTngWeatherDust, this, placeholders::_1));
3415	Subscribe("RAIN_SENSOR/DATA")
3416	(bind(&StateMachineSmartFACT::HandleRainSensorData, this, placeholders::_1));
3417
3418	Subscribe("FEEDBACK/CALIBRATED_CURRENTS")
3419	(bind(&StateMachineSmartFACT::HandleFeedbackCalibratedCurrents, this, placeholders::_1));
3420
3421	Subscribe("BIAS_CONTROL/VOLTAGE")
3422	(bind(&StateMachineSmartFACT::HandleBiasVoltage, this, placeholders::_1));
3423	Subscribe("BIAS_CONTROL/CURRENT")
3424	(bind(&StateMachineSmartFACT::HandleBiasCurrent, this, placeholders::_1));
3425
3426	Subscribe("FAD_CONTROL/CONNECTIONS")
3427	(bind(&StateMachineSmartFACT::HandleFadConnections, this, placeholders::_1));
3428	Subscribe("FAD_CONTROL/EVENTS")
3429	(bind(&StateMachineSmartFACT::HandleFadEvents, this, placeholders::_1));
3430	Subscribe("FAD_CONTROL/START_RUN")
3431	(bind(&StateMachineSmartFACT::HandleFadStartRun, this, placeholders::_1));
3432	Subscribe("FAD_CONTROL/DRS_RUNS")
3433	(bind(&StateMachineSmartFACT::HandleFadDrsRuns, this, placeholders::_1));
3434	Subscribe("FAD_CONTROL/EVENT_DATA")
3435	(bind(&StateMachineSmartFACT::HandleFadEventData, this, placeholders::_1));
3436	Subscribe("FAD_CONTROL/STATS")
3437	(bind(&StateMachineSmartFACT::HandleStats, this, placeholders::_1));
3438
3439	Subscribe("DATA_LOGGER/STATS")
3440	(bind(&StateMachineSmartFACT::HandleStats, this, placeholders::_1));
3441
3442	Subscribe("FTM_CONTROL/TRIGGER_RATES")
3443	(bind(&StateMachineSmartFACT::HandleFtmTriggerRates, this, placeholders::_1));
3444	Subscribe("FTM_CONTROL/STATIC_DATA")
3445	(bind(&StateMachineSmartFACT::HandleFtmStaticData, this, placeholders::_1));
3446	Subscribe("FTM_CONTROL/FTU_LIST")
3447	(bind(&StateMachineSmartFACT::HandleFtmFtuList, this, placeholders::_1));
3448
3449	Subscribe("RATE_CONTROL/THRESHOLD")
3450	(bind(&StateMachineSmartFACT::HandleRateControlThreshold,this, placeholders::_1));
3451
3452	Subscribe("RATE_SCAN/DATA")
3453	(bind(&StateMachineSmartFACT::HandleRateScanData, this, placeholders::_1));
3454
3455	Subscribe("CHAT/MESSAGE")
3456	(bind(&StateMachineSmartFACT::HandleChatMsg, this, placeholders::_1));
3457
3458
3459	// =================================================================
3460
3461	// State names
3462	AddStateName(kStateDimNetworkNA, "DimNetworkNotAvailable",
3463	"The Dim DNS is not reachable.");
3464
3465	AddStateName(kStateRunning, "Running", "");
3466
3467	// =================================================================
3468
3469	AddEvent("PRINT")
3470	(bind(&StateMachineSmartFACT::Print, this))
3471	("Print a list of the states of all connected servers.");
3472
3473	}
3474	int EvalOptions(Configuration &conf)
3475	{
3476	if (!fPixelMap.Read(conf.Get<string>("pixel-map-file")))
3477	{
3478	Error("Reading mapping table from "+conf.Get<string>("pixel-map-file")+" failed.");
3479	return 1;
3480	}
3481
3482	fPath = conf.Get<string>("path");
3483	fDatabase = conf.Get<string>("source-database");
3484
3485	struct stat st;
3486	if (stat(fPath.c_str(), &st))
3487	{
3488	Error(fPath+" does not exist!");
3489	return 2;
3490	}
3491
3492	if ((st.st_mode&S_IFDIR)==0)
3493	{
3494	Error(fPath+" not a directory!");
3495	return 3;
3496	}
3497
3498	if ((st.st_mode&S_IWUSR)==0)
3499	{
3500	Error(fPath+" has no write permission!");
3501	return 4;
3502	}
3503
3504	if ((st.st_mode&S_IXUSR)==0)
3505	{
3506	Error(fPath+" has no execute permission!");
3507	return 5;
3508	}
3509
3510	ostringstream out;
3511	out << Time().JavaDate() << '\n';
3512
3513	ofstream(fPath+"/error.data") << out.str();
3514
3515	return -1;
3516	}
3517	};
3518
3519	bool StateMachineSmartFACT::fIsServer = false;
3520
3521	// ------------------------------------------------------------------------
3522
3523	#include "Main.h"
3524
3525	template<class T>
3526	int RunShell(Configuration &conf)
3527	{
3528	StateMachineSmartFACT::fIsServer = !conf.Get<bool>("client");
3529	return Main::execute<T, StateMachineSmartFACT>(conf);
3530	}
3531
3532	void SetupConfiguration(Configuration &conf)
3533	{
3534	po::options_description control("Smart FACT");
3535	control.add_options()
3536	("pixel-map-file", var<string>()->required(), "Pixel mapping file. Used here to get the default reference voltage")
3537	("path", var<string>("www/smartfact/data"), "Output path for the data-files")
3538	("source-database", var<string>(""), "Database link as in\n\tuser:password@server[:port]/database.")
3539	("client", po_bool(false), "For a standalone client choose this option.")
3540	;
3541
3542	conf.AddOptions(control);
3543	}
3544
3545	/*
3546	Extract usage clause(s) [if any] for SYNOPSIS.
3547	Translators: "Usage" and "or" here are patterns (regular expressions) which
3548	are used to match the usage synopsis in program output. An example from cp
3549	(GNU coreutils) which contains both strings:
3550	Usage: cp [OPTION]... [-T] SOURCE DEST
3551	or: cp [OPTION]... SOURCE... DIRECTORY
3552	or: cp [OPTION]... -t DIRECTORY SOURCE...
3553	*/
3554	void PrintUsage()
3555	{
3556	cout <<
3557	"SmartFACT is a tool writing the files needed for the SmartFACT web interface.\n"
3558	"\n"
3559	"The default is that the program is started without user intercation. "
3560	"All actions are supposed to arrive as DimCommands. Using the -c "
3561	"option, a local shell can be initialized. With h or help a short "
3562	"help message about the usuage can be brought to the screen.\n"
3563	"\n"
3564	"Usage: smartfact [-c type] [OPTIONS]\n"
3565	" or: smartfact [OPTIONS]\n";
3566	cout << endl;
3567	}
3568
3569	void PrintHelp()
3570	{
3571	Main::PrintHelp<StateMachineSmartFACT>();
3572
3573	/* Additional help text which is printed after the configuration
3574	options goes here */
3575
3576	/*
3577	cout << "bla bla bla" << endl << endl;
3578	cout << endl;
3579	cout << "Environment:" << endl;
3580	cout << "environment" << endl;
3581	cout << endl;
3582	cout << "Examples:" << endl;
3583	cout << "test exam" << endl;
3584	cout << endl;
3585	cout << "Files:" << endl;
3586	cout << "files" << endl;
3587	cout << endl;
3588	*/
3589	}
3590
3591	int main(int argc, const char* argv[])
3592	{
3593	Configuration conf(argv[0]);
3594	conf.SetPrintUsage(PrintUsage);
3595	Main::SetupConfiguration(conf);
3596	SetupConfiguration(conf);
3597
3598	if (!conf.DoParse(argc, argv, PrintHelp))
3599	return 127;
3600
3601	if (!conf.Has("console"))
3602	return RunShell<LocalStream>(conf);
3603
3604	if (conf.Get<int>("console")==0)
3605	return RunShell<LocalShell>(conf);
3606	else
3607	return RunShell<LocalConsole>(conf);
3608
3609	return 0;
3610	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: