tasks.py
4.84 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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
from __future__ import absolute_import
from django.conf import settings
from pyrosapp.models import *
from celery.task import Task
import scheduler.tasks
import alert_manager.tasks
import observation_manager.tasks
import time
from common.Telescope import TelescopeObj
from common.VISCamera import VISCameraObj
from common.NIRCamera import NIRCameraObj
import time
TIMER_CHECK = 10 # in seconds
class monitoring(Task):
def run(self):
self.configure_instruments()
self.connect_to_plc()
self.update_software_versions()
self.get_night_start_end()
self.wait_devices_ready()
# TODO: décommenter pour lancer un scheduling
# scheduler.tasks.scheduling(first_schedule=True, alert=False, night_start=self.night_start, night_end=self.night_end)
alert_manager.tasks.alert_listener.delay()
time.sleep(5)
print("monitoring")
self.timers_loop()
def configure_instruments(self):
self.tel = TelescopeObj()
self.vis_camera = VISCameraObj()
self.nir_camera = NIRCameraObj()
# TODO: ici, on initialise les connections
self.vis_camera.do("TEMPERATURE", 1.0, -150.0)
self.nir_camera.do("TEMPERATURE", 1.0, -150.0)
self.tel.do("HOMING")
self.tel.do("DOORS", True)
# Souci : gestion des instruments en global
# Cette fonction dépendra du moyen de partager les connections des instruments
def connect_to_plc(self):
# TODO: initialiser la co avec le plc et stocker les identifiants de la co dans self
pass
def update_software_versions(self):
versions = settings.MODULES_VERSIONS
for module, version in versions.items():
same_module_versions = Version.objects.filter(module_name=module)
if same_module_versions.count() == 0:
Version.objects.create(module_name=module, version=version)
elif same_module_versions.order_by("-created")[0].version != version:
Version.objects.create(module_name=module, version=version)
# TODO: envoyer les versions à l'IC
def get_night_start_end(self):
# TODO: utiliser un logiciel by AK pour stocker en local le début et la fin de la nuit (on est peut-être dedans)
self.night_start = time.time() + 180 / 86400
self.night_end = time.time() + 360 / 86400
pass
def wait_devices_ready(self):
# TODO: faire une boucle pour attendre que les devices soient prêts
pass
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":
# TODO: get PLC status
status_tel = self.tel.get("STATUS")
status_nir = self.nir_camera.get("STATUS")
status_vis = self.vis_camera.get("STATUS")
# TODO: stocker les statuts & les envoyer à l'IC
# TODO: analyser le retour du PLC
elif timer_name == "night_start":
scheduler.tasks.scheduling.delay(first_schedule=False, alert=False)
timers["night_start"] = 86400
elif timer_name == "night_end":
observation_manager.tasks.execute_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)