tasks.py
4.22 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
from __future__ import absolute_import
from django.conf import settings
from common.models import *
from celery.task import Task
import scheduler.tasks
import alert_manager.tasks
import observation_manager.tasks
import time
from devices.PLC import PLCController
import time
TIMER_CHECK = 10 # in seconds
'''
Infinite task created at the program's start.
It initilize all the external connections, and starts the alert_listener.
This is the place to put the starting configurations.
Once the starting configurations are done, it becomes a loop that checks the PLC and instruments status.
It also handles the beginning and the end of the night, recalculating them at each end of night.
'''
class monitoring(Task):
def run(self):
self.setContext()
self.get_night_start_end()
alert_manager.tasks.alert_listener.delay()
self.timers_loop()
'''
Creates the communication objects for each instrument, and give them the basic configurations.
'''
def setContext(self):
self.plc = PLCController()
return (0)
def timers_loop(self):
'''
Infinite loop for the different timers :
- Every TIMER_CHECK seconds, check PLC and instruments status (+ analyse them and send them to the IC)
- 2 minutes before the night start, make a scheduling
- At the end of the night, do calibration files and computes the next night limits + make a scheduling with the new schedule
'''
timer_status = TIMER_CHECK
''' Set night start timer to 1 day, then compute the real ones if the current time isn't during the night '''
timer_night_start = 86400
night_start_seconds = self.night_start * 3600 * 24
night_end_seconds = self.night_end * 3600 * 24
if night_start_seconds - 120 > time.time():
timer_night_start = night_start_seconds - 120 - time.time()
timer_night_end = night_end_seconds - time.time()
timers = {"status": timer_status, "night_start": timer_night_start, "night_end": timer_night_end}
while True:
minimal_timer = min(timers, key=timers.get)
''' Wait for the nearest timer '''
time.sleep(timers[minimal_timer])
''' Update the timers '''
timers = {key: value - timers[minimal_timer] for key, value in timers.items()}
''' Then check what timers are <= 0 '''
for timer_name, timer_value in timers.items():
if timer_value <= 0:
if timer_name == "status":
status_tel = self.tel.get("STATUS")
status_nir = self.nir_camera.get("STATUS")
status_vis = self.vis_camera.get("STATUS")
status_plc = self.plc.get("STATUS")
# TODO: stocker les statuts & les envoyer à l'IC
timers["status"] = TIMER_CHECK
self.analyze_plc_status()
elif timer_name == "night_start":
scheduler.tasks.scheduling.delay(first_schedule=False, alert=False)
timers["night_start"] = 86400
elif timer_name == "night_end":
# TODO: faire un majordome.system_pause (fin de nuit)
observation_manager.tasks.create_calibrations.delay()
self.get_night_start_end()
scheduler.tasks.scheduling(first_schedule=True, alert=False, night_start=self.night_start, night_end=self.night_end)
timers["night_start"] = self.night_start * 3600 * 24 - time.time() - 120
timers["night_end"] = self.night_end * 3600 * 24 - time.time()
def analyze_plc_status(self):
'''
Reads the status in DB, and fill missing fields (maybe ?)
Determines the obs conditions and compare them with the previous ones to know if they changed
Create a task to stop the system if there is a security problem
'''
pass
# TODO: toute la fct
# On calcule le nouveau seeing, et si il y a eu du changement, on crée une tâche de majordome.change_obs_conditions