source: branches/FACT++_lidctrl_usb/scripts/Main.js@ 20115

Last change on this file since 20115 was 18715, checked in by tbretz, 8 years ago
Implemented the suspend/resume feature. Everything after a suspend is ignored. If a successive resume is found suspend/resume are ignored.
File size: 52.8 KB
Line 
1/**
2 * @fileOverview This file has functions related to documenting JavaScript.
3 * @author <a href="mailto:thomas.bretz@epfl.ch">Thomas Bretz</a>
4 */
5'use strict';
6
7dim.log("Start: "+__FILE__+" ["+__DATE__+"]");
8
9// This should be set in dimctrl.rc as JavaScript.schedule-database.
10// It is sent together with the script to the dimserver.
11// If started directly, it has to be set after the command:
12//
13// .js scripts/Main.js schedule-database=...
14//
15if (!$['schedule-database'])
16 throw new Error("Environment 'schedule-database' not set!");
17
18//dimctrl.defineState(37, "TimeOutBeforeTakingData", "MCP took more than 5minutes to start TakingData");
19
20// ================================================================
21// Code related to the schedule
22// ================================================================
23
24//this is just the class implementation of 'Observation'
25include('scripts/Observation_class.js');
26include('scripts/getSchedule.js');
27
28var observations = [ ];
29
30// Get the observation scheduled for 'now' from the table and
31// return its index
32function getObservation(now)
33{
34 if (now==undefined)
35 now = new Date();
36
37 if (isNaN(now.valueOf()))
38 throw new Error("Date argument in getObservation invalid.");
39
40 observations = getSchedule();
41 if (observations.length==0)
42 return -1;
43
44 var suspended = -1;
45
46 var rc = observations.length-1;
47
48 for (var i=0; i<observations.length; i++)
49 {
50 // Find the first observation which is in the future
51 if (observations[i].start>now)
52 {
53 rc = i-1;
54 break;
55 }
56
57 // If the loop just passed a suspend, i.e. it is in the past, set the suspend flag
58 if (observations[i][0].task=="SUSPEND")
59 suspended = i;
60
61 // If the loop just passed a resume, i.e. it is in the past, remove the suspend flag
62 if (observations[i][0].task=="RESUME")
63 suspended = -1;
64 }
65
66 // Now rc contains the index of the first observation in the past
67
68 // If the system is in suspend mode, the suspend observation is
69 // returned as recent measurement. For convenience (to avoid that
70 // the next observation is announced), all furture observations
71 // are removed.
72 if (suspended>=0)
73 {
74 observations.splice(suspended+1);
75 return suspended;
76 }
77
78 // Observations have already been resumed and the last scheduled
79 // observation is the resume itself: remove the resume and
80 // all leading suspend/resume pairs until the last observation
81 // is found
82 while (rc>=0 && observations[rc][0].task=="RESUME")
83 {
84 observations.splice(rc--, 1);
85
86 // Find previous suspend
87 if (rc>=0 && observations[rc][0].task=="SUSPEND")
88 observations.splice(rc--, 1);
89 }
90
91 return rc;
92}
93
94// ================================================================
95// Code to check whether observation is allowed
96// ================================================================
97/*
98function currentEst(source)
99{
100 var moon = new Moon();
101 if (!moon.isUp)
102 return 7.7;
103
104 var dist = Sky.dist(moon, source);
105
106 var alt = 90-moon.toLocal().zd;
107
108 var lc = dist*alt*pow(Moon.disk(), 6)/360/360;
109
110 var cur = 7.7+4942*lc;
111
112 return cur;
113}
114
115function thresholdEst(source) // relative threshold (ratio)
116{
117 // Assumption:
118 // atmosphere is 70km, shower taks place after 60km, earth radius 6400km
119 // just using the cosine law
120 // This fits very well with MC results: See Roger Firpo, p.45
121 // "Study of the MAGIC telescope sensitivity for Large Zenith Angle observations"
122
123 var c = Math.cos(Math.Pi-source.zd);
124 var ratio = (10*sqrt(409600*c*c+9009) + 6400*c - 60)/10;
125
126 // assumption: Energy threshold increases linearily with current
127 // assumption: Energy threshold increases linearily with distance
128
129 return ratio*currentEst(source)/7.7;
130}
131*/
132
133// ================================================================
134// Code to perform the DRS calib sequence
135// ================================================================
136
137var irq;
138
139function doDrsCalibration(where)
140{
141 dim.log("Starting DRS calibration ["+where+"]");
142
143 service_feedback.voltageOff();
144
145 var tm = new Date();
146
147 while (!irq)
148 {
149 dim.send("FAD_CONTROL/START_DRS_CALIBRATION");
150 if (irq || !takeRun("drs-pedestal", 1000)) // 40 / 20s (50Hz)
151 continue;
152
153 if (irq || !takeRun("drs-gain", 1000)) // 40 / 20s (50Hz)
154 continue;
155
156 if (where!="data")
157 {
158 if (irq || !takeRun("drs-pedestal", 1000)) // 40 / 20s (50Hz)
159 continue;
160 }
161
162 break;
163 }
164
165 if (where!="data")
166 {
167 dim.send("FAD_CONTROL/SET_FILE_FORMAT", 6);
168
169 while (!irq && !takeRun("drs-pedestal", 1000)); // 40 / 20s (50Hz)
170 while (!irq && !takeRun("drs-time", 1000)); // 40 / 20s (50Hz)
171 }
172
173 while (!irq)
174 {
175 dim.send("FAD_CONTROL/RESET_SECONDARY_DRS_BASELINE");
176 if (takeRun("pedestal", 1000)) // 40 / 10s (80Hz)
177 break;
178 }
179
180 dim.send("FAD_CONTROL/SET_FILE_FORMAT", 6);
181
182 while (!irq && !takeRun("pedestal", 1000)); // 40 / 10s (80Hz)
183 // -----------
184 // 4'40 / 2'00
185
186 if (irq)
187 dim.log("DRS calibration interrupted [%.1fs]".$((new Date()-tm)/1000));
188 else
189 dim.log("DRS calibration done [%.1fs]".$((new Date()-tm)/1000));
190}
191
192// ================================================================
193// Code related to the lid
194// ================================================================
195
196function OpenLid()
197{
198 /*
199 while (Sun.horizon(-13).isUp)
200 {
201 var now = new Date();
202 var minutes_until_sunset = (Sun.horizon(-13).set - now)/60000;
203 console.out(now.toUTCString()+": Sun above FACT-horizon, lid cannot be opened: sleeping 1min, remaining %.1fmin".$(minutes_until_sunset));
204 v8.sleep(60000);
205 }*/
206
207 var isClosed = dim.state("LID_CONTROL").name=="Closed";
208 var isInconsistent = dim.state("LID_CONTROL").name=="Inconsistent";
209
210 var tm = new Date();
211
212 // Wait for lid to be open
213 if (isClosed || isInconsistent)
214 {
215 dim.log("Opening lid");
216 dim.send("LID_CONTROL/OPEN");
217
218 dim.log("Turning off IR camera LEDs...");
219
220 var cam = new Curl("fact@cam/cgi-bin/user/Config.cgi");
221 cam.data.push("action=set");
222 cam.data.push("Camera.System.Title=Camera1");
223 cam.data.push("Camera.General.IRControl.Value=2");
224 cam.data.push("Camera.System.Display=ALL");
225 cam.data.push("Camera.Environment=OUTDOOR");
226 var ret = cam.send();
227 dim.log("Camera response: "+ret.data.replace(/\n/g,"/")+" ["+ret.rc+"]");
228 }
229 dim.wait("LID_CONTROL", "Open", 30000);
230
231 if (isClosed || isInconsistent)
232 dim.log("Lid open [%.1fs]".$((new Date()-tm)/1000));
233}
234
235function CloseLid()
236{
237 var isOpen = dim.state("LID_CONTROL").name=="Open";
238
239 var tm = new Date();
240
241 // Wait for lid to be open
242 if (isOpen)
243 {
244 if (dim.state("FTM_CONTROL").name=="TriggerOn")
245 {
246 dim.send("FTM_CONTROL/STOP_TRIGGER");
247 dim.wait("FTM_CONTROL", "Valid", 3000);
248 }
249
250 dim.log("Closing lid.");
251 dim.send("LID_CONTROL/CLOSE");
252 }
253 v8.timeout(30000, function() { if (dim.state("LID_CONTROL").name=="Closed" || dim.state("LID_CONTROL").name=="Inconsistent") return true; });
254 //dim.wait("LID_CONTROL", "Closed", 30000);
255 //dim.wait("LID_CONTROL", "Inconsistent", 30000);
256
257 if (isOpen)
258 dim.log("Lid closed [%.1fs]".$((new Date()-tm)/1000));
259}
260
261// ================================================================
262// Interrupt data taking in case of high currents
263// ================================================================
264dim.onchange['FEEDBACK'] = function(state)
265{
266 if ((state.name=="Critical" || state.name=="OnStandby") &&
267 (this.prev!="Critical" && this.prev!="OnStandby"))
268 {
269 console.out("Feedback state changed from "+this.prev+" to "+state.name+" [Main.js]");
270 irq = "RESCHEDULE";
271 }
272 this.prev=state.name;
273}
274
275// ================================================================
276// Code related to switching bias voltage on and off
277// ================================================================
278
279var service_feedback = new Subscription("FEEDBACK/CALIBRATED_CURRENTS");
280
281service_feedback.onchange = function(evt)
282{
283 if (!evt.data)
284 return;
285
286 if (this.ok==undefined)
287 return;
288
289 var Unom = evt.obj['U_nom'];
290 var Uov = evt.obj['U_ov'];
291 if (!Uov)
292 return;
293
294 var cnt = 0;
295 var avg = 0;
296 for (var i=0; i<320; i++)
297 {
298 // This is a fix for the channel with a shortcut
299 if (i==272)
300 continue;
301
302 var dU = Uov[i]-Unom;
303
304 // 0.022 corresponds to 1 DAC count (90V/4096)
305 if (Math.abs(dU)>0.033)
306 cnt++;
307
308 avg += dU;
309 }
310 avg /= 320;
311
312 this.ok = cnt<3;// || (this.last!=undefined && Math.abs(this.last-avg)<0.002);
313
314 console.out(" DeltaUov=%.3f (%.3f) [N(>0.033V)=%d]".$(avg, avg-this.last, cnt));
315
316 this.last = avg;
317}
318
319service_feedback.voltageOff = function()
320{
321 var state = dim.state("BIAS_CONTROL").name;
322
323 if (state=="Disconnected")
324 {
325 console.out(" Voltage off: bias crate disconnected!");
326 return;
327 }
328
329 // check of feedback has to be switched on
330 var isOn = state=="VoltageOn" || state=="Ramping";
331 if (isOn)
332 {
333 dim.log("Switching voltage off.");
334
335 if (dim.state("FTM_CONTROL").name=="TriggerOn")
336 {
337 dim.send("FTM_CONTROL/STOP_TRIGGER");
338 dim.wait("FTM_CONTROL", "Valid", 3000);
339 }
340
341 // Supress the possibility that the bias control is
342 // ramping and will reject the command to switch the
343 // voltage off
344 //dim.send("FEEDBACK/STOP");
345 //dim.wait("FEEDBACK", "Calibrated", 3000);
346
347 // Make sure we are not in Ramping anymore
348 //dim.wait("BIAS_CONTROL", "VoltageOn", 3000);
349
350 // Switch voltage off
351 dim.send("BIAS_CONTROL/SET_ZERO_VOLTAGE");
352 }
353
354 dim.wait("BIAS_CONTROL", "VoltageOff", 60000); // FIXME: 30000?
355 dim.wait("FEEDBACK", "Calibrated", 3000);
356
357 // FEEDBACK stays in CurrentCtrl when Voltage is off but output enabled
358 // dim.wait("FEEDBACK", "CurrentCtrlIdle", 1000);
359
360 if (isOn)
361 dim.log("Voltage off.");
362}
363
364// DN: The name of the method voltageOn() in the context of the method
365// voltageOff() is a little bit misleading, since when voltageOff() returns
366// the caller can be sure the voltage is off, but when voltageOn() return
367// this is not the case, in the sense, that the caller can now take data.
368// instead the caller of voltageOn() *must* call waitForVoltageOn() afterwards
369// in order to safely take good-quality data.
370// This could lead to nasty bugs in the sense, that the second call might
371// be forgotten by somebody
372//
373// so I suggest to rename voltageOn() --> prepareVoltageOn()
374// waitForVoltageOn() stays as it is
375// and one creates a third method called:voltageOn() like this
376/* service_feedback.voltageOn = function()
377 * {
378 * this.prepareVoltageOn();
379 * this.waitForVoltageOn();
380 * }
381 *
382 * */
383// For convenience.
384
385service_feedback.voltageOn = function(ov)
386{
387 if (isNaN(ov))
388 ov = 1.1;
389
390 if (this.ov!=ov && dim.state("FEEDBACK").name=="InProgress") // FIXME: Warning, OnStandby, Critical if (ov<this.ov)
391 {
392 dim.log("Stoping feedback.");
393 if (dim.state("FTM_CONTROL").name=="TriggerOn")
394 {
395 dim.send("FTM_CONTROL/STOP_TRIGGER");
396 dim.wait("FTM_CONTROL", "Valid", 3000);
397 }
398
399 dim.send("FEEDBACK/STOP");
400 dim.wait("FEEDBACK", "Calibrated", 3000);
401
402 // Make sure we are not in Ramping anymore
403 dim.wait("BIAS_CONTROL", "VoltageOn", 3000);
404 }
405
406 var isOff = dim.state("FEEDBACK").name=="Calibrated";
407 if (isOff)
408 {
409 dim.log("Switching voltage to Uov="+ov+"V.");
410
411 dim.send("FEEDBACK/START", ov);
412
413 // FIXME: We could miss "InProgress" if it immediately changes to "Warning"
414 // Maybe a dim.timeout state>8 ?
415 dim.wait("FEEDBACK", "InProgress", 45000);
416
417 this.ov = ov;
418 }
419
420 // Wait until voltage on
421 dim.wait("BIAS_CONTROL", "VoltageOn", 60000); // FIXME: 30000?
422}
423
424service_feedback.waitForVoltageOn = function()
425{
426 // Avoid output if condition is already fulfilled
427 dim.log("Waiting for voltage to be stable.");
428
429 function func()
430 {
431 if (irq || this.ok==true)
432 return true;
433 }
434
435 var now = new Date();
436
437 this.last = undefined;
438 this.ok = false;
439 v8.timeout(4*60000, func, this); // FIMXE: Remove 4!
440 this.ok = undefined;
441
442 if (irq)
443 dim.log("Waiting for stable voltage interrupted.");
444 else
445 dim.log("Voltage stable within limits");
446}
447
448// ================================================================
449// Function to shutdown the system
450// ================================================================
451
452function Shutdown(type)
453{
454 if (!type)
455 type = "default";
456
457 dim.log("Starting shutdown ["+type+"].");
458
459 var now1 = new Date();
460
461 var bias = dim.state("BIAS_CONTROL").name;
462 if (bias=="VoltageOn" || bias=="Ramping")
463 service_feedback.voltageOn(0);
464
465 CloseLid();
466
467 var now2 = new Date();
468
469 dim.send("DRIVE_CONTROL/PARK");
470
471 console.out("","Waiting for telescope to park. This may take a while.");
472
473 // FIXME: This might not work is the drive is already close to park position
474 //dim.wait("DRIVE_CONTROL", "Parking", 3000);
475
476 /*
477 // Check if DRS calibration is necessary
478 var diff = getTimeSinceLastDrsCalib();
479 if (diff>30 || diff==null)
480 {
481 doDrsCalibration("singlepe"); // will turn voltage off
482 if (irq)
483 break;
484 }*/
485
486 //take single pe run if required
487 if (type=="singlepe")
488 {
489 dim.log("Taking single-pe run.");
490
491 // The voltage must be on
492 service_feedback.voltageOn();
493 service_feedback.waitForVoltageOn();
494
495 // Before we can switch to 3000 we have to make the right DRS calibration
496 dim.log("Taking single p.e. run.");
497 while (!irq && !takeRun("single-pe", 10000));
498
499 /*
500 Maybe we need to send a trigger... but data runs contain pedestal triggers... so it should work in any case...
501 var customRun = function()
502 {
503 v8.sleep(500);//wait that configuration is set
504 dim.wait("FTM_CONTROL", "TriggerOn", 15000);
505 dim.send("FAD_CONTROL/SEND_SINGLE_TRIGGER");
506 dim.send("RATE_CONTROL/STOP");
507 dim.send("FTM_CONTROL/STOP_TRIGGER");
508 dim.wait("FTM_CONTROL", "Valid", 3000);
509 dim.send("FTM_CONTROL/ENABLE_TRIGGER", true);
510 dim.send("FTM_CONTROL/SET_TIME_MARKER_DELAY", 123);
511 dim.send("FTM_CONTROL/SET_THRESHOLD", -1, obs[sub].threshold);
512 v8.sleep(500);//wait that configuration is set
513 dim.send("FTM_CONTROL/START_TRIGGER");
514 dim.wait("FTM_CONTROL", "TriggerOn", 15000);
515 }*/
516 }
517
518 //wait until drive is in locked (after it reached park position)
519 dim.wait("DRIVE_CONTROL", "Locked", 150000);
520
521 //unlock drive if task was sleep
522 if (type=="sleep")
523 dim.send("DRIVE_CONTROL/UNLOCK");
524
525
526 // It is unclear what comes next, so we better switch off the voltage
527 service_feedback.voltageOff();
528
529 dim.log("Finishing shutdown.");
530
531 var now3 = new Date();
532
533 dim.send("FTM_CONTROL/STOP_TRIGGER");
534 dim.wait("FTM_CONTROL", "Valid", 3000);
535
536 if (bias!="Disconnected")
537 dim.wait("FEEDBACK", "Calibrated", 3000);
538
539 if (type!="sleep")
540 {
541 dim.send("BIAS_CONTROL/DISCONNECT");
542
543 var pwrctrl_state = dim.state("PWR_CONTROL").name;
544 if (pwrctrl_state=="SystemOn" ||
545 pwrctrl_state=="BiasOff" ||
546 pwrctrl_state=="DriveOn")
547 dim.send("PWR_CONTROL/TOGGLE_DRIVE");
548
549 dim.wait("BIAS_CONTROL", "Disconnected", 3000);
550 dim.wait("PWR_CONTROL", "DriveOff", 6000);
551 }
552
553 var sub = new Subscription("DRIVE_CONTROL/POINTING_POSITION");
554 sub.get(5000); // FIXME: Proper error message in case of failure
555
556 var report = sub.get();
557
558 console.out("");
559 console.out("Shutdown procedure ["+type+"] seems to be finished...");
560 console.out(" "+new Date().toUTCString());
561 console.out(" Telescope at Zd=%.1fdeg Az=%.1fdeg".$(report.obj['Zd'], report.obj['Az']));
562 console.out(" Please check on the web cam that the park position was reached");
563 console.out(" and the telescope is not moving anymore.");
564 console.out(" Please check visually that the lid is really closed and");
565 console.out(" that the biasctrl really switched the voltage off.", "");
566 console.out(" DRIVE_CONTROL: "+dim.state("DRIVE_CONTROL").name);
567 console.out(" FEEDBACK: "+dim.state("FEEDBACK").name);
568 console.out(" FTM_CONTROL: "+dim.state("FTM_CONTROL").name);
569 console.out(" BIAS_CONTROL: "+dim.state("BIAS_CONTROL").name);
570 console.out(" PWR_CONTROL: "+dim.state("PWR_CONTROL").name);
571 console.out("");
572 dim.log("Shutdown: end ["+(now2-now1)/1000+"s, "+(now3-now2)/1000+"s, "+(new Date()-now3)/1000+"s]");
573 console.out("");
574
575 sub.close();
576}
577
578
579// ================================================================
580// Function to set the system to sleep-mode
581// ================================================================
582// FIXME: do not repeat code from shutdown-function
583/*
584function GoToSleep()
585{
586 CloseLid();
587
588 var isArmed = dim.state("DRIVE_CONTROL").name=="Armed";
589 if (!isArmed)
590 {
591 dim.log("Drive not ready to move. -> send STOP");
592 dim.send("DRIVE_CONTROL/STOP");
593 dim.wait("DRIVE_CONTROL", "Armed", 5000);
594 }
595
596 dim.send("DRIVE_CONTROL/MOVE_TO 101 0");//park position
597 var sub = new Subscription("DRIVE_CONTROL/POINTING_POSITION");
598 sub.get(5000); // FIXME: Proper error message in case of failure
599
600 function func()
601 {
602 var report = sub.get();
603
604 var zd = report.obj['Zd'];
605 var az = report.obj['Az'];
606
607 if (zd>100 && Math.abs(az)<1)
608 return true;
609
610 return undefined;
611 }
612
613 try { v8.timeout(150000, func); }
614 catch (e)
615 {
616 var p = sub.get();
617 dim.log('Park position not reached? Telescope at Zd='+p.obj['Zd']+' Az='+p.obj['Az']);
618 }
619 var p2 = sub.get();
620 dim.log('Telescope at Zd=%.1fdeg Az=%.1fdeg'.$(p2.obj['Zd'], p2.obj['Az']));
621 sub.close();
622}
623*/
624
625// ================================================================
626// Check datalogger subscriptions
627// ================================================================
628
629var datalogger_subscriptions = new Subscription("DATA_LOGGER/SUBSCRIPTIONS");
630datalogger_subscriptions.get(3000, false);
631
632datalogger_subscriptions.check = function()
633{
634 var obj = this.get();
635 if (!obj.data)
636 throw new Error("DATA_LOGGER/SUBSCRIPTIONS not available.");
637
638 var expected =
639 [
640 "AGILENT_CONTROL_24V/DATA",
641 "AGILENT_CONTROL_50V/DATA",
642 "AGILENT_CONTROL_80V/DATA",
643 "BIAS_CONTROL/CURRENT",
644 "BIAS_CONTROL/DAC",
645 "BIAS_CONTROL/NOMINAL",
646 "BIAS_CONTROL/VOLTAGE",
647 "DRIVE_CONTROL/POINTING_POSITION",
648 "DRIVE_CONTROL/SOURCE_POSITION",
649 "DRIVE_CONTROL/STATUS",
650 "DRIVE_CONTROL/TRACKING_POSITION",
651 "FAD_CONTROL/CONNECTIONS",
652 "FAD_CONTROL/DAC",
653 "FAD_CONTROL/DNA",
654 "FAD_CONTROL/DRS_RUNS",
655 "FAD_CONTROL/EVENTS",
656 "FAD_CONTROL/FEEDBACK_DATA",
657 "FAD_CONTROL/FILE_FORMAT",
658 "FAD_CONTROL/FIRMWARE_VERSION",
659 "FAD_CONTROL/INCOMPLETE",
660 "FAD_CONTROL/PRESCALER",
661 "FAD_CONTROL/REFERENCE_CLOCK",
662 "FAD_CONTROL/REGION_OF_INTEREST",
663 "FAD_CONTROL/RUNS",
664 "FAD_CONTROL/RUN_NUMBER",
665 "FAD_CONTROL/START_RUN",
666 "FAD_CONTROL/STATISTICS1",
667 "FAD_CONTROL/STATS",
668 "FAD_CONTROL/STATUS",
669 "FAD_CONTROL/TEMPERATURE",
670 "FEEDBACK/CALIBRATED_CURRENTS",
671 "FEEDBACK/CALIBRATION",
672 "FEEDBACK/CALIBRATION_R8",
673 "FEEDBACK/CALIBRATION_STEPS",
674/* "FEEDBACK/REFERENCE",*/
675 "FSC_CONTROL/CURRENT",
676 "FSC_CONTROL/HUMIDITY",
677 "FSC_CONTROL/TEMPERATURE",
678 "FSC_CONTROL/VOLTAGE",
679 "FTM_CONTROL/COUNTER",
680 "FTM_CONTROL/DYNAMIC_DATA",
681 "FTM_CONTROL/ERROR",
682 "FTM_CONTROL/FTU_LIST",
683 "FTM_CONTROL/PASSPORT",
684 "FTM_CONTROL/STATIC_DATA",
685 "FTM_CONTROL/TRIGGER_RATES",
686 "GPS_CONTROL/NEMA",
687 "SQM_CONTROL/DATA",
688 "LID_CONTROL/DATA",
689 "MAGIC_LIDAR/DATA",
690 "MAGIC_WEATHER/DATA",
691 "MCP/CONFIGURATION",
692 "PWR_CONTROL/DATA",
693 "RATE_CONTROL/THRESHOLD",
694 "RATE_SCAN/DATA",
695 "RATE_SCAN/PROCESS_DATA",
696 "TEMPERATURE/DATA",
697 "TIME_CHECK/OFFSET",
698 "TNG_WEATHER/DATA",
699 "TNG_WEATHER/DUST",
700 "PFMINI_CONTROL/DATA",
701 ];
702
703 function map(entry)
704 {
705 if (entry.length==0)
706 return undefined;
707
708 var rc = entry.split(',');
709 if (rc.length!=2)
710 throw new Error("Subscription list entry '"+entry+"' has wrong number of elements.");
711 return rc;
712 }
713
714 var list = obj.data.split('\n').map(map);
715 function check(name)
716 {
717 if (list.every(function(el){return el==undefined || el[0]!=name;}))
718 throw new Error("Subscription to '"+name+"' not available.");
719 }
720
721 expected.forEach(check);
722}
723
724
725
726// ================================================================
727// Crosscheck all states
728// ================================================================
729
730// ----------------------------------------------------------------
731// Do a standard startup to bring the system in into a well
732// defined state
733// ----------------------------------------------------------------
734include('scripts/Startup.js');
735
736// ================================================================
737// Code to monitor clock conditioner
738// ================================================================
739
740var sub_counter = new Subscription("FTM_CONTROL/COUNTER");
741sub_counter.onchange = function(evt)
742{
743 if (evt.qos>0 && evt.qos!=2 && evt.qos&0x100==0)
744 throw new Error("FTM reports: clock conditioner not locked.");
745}
746
747// ================================================================
748// Code related to monitoring the fad system
749// ================================================================
750
751// This code is here, because scripts/Startup.js needs the
752// same subscriptions... to be revised.
753var sub_incomplete = new Subscription("FAD_CONTROL/INCOMPLETE");
754var sub_connections = new Subscription("FAD_CONTROL/CONNECTIONS");
755var sub_startrun = new Subscription("FAD_CONTROL/START_RUN");
756sub_startrun.get(5000);
757
758include('scripts/takeRun.js');
759
760// ----------------------------------------------------------------
761// Check that everything we need is availabel to receive commands
762// (FIXME: Should that go to the general CheckState?)
763// ----------------------------------------------------------------
764//console.out("Checking send.");
765checkSend(["MCP", "DRIVE_CONTROL", "LID_CONTROL", "FAD_CONTROL", "FEEDBACK"]);
766//console.out("Checking send: done");
767
768// ----------------------------------------------------------------
769// Bring feedback into the correct operational state
770// ----------------------------------------------------------------
771//console.out("Feedback init: start.");
772service_feedback.get(5000);
773
774// ----------------------------------------------------------------
775// Connect to the DRS_RUNS service
776// ----------------------------------------------------------------
777//console.out("Drs runs init: start.");
778
779var sub_drsruns = new Subscription("FAD_CONTROL/DRS_RUNS");
780sub_drsruns.get(5000);
781// FIXME: Check if the last DRS calibration was complete?
782
783function getTimeSinceLastDrsCalib()
784{
785 // ----- Time since last DRS Calibration [min] ------
786 var runs = sub_drsruns.get(0);
787 var diff = (new Date()-runs.time)/60000;
788
789 // Warning: 'roi=300' is a number which is not intrisically fixed
790 // but can change depending on the taste of the observers
791 var valid = runs.obj['run'][2]>0 && runs.obj['roi']==300;
792
793 if (valid)
794 dim.log("Last DRS calibration was %.1fmin ago".$(diff));
795 else
796 dim.log("No valid DRS calibration available.");
797
798 return valid ? diff : null;
799}
800
801// ----------------------------------------------------------------
802// Install interrupt handler
803// ----------------------------------------------------------------
804function handleIrq(cmd, args, time, user)
805{
806 console.out("Interrupt received:");
807 console.out(" IRQ: "+cmd);
808 console.out(" Time: "+time);
809 console.out(" User: "+user);
810
811 irq = cmd ? cmd : "stop";
812
813 // This will end a run in progress as if it where correctly stopped
814 if (dim.state("MCP").name=="TakingData")
815 dim.send("MCP/STOP");
816
817 // This will stop a rate scan in progress
818 if (dim.state("RATE_SCAN").name=="InProgress")
819 dim.send("RATE_SCAN/STOP");
820}
821
822dimctrl.setInterruptHandler(handleIrq);
823
824// ----------------------------------------------------------------
825// Make sure we will write files
826// ----------------------------------------------------------------
827dim.send("FAD_CONTROL/SET_FILE_FORMAT", 6);
828
829// ----------------------------------------------------------------
830// Print some information for the user about the
831// expected first oberservation
832// ----------------------------------------------------------------
833var test = getObservation();
834if (test!=undefined)
835{
836 var n = new Date();
837 if (observations.length>0 && test==-1)
838 dim.log("First observation scheduled for "+observations[0].start.toUTCString()+" [id="+observations[0].id+"]");
839 if (test>=0 && test<observations.length)
840 dim.log("First observation should start immediately ["+observations[test].start.toUTCString()+", id="+observations[test].id+"]");
841 if (observations.length>0 && observations[0].start>n+12*3600*1000)
842 dim.log("No observations scheduled for the next 12 hours!");
843 if (observations.length==0)
844 dim.log("No observations scheduled!");
845}
846
847// ----------------------------------------------------------------
848// Start main loop
849// ----------------------------------------------------------------
850dim.log("Entering main loop.");
851console.out("");
852
853var run = -2; // getObservation never called
854var sub;
855var lastId;
856var nextId;
857var sun = Sun.horizon(-12);
858var system_on; // undefined
859
860function processIrq()
861{
862 if (!irq)
863 return false;
864
865 if (irq.toUpperCase()=="RESCHEDULE")
866 {
867 irq = undefined;
868 return false;
869 }
870
871 if (irq.toUpperCase()=="OFF")
872 {
873 service_feedback.voltageOff();
874 dim.send("FAD_CONTROL/CLOSE_OPEN_FILES");
875 return true;
876 }
877
878 /*
879 if (irq.toUpperCase()=="STOP")
880 {
881 dim.send("FAD_CONTROL/CLOSE_OPEN_FILES");
882 dim.send("MCP/STOP");
883 return true;
884 }*/
885
886 if (irq.toUpperCase()=="SHUTDOWN")
887 {
888 Shutdown();
889 return true;
890 }
891
892 dim.log("IRQ "+irq+" unhandled... stopping script.");
893 return true;
894}
895
896while (!processIrq())
897{
898 // Check if observation position is still valid
899 // If source position has changed, set run=0
900 var idxObs = getObservation();
901 if (idxObs===undefined)
902 break;
903
904 // we are still waiting for the first observation in the schedule
905 if (idxObs==-1)
906 {
907 // flag that the first observation will be in the future
908 run = -1;
909 v8.sleep(1000);
910 continue;
911 }
912
913 // Check if we have to take action do to sun-rise
914 var was_up = sun.isUp;
915 sun = Sun.horizon(-12);
916 if (!was_up && sun.isUp)
917 {
918 console.out("");
919 dim.log("Sun rise detected.... automatic shutdown initiated!");
920 // FIXME: State check?
921 Shutdown();
922 system_on = false;
923 continue;
924 }
925
926 // Current and next observation target
927 var obs = observations[idxObs];
928 var nextObs = observations[idxObs+1];
929
930 // Check if observation target has changed
931 if (lastId!=obs.id) // !Object.isEqual(obs, nextObs)
932 {
933 dim.log("Starting new observation ["+obs.start.toUTCString()+", id="+obs.id+"]");
934
935 // This is the first source, but we do not come from
936 // a scheduled 'START', so we have to check if the
937 // telescop is operational already
938 sub = 0;
939 if (run<0)
940 {
941 //Startup(); // -> Bias On/Off?, Lid open/closed?
942 //CloseLid();
943 }
944
945 // The first observation had a start-time in the past...
946 // In this particular case start with the last entry
947 // in the list of measurements
948 if (run==-2)
949 sub = obs.length-1;
950
951 run = 0;
952 lastId = obs.id;
953 }
954
955 //dim.log("DEBUG: Next observation scheduled for "+nextObs.start.toUTCString()+" [id="+nextObs.id+"]");
956 if (nextObs && nextId!=nextObs.id)
957 {
958 dim.log("Next observation scheduled for "+nextObs.start.toUTCString()+" [id="+nextObs.id+"]");
959 console.out("");
960 nextId = nextObs.id;
961 }
962
963 if (!nextObs && nextId)
964 {
965 if (obs[sub].task=="SUSPEND")
966 dim.log("Further observation suspended.");
967 else
968 dim.log("No further observation scheduled.");
969 console.out("");
970 nextId = undefined;
971 }
972
973 //if (nextObs==undefined && obs[obs.length-1].task!="SHUTDOWN")
974 // throw Error("Last scheduled measurement must be a shutdown.");
975
976 // We are done with all measurement slots for this
977 // observation... wait for next observation
978 if (sub>=obs.length)
979 {
980 v8.sleep(1000);
981 continue;
982 }
983
984 if (system_on===false && obs[sub].task!="STARTUP")
985 {
986 v8.sleep(1000);
987 continue;
988 }
989
990 // Check if sun is still up... only DATA and */
991 if ((obs[sub].task=="DATA" || obs[sub].task=="RATESCAN" || obs[sub].task=="RATESCAN2" ) && sun.isUp)
992 {
993 var now = new Date();
994 var remaining = (sun.set - now)/60000;
995 console.out(now.toUTCString()+" - "+obs[sub].task+": Sun above FACT-horizon: sleeping 1min, remaining %.1fmin".$(remaining));
996 v8.sleep(60000);
997 continue;
998 }
999
1000
1001 if (obs[sub].task!="IDLE" && (obs[sub].task!="DATA" && run>0))
1002 dim.log("New task ["+obs[sub]+"]");
1003
1004 // FIXME: Maybe print a warning if Drive is on during day time!
1005
1006 // It is not ideal that we allow the drive to be on during day time, but
1007 // otherwise it is difficult to allow e.g. the STARTUP at the beginning of the night
1008 var power_states = sun.isUp || !system_on ? [ "DriveOff", "SystemOn" ] : [ "SystemOn" ];
1009 var drive_states = sun.isUp || !system_on ? undefined : [ "Initialized", "Tracking", "OnTrack" ];
1010
1011 // A scheduled task was found, lets check if all servers are
1012 // still only and in reasonable states. If this is not the case,
1013 // something unexpected must have happend and the script is aborted.
1014 //console.out(" Checking states [general]");
1015 var table =
1016 [
1017 [ "TNG_WEATHER" ],
1018 [ "MAGIC_WEATHER" ],
1019 [ "CHAT" ],
1020 [ "SMART_FACT" ],
1021 [ "TEMPERATURE" ],
1022 [ "DATA_LOGGER", [ "NightlyFileOpen", "WaitForRun", "Logging" ] ],
1023 [ "FSC_CONTROL", [ "Connected" ] ],
1024 [ "MCP", [ "Idle" ] ],
1025 [ "TIME_CHECK", [ "Valid" ] ],
1026 [ "PWR_CONTROL", power_states/*[ "SystemOn" ]*/ ],
1027 [ "AGILENT_CONTROL_24V", [ "VoltageOn" ] ],
1028 [ "AGILENT_CONTROL_50V", [ "VoltageOn" ] ],
1029 [ "AGILENT_CONTROL_80V", [ "VoltageOn" ] ],
1030 [ "BIAS_CONTROL", [ "VoltageOff", "VoltageOn", "Ramping" ] ],
1031 [ "FEEDBACK", [ "Calibrated", "InProgress", "OnStandby", "Warning", "Critical" ] ],
1032// [ "LID_CONTROL", [ "Open", "Closed" ] ],
1033 [ "LID_CONTROL", [ "Open", "Closed", "Inconsistent" ] ],
1034 [ "DRIVE_CONTROL", drive_states/*[ "Armed", "Tracking", "OnTrack" ]*/ ],
1035 [ "FTM_CONTROL", [ "Valid", "TriggerOn" ] ],
1036 [ "FAD_CONTROL", [ "Connected", "RunInProgress" ] ],
1037 [ "RATE_SCAN", [ "Connected" ] ],
1038 [ "RATE_CONTROL", [ "Connected", "GlobalThresholdSet", "InProgress" ] ],
1039 [ "GPS_CONTROL", [ "Locked" ] ],
1040 [ "SQM_CONTROL", [ "Disconnected", "Connected", "Valid" ] ],
1041 [ "PFMINI_CONTROL", [ "Disconnected", "Connected", "Receiving" ] ],
1042 ];
1043
1044
1045 if (!checkStates(table))
1046 {
1047 throw new Error("Something unexpected has happened. One of the servers "+
1048 "is in a state in which it should not be. Please,"+
1049 "try to find out what happened...");
1050 }
1051
1052 datalogger_subscriptions.check();
1053
1054 // If this is an observation which needs the voltage to be swicthed on
1055 // skip that if the voltage is not stable
1056 /*
1057 if (obs[sub].task=="DATA" || obs[sub].task=="RATESCAN")
1058 {
1059 var state = dim.state("FEEDBACK").name;
1060 if (state=="Warning" || state=="Critical" || state=="OnStandby")
1061 {
1062 v8.sleep(1000);
1063 continue;
1064 }
1065 }*/
1066
1067
1068 // Check if obs.task is one of the one-time-tasks
1069 switch (obs[sub].task)
1070 {
1071 case "IDLE":
1072 v8.sleep(5000);
1073 continue;
1074
1075 case "SUSPEND":
1076 case "SLEEP":
1077 Shutdown("sleep"); //GoToSleep();
1078
1079 dim.log("Task finished ["+obs[sub].task+"].");
1080 console.out("");
1081 sub++;
1082 continue;
1083
1084 case "STARTUP":
1085 CloseLid();
1086
1087 doDrsCalibration("startup"); // will switch the voltage off
1088
1089 if (irq)
1090 break;
1091
1092 service_feedback.voltageOn();
1093 service_feedback.waitForVoltageOn();
1094
1095 // Before we can switch to 3000 we have to make the right DRS calibration
1096 dim.log("Taking single p.e. run.");
1097 while (!irq && !takeRun("single-pe", 10000));
1098
1099 // It is unclear what comes next, so we better switch off the voltage
1100 service_feedback.voltageOff();
1101
1102 system_on = true;
1103 dim.log("Task finished [STARTUP]");
1104 console.out("");
1105 break;
1106
1107 case "SHUTDOWN":
1108 Shutdown("singlepe");
1109 system_on = false;
1110
1111 // FIXME: Avoid new observations after a shutdown until
1112 // the next startup (set run back to -2?)
1113 sub++;
1114 dim.log("Task finished [SHUTDOWN]");
1115 console.out("");
1116 //console.out(" Waiting for next startup.", "");
1117 continue;
1118
1119 case "DRSCALIB":
1120 doDrsCalibration("drscalib"); // will switch the voltage off
1121 dim.log("Task finished [DRSCALIB]");
1122 console.out("");
1123 break;
1124
1125 case "SINGLEPE":
1126 // The lid must be closes
1127 CloseLid();
1128
1129 // Check if DRS calibration is necessary
1130 var diff = getTimeSinceLastDrsCalib();
1131 if (diff>30 || diff==null)
1132 {
1133 doDrsCalibration("singlepe"); // will turn voltage off
1134 if (irq)
1135 break;
1136 }
1137
1138 // The voltage must be on
1139 service_feedback.voltageOn();
1140 service_feedback.waitForVoltageOn();
1141
1142 // Before we can switch to 3000 we have to make the right DRS calibration
1143 dim.log("Taking single p.e. run.");
1144 while (!irq && !takeRun("single-pe", 10000));
1145
1146 // It is unclear what comes next, so we better switch off the voltage
1147 service_feedback.voltageOff();
1148 dim.log("Task finished [SINGLE-PE]");
1149 console.out("");
1150 break;
1151
1152 case "OVTEST":
1153 var locked = dim.state("DRIVE_CONTROL").name=="Locked";
1154 if (!locked)
1155 dim.send("DRIVE_CONTROL/PARK");
1156
1157 dim.send("FEEDBACK/STOP");
1158
1159 // The lid must be closed
1160 CloseLid();
1161
1162 if (!locked)
1163 {
1164 //console.out("Waiting for telescope to park. This may take a while.");
1165 dim.wait("DRIVE_CONTROL", "Locked", 3000);
1166 dim.send("DRIVE_CONTROL/UNLOCK");
1167 }
1168
1169 // Check if DRS calibration is necessary
1170 var diff = getTimeSinceLastDrsCalib();
1171 if (diff>30 || diff==null)
1172 {
1173 doDrsCalibration("ovtest"); // will turn voltage off
1174 if (irq)
1175 break;
1176 }
1177
1178 // The voltage must be on
1179 service_feedback.voltageOn(0.4);
1180 service_feedback.waitForVoltageOn();
1181
1182 dim.log("Taking single p.e. run (0.4V)");
1183 while (!irq && !takeRun("single-pe", 10000));
1184
1185 for (var i=5; i<18 && !irq; i++)
1186 {
1187 dim.send("FEEDBACK/STOP");
1188 dim.wait("FEEDBACK", "Calibrated", 3000);
1189 dim.wait("BIAS_CONTROL", "VoltageOn", 3000);
1190 dim.send("FEEDBACK/START", i*0.1);
1191 dim.wait("FEEDBACK", "InProgress", 45000);
1192 dim.wait("BIAS_CONTROL", "VoltageOn", 60000); // FIXME: 30000?
1193 service_feedback.waitForVoltageOn();
1194 dim.log("Taking single p.e. run ("+(i*0.1)+"V)");
1195 while (!irq && !takeRun("single-pe", 10000));
1196 }
1197
1198 // It is unclear what comes next, so we better switch off the voltage
1199 service_feedback.voltageOff();
1200 dim.log("Task finished [OVTEST]");
1201 console.out("");
1202 break;
1203
1204 case "RATESCAN":
1205 var tm1 = new Date();
1206
1207 // This is a workaround to make sure that we really catch
1208 // the new OnTrack state later and not the old one
1209 dim.send("DRIVE_CONTROL/STOP");
1210 dim.wait("DRIVE_CONTROL", "Initialized", 15000);
1211
1212 // The lid must be open
1213 OpenLid();
1214
1215 // Switch the voltage to a reduced level (Ubd)
1216 service_feedback.voltageOn(0);
1217
1218 if (obs[sub].source != null) // undefined != null -> false
1219 {
1220 dim.log("Pointing telescope to '"+obs[sub].source+"'.");
1221 dim.send("DRIVE_CONTROL/TRACK_ON", obs[sub].source);
1222 }
1223 else
1224 {
1225 dim.log("Pointing telescope to ra="+obs[sub].ra+" dec="+obs[sub].dec);
1226 dim.send("DRIVE_CONTROL/TRACK", obs[sub].ra, obs[sub].dec);
1227 }
1228
1229 dim.wait("DRIVE_CONTROL", "OnTrack", 150000); // 110s for turning and 30s for stabilizing
1230
1231 // Now tracking stable, switch voltage to nominal level and wait
1232 // for stability.
1233 service_feedback.voltageOn();
1234 service_feedback.waitForVoltageOn();
1235
1236 if (!irq)
1237 {
1238 dim.log("Starting calibration.");
1239
1240 // Calibration (2% of 20')
1241 while (!irq)
1242 {
1243 if (irq || !takeRun("pedestal", 1000)) // 80 Hz -> 10s
1244 continue;
1245 //if (irq || !takeRun("light-pulser-ext", 1000)) // 80 Hz -> 10s
1246 // continue;
1247 break;
1248 }
1249
1250 var tm2 = new Date();
1251
1252 dim.log("Starting ratescan.");
1253
1254 //set reference to whole camera (in case it was changed)
1255 dim.send("RATE_SCAN/SET_REFERENCE_CAMERA");
1256 // Start rate scan
1257 dim.send("RATE_SCAN/START_THRESHOLD_SCAN", 50, 1000, -10, "default");
1258
1259 // Lets wait if the ratescan really starts... this might take a few
1260 // seconds because RATE_SCAN configures the ftm and is waiting for
1261 // it to be configured.
1262 dim.wait("RATE_SCAN", "InProgress", 10000);
1263 dim.wait("RATE_SCAN", "Connected", 2700000);
1264
1265 // Here one could implement a watchdog for the feedback as well, but what is the difference
1266 // whether finally one has to find out if the feedback was in the correct state
1267 // or the ratescan was interrupted?
1268
1269 // this line is actually some kind of hack.
1270 // after the Ratescan, no data is written to disk. I don't know why, but it happens all the time
1271 // So I decided to put this line here as a kind of patchwork....
1272 //dim.send("FAD_CONTROL/SET_FILE_FORMAT", 6);
1273
1274 dim.log("Ratescan done [%.1fs, %.1fs]".$((tm2-tm1)/1000, (new Date()-tm2)/1000));
1275 }
1276
1277 dim.log("Task finished [RATESCAN]");
1278 console.out("");
1279 break; // case "RATESCAN"
1280
1281 case "RATESCAN2":
1282 var tm1 = new Date();
1283
1284 // This is a workaround to make sure that we really catch
1285 // the new OnTrack state later and not the old one
1286 dim.send("DRIVE_CONTROL/STOP");
1287 dim.wait("DRIVE_CONTROL", "Initialized", 15000);
1288
1289 if (obs[sub].rstype=="dark-bias-off")
1290 service_feedback.voltageOff();
1291 else
1292 {
1293 // Switch the voltage to a reduced level (Ubd)
1294 var bias = dim.state("BIAS_CONTROL").name;
1295 if (bias=="VoltageOn" || bias=="Ramping")
1296 service_feedback.voltageOn(0);
1297 }
1298
1299 // Open the lid if required
1300 if (!obs[sub].lidclosed)
1301 OpenLid();
1302 else
1303 CloseLid();
1304
1305 // track source/position or move to position
1306 if (obs[sub].lidclosed)
1307 {
1308 dim.log("Moving telescope to zd="+obs[sub].zd+" az="+obs[sub].az);
1309 dim.send("DRIVE_CONTROL/MOVE_TO", obs[sub].zd, obs[sub].az);
1310 v8.sleep(3000);
1311 dim.wait("DRIVE_CONTROL", "Initialized", 150000); // 110s for turning and 30s for stabilizing
1312 }
1313 else
1314 {
1315 if (obs[sub].source != null) // undefined != null -> false
1316 {
1317 dim.log("Pointing telescope to '"+obs[sub].source+"'.");
1318 dim.send("DRIVE_CONTROL/TRACK_ON", obs[sub].source);
1319 }
1320 else
1321 {
1322 dim.log("Pointing telescope to ra="+obs[sub].ra+" dec="+obs[sub].dec);
1323 dim.send("DRIVE_CONTROL/TRACK", obs[sub].ra, obs[sub].dec);
1324 }
1325
1326 dim.wait("DRIVE_CONTROL", "OnTrack", 150000); // 110s for turning and 30s for stabilizing
1327 }
1328
1329 // Now tracking stable, switch voltage to nominal level and wait
1330 // for stability.
1331 if (obs[sub].rstype!="dark-bias-off")
1332 {
1333 service_feedback.voltageOn();
1334 service_feedback.waitForVoltageOn();
1335 }
1336
1337 if (!irq)
1338 {
1339 var tm2 = new Date();
1340
1341 dim.log("Starting ratescan 2/1 ["+obs[sub].rstype+"]");
1342
1343 //set reference to whole camera (in case it was changed)
1344 dim.send("RATE_SCAN/SET_REFERENCE_CAMERA");
1345 // Start rate scan
1346 dim.send("RATE_SCAN/START_THRESHOLD_SCAN", 50, 300, 20, obs[sub].rstype);
1347
1348 // Lets wait if the ratescan really starts... this might take a few
1349 // seconds because RATE_SCAN configures the ftm and is waiting for
1350 // it to be configured.
1351 dim.wait("RATE_SCAN", "InProgress", 10000);
1352 //FIXME: discuss what best value is here
1353 dim.wait("RATE_SCAN", "Connected", 2700000);//45min
1354 //dim.wait("RATE_SCAN", "Connected", 1200000);//3.3h
1355
1356 // Here one could implement a watchdog for the feedback as well, but what is the difference
1357 // whether finally one has to find out if the feedback was in the correct state
1358 // or the ratescan was interrupted?
1359
1360 // this line is actually some kind of hack.
1361 // after the Ratescan, no data is written to disk. I don't know why, but it happens all the time
1362 // So I decided to put this line here as a kind of patchwork....
1363 //dim.send("FAD_CONTROL/SET_FILE_FORMAT", 6);
1364
1365 dim.log("Ratescan 2/1 done [%.1fs, %.1fs]".$((tm2-tm1)/1000, (new Date()-tm2)/1000));
1366 }
1367
1368 if (!irq)
1369 {
1370 var tm2 = new Date();
1371
1372 dim.log("Starting ratescan 2/2 ["+obs[sub].rstype+"]");
1373
1374 // Start rate scan
1375 dim.send("RATE_SCAN/START_THRESHOLD_SCAN", 300, 1000, 100, obs[sub].rstype);
1376
1377 // Lets wait if the ratescan really starts... this might take a few
1378 // seconds because RATE_SCAN configures the ftm and is waiting for
1379 // it to be configured.
1380 dim.wait("RATE_SCAN", "InProgress", 10000);
1381 dim.wait("RATE_SCAN", "Connected", 2700000);
1382
1383 // Here one could implement a watchdog for the feedback as well, but what is the difference
1384 // whether finally one has to find out if the feedback was in the correct state
1385 // or the ratescan was interrupted?
1386
1387 // this line is actually some kind of hack.
1388 // after the Ratescan, no data is written to disk. I don't know why, but it happens all the time
1389 // So I decided to put this line here as a kind of patchwork....
1390 //dim.send("FAD_CONTROL/SET_FILE_FORMAT", 6);
1391
1392 dim.log("Ratescan 2/2 done [%.1fs, %.1fs]".$((tm2-tm1)/1000, (new Date()-tm2)/1000));
1393 }
1394
1395 dim.log("Task finished [RATESCAN2]");
1396 console.out("");
1397 break; // case "RATESCAN2"
1398
1399 case "CUSTOM":
1400
1401 // This is a workaround to make sure that we really catch
1402 // the new OnTrack state later and not the old one
1403 dim.send("DRIVE_CONTROL/STOP");
1404 dim.wait("DRIVE_CONTROL", "Initialized", 15000);
1405
1406 // Ramp bias if needed
1407 if (!obs[sub].biason)
1408 service_feedback.voltageOff();
1409 else
1410 {
1411 // Switch the voltage to a reduced level (Ubd)
1412 var bias = dim.state("BIAS_CONTROL").name;
1413 if (bias=="VoltageOn" || bias=="Ramping")
1414 service_feedback.voltageOn(0);
1415 }
1416 // Close lid
1417 CloseLid();
1418
1419 // Move to position (zd/az)
1420 dim.log("Moving telescope to zd="+obs[sub].zd+" az="+obs[sub].az);
1421 dim.send("DRIVE_CONTROL/MOVE_TO", obs[sub].zd, obs[sub].az);
1422 v8.sleep(3000);
1423 dim.wait("DRIVE_CONTROL", "Initialized", 150000); // 110s for turning and 30s for stabilizing
1424
1425 // Now tracking stable, switch voltage to nominal level and wait
1426 // for stability.
1427 if (obs[sub].biason)
1428 {
1429 service_feedback.voltageOn();
1430 service_feedback.waitForVoltageOn();
1431 }
1432
1433 if (!irq)
1434 {
1435 dim.log("Taking custom run with time "+obs[sub].time+"s, threshold="+obs[sub].threshold+", biason="+obs[sub].biason);
1436
1437 var customRun = function()
1438 {
1439 v8.sleep(500);//wait that configuration is set
1440 dim.wait("FTM_CONTROL", "TriggerOn", 15000);
1441 dim.send("FAD_CONTROL/SEND_SINGLE_TRIGGER");
1442 dim.send("RATE_CONTROL/STOP");
1443 dim.send("FTM_CONTROL/STOP_TRIGGER");
1444 dim.wait("FTM_CONTROL", "Valid", 3000);
1445 dim.send("FTM_CONTROL/ENABLE_TRIGGER", true);
1446 dim.send("FTM_CONTROL/SET_TIME_MARKER_DELAY", 123);
1447 dim.send("FTM_CONTROL/SET_THRESHOLD", -1, obs[sub].threshold);
1448 v8.sleep(500);//wait that configuration is set
1449 dim.send("FTM_CONTROL/START_TRIGGER");
1450 dim.wait("FTM_CONTROL", "TriggerOn", 15000);
1451 }
1452
1453 takeRun("custom", -1, obs[sub].time, customRun);
1454 }
1455 dim.log("Task finished [CUSTOM].");
1456 dim.log("");
1457 break; // case "CUSTOM"
1458
1459 case "DATA":
1460
1461 // ========================== case "DATA" ============================
1462 /*
1463 if (Sun.horizon("FACT").isUp)
1464 {
1465 console.out(" SHUTDOWN","");
1466 Shutdown();
1467 console.out(" Exit forced due to broken schedule", "");
1468 exit();
1469 }
1470 */
1471
1472 // Calculate remaining time for this observation in minutes
1473 var remaining = nextObs==undefined ? 0 : (nextObs.start-new Date())/60000;
1474 //dim.log("DEBUG: remaining: "+remaining+" nextObs="+nextObs+" start="+nextObs.start);
1475
1476 // ------------------------------------------------------------
1477
1478 dim.log("Run count "+run+" [remaining "+parseInt(remaining)+"min]");
1479
1480 // ----- Time since last DRS Calibration [min] ------
1481 var diff = getTimeSinceLastDrsCalib();
1482
1483 // Changine pointing position and take calibration...
1484 // ...every four runs (every ~20min)
1485 // ...if at least ten minutes of observation time are left
1486 // ...if this is the first run on the source
1487 var point = (run%4==0 && remaining>10 && !obs[sub].orbit) || run==0; // undefined==null -> true!
1488
1489 // Take DRS Calib...
1490 // ...every four runs (every ~20min)
1491 // ...at last every two hours
1492 // ...when DRS temperature has changed by more than 2deg (?)
1493 // ...when more than 15min of observation are left
1494 // ...no drs calibration was done yet
1495 var drscal = (run%4==0 && (remaining>15 && diff>70)) || diff==null;
1496
1497 if (point)
1498 {
1499 // Switch the voltage to a reduced voltage level
1500 service_feedback.voltageOn(0);
1501
1502 // Change wobble position every four runs,
1503 // start with alternating wobble positions each day
1504 var wobble = (parseInt(run/4) + parseInt(new Date()/1000/3600/24-0.5))%2+1;
1505 var angle = obs[sub].angle == null ? Math.random()*360 : obs[sub].angle;
1506
1507 if (obs[sub].orbit) // != undefined, != null, != 0
1508 dim.log("Pointing telescope to '"+obs[sub].source+"' [orbit="+obs[sub].orbit+"min, angle="+angle+"]");
1509 else
1510 dim.log("Pointing telescope to '"+obs[sub].source+"' [wobble="+wobble+"]");
1511
1512 // This is a workaround to make sure that we really catch
1513 // the new OnTrack state later and not the old one
1514 dim.send("DRIVE_CONTROL/STOP");
1515 dim.wait("DRIVE_CONTROL", "Initialized", 15000);
1516
1517 if (obs[sub].orbit) // != undefined, != null, != 0
1518 dim.send("DRIVE_CONTROL/TRACK_ORBIT", angle, obs[sub].orbit, obs[sub].source);
1519 else
1520 dim.send("DRIVE_CONTROL/TRACK_WOBBLE", wobble, obs[sub].source);
1521
1522 // Do we have to check if the telescope is really moving?
1523 // We can cross-check the SOURCE service later
1524 }
1525
1526 if (drscal)
1527 {
1528 doDrsCalibration("data"); // will turn voltage off
1529
1530 // Now we switch on the voltage and a significant amount of
1531 // time has been passed, so do the check again.
1532 sun = Sun.horizon(-12);
1533 if (!was_up && sun.isUp)
1534 {
1535 dim.log("Sun rise detected....");
1536 continue;
1537 }
1538 }
1539
1540 if (irq)
1541 continue;
1542
1543 OpenLid();
1544
1545 // This is now th right time to wait for th drive to be stable
1546 dim.wait("DRIVE_CONTROL", "OnTrack", 150000); // 110s for turning and 30s for stabilizing
1547
1548 // Now check the voltage... (do not start a lot of stuff just to do nothing)
1549 var state = dim.state("FEEDBACK").name;
1550 if (state=="Warning" || state=="Critical" || state=="OnStandby")
1551 {
1552 v8.sleep(60000);
1553 continue;
1554 }
1555
1556 // Now we are 'OnTrack', so we can ramp to nominal voltage
1557 // and wait for the feedback to get stable
1558 service_feedback.voltageOn();
1559 service_feedback.waitForVoltageOn();
1560
1561 // If pointing had changed, do calibration
1562 if (!irq && point)
1563 {
1564 dim.log("Starting calibration.");
1565
1566 // Calibration (2% of 20')
1567 while (!irq)
1568 {
1569 if (irq || !takeRun("pedestal", 1000)) // 80 Hz -> 10s
1570 continue;
1571// if (irq || !takeRun("light-pulser-ext", 1000)) // 80 Hz -> 10s
1572// continue;
1573 break;
1574 }
1575 }
1576
1577 //console.out(" Taking data: start [5min]");
1578
1579 // FIXME: What do we do if during calibration something has happened
1580 // e.g. drive went to ERROR? Maybe we have to check all states again?
1581
1582 var twilight = Sun.horizon(-16).isUp;
1583
1584 if (twilight)
1585 {
1586 for (var i=0; i<5 && !irq; i++)
1587 takeRun("data", -1, 60); // Take data (1min)
1588 }
1589 else
1590 {
1591 var len = 300;
1592 while (!irq && len>15)
1593 {
1594 var time = new Date();
1595 if (takeRun("data", -1, len)) // Take data (5min)
1596 break;
1597
1598 len -= parseInt((new Date()-time)/1000);
1599 }
1600 }
1601
1602 //console.out(" Taking data: done");
1603 run++;
1604
1605 continue; // case "DATA"
1606 }
1607
1608 if (nextObs!=undefined && sub==obs.length-1)
1609 dim.log("Next observation will start at "+nextObs.start.toUTCString()+" [id="+nextObs.id+"]");
1610
1611 sub++;
1612}
1613
1614sub_drsruns.close();
1615
1616dim.log("Left main loop [irq="+irq+"]");
1617
1618// ================================================================
1619// Comments and ToDo goes here
1620// ================================================================
1621
1622// error handline : http://www.sitepoint.com/exceptional-exception-handling-in-javascript/
1623// classes: http://www.phpied.com/3-ways-to-define-a-javascript-class/
Note: See TracBrowser for help on using the repository browser.