Update

Jeremy
1 parent 675fb3d5
Showing 29 changed files with 208 additions and 99 deletions Show diff stats
logs/2
pyros.py
simulators/config/conf.json
simulators/resources/routine_request_01.xml
simulators/resources/routine_request_02.xml
simulators/resources/routine_request_03.xml
simulators/resources/routine_request_04.xml
simulators/resources/routine_request_05.xml
simulators/resources/routine_request_06.xml
simulators/resources/routine_request_07.xml
simulators/resources/routine_request_08.xml
simulators/resources/routine_request_09.xml
simulators/resources/routine_request_10.xml
src/common/RequestBuilder.py
src/common/models.py
src/majordome/tasks.py
src/misc/static/media/next.png
src/misc/static/media/planned.png
src/observation_manager/tasks.py
src/pyros/settings.py.bak
@@ -0,0 +1 @@
+test
@@ -363,6 +363,18 @@ class Pyros(AManager):
     help_message = "python neo.py"
     init_fixture = "initial_fixture.json"
+    def signal_handler(self, signal, frame):
+        self.printFullTerm(Colors.WARNING, "Ctrl-c catched")
+        for p in self.subproc:
+            proc, name = p
+            self.printColor(Colors.BLUE, "Killing process " + str(name))
+            proc.kill()
+        if self.current_command == "simulator" or self.current_command == "simulator_development":
+            self.changeDirectory(self.path_dir_file)
+            self.kill_simulation()
+        self.printFullTerm(Colors.WARNING, "Exiting")
+        sys.exit(0)
+
     def install(self):
         if (self.system == "Windows"):
             self.execProcess("python install/install.py install")
@@ -496,6 +508,7 @@ class Pyros(AManager):
     def simulator_development(self):
         self.changeDirectory("src")
         self.replacePatternInFile("CELERY_TEST = False", "CELERY_TEST = True", "pyros/settings.py")
+        self.replacePatternInFile("SIMULATOR = False", "SIMULATOR = True", "pyros/settings.py")
         self.execProcess("rm -f testdb.sqlite3")
         self.changeDirectory("..")
         self.migrate()
@@ -535,6 +548,7 @@ class Pyros(AManager):
     def simulator(self):
         self.changeDirectory("src")
         self.replacePatternInFile("CELERY_TEST = False", "CELERY_TEST = True", "pyros/settings.py")
+        self.replacePatternInFile("SIMULATOR = False", "SIMULATOR = True", "pyros/settings.py")
         self.execProcess("rm -f testdb.sqlite3")
         self.changeDirectory("..")
         self.migrate()
@@ -569,6 +583,7 @@ class Pyros(AManager):
     def kill_simulation(self):
         self.changeDirectory("src")
         self.replacePatternInFile("CELERY_TEST = True", "CELERY_TEST = False", "pyros/settings.py")
+        self.replacePatternInFile("SIMULATOR = True", "SIMULATOR = False", "pyros/settings.py")
         if (self.system == "Windows"):
             self.execProcessAsync("taskkill /f /im python.exe")
             self.execProcessAsync("rm -f testdb.sqlite3")
@@ -638,7 +653,7 @@ class Pyros(AManager):
             "update": self.update,
             "server": self.server,
             "clean": self.clean,
-            "simulator_scheduler": self.simulator_development,
+            "simulator_development": self.simulator_development,
             "clean_logs": self.clean_logs,
             "test": self.test,
             "migrate": self.migrate,
@@ -677,7 +692,7 @@ class Pyros(AManager):
             "start": "Stop the celery workers then the web server",
             "stop": "stops the celery workers",
             "simulator": "Launch a simulation",
-            "simulator_scheduler": "Simulation for the scheduler only",
+            "simulator_development": "Simulation for the scheduler only",
             "kill_simulation": "kill the simulators / celery workers / web server",
             "sims_launch": "Launch only the simulators",
         }
@@ -40,6 +40,10 @@
     "userSimulator" : "routine_request_10.xml"
   },
   {
+    "time" : 200,
+    "userSimulator" : "rou"
+  },
+  {
     "time" : 35,
     "plcSimulator" : {"rain" : 5, "cloud" : 3}
   },
@@ -62,5 +66,9 @@
   {
     "time" : 42,
     "telescopeSimulator" : {"status" : "ERROR"}
+  },
+  {
+    "time" : 200,
+    "telescopeSimulator" : {"status" : "OFF"}
   }
 ]
 <?xml version="1.0" ?>
 <request submitted="1" relative="1" name="RequestSimulator" scientific_program="GRB" target_type="test">
-    <sequence duration="200" jd1="6000" jd2="18000" name="Sequence1 (200secs)" target_coords="10">
+    <sequence duration="200" jd1="15" jd2="60000" name="Sequence1 (200secs)" target_coords="10">
         <album detector="Visible camera" name="alb">
             <plan duration="200" filter="First infrared filter" name="New plan" nb_images="5"/>
         </album>
 <?xml version="1.0" ?>
 <request submitted="1" relative="1" name="RequestSimulator" scientific_program="GRB" target_type="test">
-    <sequence duration="100" jd1="6000" jd2="18000" name="Sequence2 (100 secs)" target_coords="10">
+    <sequence duration="100" jd1="60" jd2="60000" name="Sequence2 (100 secs)" target_coords="10">
         <album detector="Visible camera" name="alb">
             <plan duration="100" filter="First infrared filter" name="New plan" nb_images="5"/>
         </album>
 <?xml version="1.0" ?>
 <request submitted="1" relative="1" name="RequestSimulator" scientific_program="GRB" target_type="test">
-    <sequence duration="40" jd1="10000" jd2="15000" name="Sequence3 (40secs)" target_coords="10">
+    <sequence duration="40" jd1="60" jd2="60000" name="Sequence3 (40secs)" target_coords="10">
         <album detector="Visible camera" name="alb">
             <plan duration="40" filter="First infrared filter" name="New plan" nb_images="5"/>
         </album>
 <?xml version="1.0" ?>
 <request submitted="1" relative="1" name="RequestSimulator" scientific_program="GRB" target_type="test">
-    <sequence duration="500" jd1="12000" jd2="25000" name="Sequence 4 (500secs)" target_coords="10">
+    <sequence duration="500" jd1="12000" jd2="60000" name="Sequence 4 (500secs)" target_coords="10">
         <album detector="Visible camera" name="alb">
             <plan duration="500" filter="First infrared filter" name="New plan" nb_images="5"/>
         </album>
 <?xml version="1.0" ?>
 <request submitted="1" relative="1" name="RequestSimulator" scientific_program="GRB" target_type="test">
-    <sequence duration="10" jd1="6000" jd2="22000" name="Sequence5 (10secs)" target_coords="10">
+    <sequence duration="10" jd1="60" jd2="60000" name="Sequence5 (10secs)" target_coords="10">
         <album detector="Visible camera" name="alb">
             <plan duration="10" filter="First infrared filter" name="plan vis" nb_images="1"/>
         </album>
 <?xml version="1.0" ?>
 <request submitted="1" relative="1" name="RequestSimulator" scientific_program="GRB" target_type="test">
-    <sequence duration="200" jd1="6000" jd2="18000" name="Sequence6 (200 secs)" target_coords="10">
+    <sequence duration="200" jd1="6000" jd2="60000" name="Sequence6 (200 secs)" target_coords="10">
         <album detector="Visible camera" name="alb">
             <plan duration="200" filter="First infrared filter" name="New plan" nb_images="5"/>
         </album>
 <?xml version="1.0" ?>
 <request submitted="1" relative="1" name="RequestSimulator" scientific_program="GRB" target_type="test">
-    <sequence duration="200" jd1="6000" jd2="18000" name="Sequence7 (200secs)" target_coords="10">
+    <sequence duration="200" jd1="6000" jd2="60000" name="Sequence7 (200secs)" target_coords="10">
         <album detector="Visible camera" name="alb">
             <plan duration="200" filter="First infrared filter" name="New plan" nb_images="5"/>
         </album>
 <?xml version="1.0" ?>
 <request submitted="1" relative="1" name="RequestSimulator" scientific_program="GRB" target_type="test">
-    <sequence duration="200" jd1="6000" jd2="18000" name="Sequence8 (200secs)" target_coords="10">
+    <sequence duration="200" jd1="19000" jd2="60000" name="Sequence8 (200secs)" target_coords="10">
         <album detector="Visible camera" name="alb">
             <plan duration="200" filter="First infrared filter" name="New plan" nb_images="5"/>
         </album>
 <?xml version="1.0" ?>
 <request submitted="1" relative="1" name="RequestSimulator" scientific_program="GRB" target_type="test">
-    <sequence duration="200" jd1="6000" jd2="18000" name="Sequence9 (200secs)" target_coords="10">
+    <sequence duration="200" jd1="1000" jd2="60000" name="Sequence9 (200secs)" target_coords="10">
         <album detector="Visible camera" name="alb">
             <plan duration="200" filter="First infrared filter" name="New plan" nb_images="5"/>
         </album>
 <?xml version="1.0" ?>
 <request submitted="1" relative="1" name="RequestSimulator" scientific_program="GRB" target_type="test">
-    <sequence duration="200" jd1="6000" jd2="18000" name="Sequence10 (200secs)" target_coords="10">
+    <sequence duration="200" jd1="200" jd2="60000" name="Sequence10 (200secs)" target_coords="10">
         <album detector="Visible camera" name="alb">
             <plan duration="200" filter="First infrared filter" name="New plan" nb_images="5"/>
         </album>
@@ -31,7 +31,7 @@ class RequestBuilder():
             raise RuntimeError(
                 "start_new_request MUST be invoked before creating any sequence")
-        sequence = Sequence(name=name, status=Sequence.OBSERVABLE, priority=priority,
+        sequence = Sequence(name=name, status=Sequence.TOBEPLANNED, priority=priority,
                             jd1=jd1, jd2=jd2, t_prefered=t_prefered, duration=duration)
         self.sequences[self.sequence_id] = sequence
         self.sequence_id += 1
@@ -367,20 +367,19 @@ class Sequence(models.Model):
     INCOMPLETE = "INCPL"
     COMPLETE = "CPL"
     TOBEPLANNED = "TBP"
-    OBSERVABLE = "OBS"
-    UNPLANNABLE = "UNPLN"
+    PLANNED = "PLND"
     PENDING = "PNDG"
-    EXECUTED = "EXD"
     EXECUTING = "EXING"
+    EXECUTED = "EXD"
     REJECTED = "RJTD"
-    CANCELLED = "CNCLD"
     INVALID = "INVL"
-    DEVICE_ERROR = "DVER"
+    CANCELLED = "CNCLD"
+    UNPLANNABLE = "UNPLN"
     STATUS_CHOICES = (
         (INCOMPLETE, "Incomplete"),
         (COMPLETE, "Complete"),
         (TOBEPLANNED, "To be planned"),
-        (OBSERVABLE, "Observable"),
+        (PLANNED, "Planned"),
         (UNPLANNABLE, "Unplannable"),
         (PENDING, "Pending"),
         (EXECUTED, "Executed"),
@@ -388,7 +387,6 @@ class Sequence(models.Model):
         (REJECTED, "Rejected"),
         (CANCELLED, "Cancelled"),
         (INVALID, "Invalid"),
-        (DEVICE_ERROR, "Device error"),
     )
     request = models.ForeignKey(
@@ -16,6 +16,7 @@ from django.conf import settings
 from utils.JDManipulator import *
 import utils.Logger as L
+DEBUG_FILE = False
 log = L.setupLogger("MajordomeTaskLogger", "Majordome")
 '''
@@ -127,7 +128,7 @@ class Majordome(Task):
             "schedule": self.timer_schedule,
             "sequence": self.timer_sequence
         }
-        if (settings.DEBUG):
+        if (settings.DEBUG and DEBUG_FILE):
             log.info("Majordome started with timers : " + str(self.timers))
         # Functions called during the loop
         self.functions = {
@@ -162,10 +163,10 @@ class Majordome(Task):
                         self.logDB("Executing timer " + str(timer_name))
                         self.functions[timer_name]()
                     else:
-                        if (settings.DEBUG):
+                        if (settings.DEBUG and DEBUG_FILE):
                             log.info("Timer : " + str(timer_name) + "is not known by the Majordome")
                         self.logDB("Timer " + str(timer_name) + " unknown")
-                    if (settings.DEBUG):
+                    if (settings.DEBUG and DEBUG_FILE):
                         log.info("Timer : " + str(timer_name) + " executed")
         return (0)
@@ -175,7 +176,7 @@ class Majordome(Task):
             site_status = SiteWatch.objects.latest('updated')
             weather_status = WeatherWatch.objects.latest('updated')
         except ObjectDoesNotExist:
-            if (settings.DEBUG):
+            if (settings.DEBUG and DEBUG_FILE):
                 log.info("No site_status or weather_status found in database")
             return (1)
         self.handlePLC(site_status, weather_status)
@@ -192,29 +193,26 @@ class Majordome(Task):
     def handleSequenceTimer(self):
         self.timers["sequence"] = self.timer_sequence
-        if (self.isValidStatus(self.status_tel)):
-            if (self.executing_sequence != None):
-                self.handleSequence(self.executing_sequence[0],
-                                    self.executing_sequence[1], self.executing_sequence[2])
-        else:
-            self.notifyTelescopeStatus("sequence")
+        if (self.executing_sequence):
+            self.handleSequence(self.executing_sequence[0],
+                                self.executing_sequence[1], self.executing_sequence[2])
         return (0)
     def handleScheduleTimer(self):
         self.timers["schedule"] = self.timer_schedule
         if (self.isValidStatus(self.status_tel)):
-            if (self.schedule == None):
+            if (self.schedule is None):
                 try:
                     self.schedule = Schedule.objects.latest('created')
                 except ObjectDoesNotExist:
-                    if (settings.DEBUG):
+                    if (settings.DEBUG and DEBUG_FILE):
                         log.info("No schedule found in database")
                     return (1)
             else:
                 try:
                     schedule = Schedule.objects.latest('created')
                 except ObjectDoesNotExist:
-                    if (settings.DEBUG):
+                    if (settings.DEBUG and DEBUG_FILE):
                         log.info("No schedule found in database")
                     return (1)
                 if (schedule.created != self.schedule.created):
@@ -256,52 +254,66 @@ class Majordome(Task):
         Function called when a schedule has to be executed
     '''
     def executeSchedule(self, shs_list):
+        is_prev_planned = False
         self.logDB("Trying to execute a sequence from current schedule")
         for shs in shs_list: # shs_list is sorted by tsp
-            if (shs.sequence.status == Sequence.OBSERVABLE and self.observable(shs.sequence)):
+            if (shs.sequence.status == Sequence.PLANNED and self.observable(shs.sequence)):
                 countdown = self.getCountdown(shs)
-                if countdown <= JulianSeconds(5) and countdown > 0:
-                    if (self.executing_sequence == None):
-                        self.executeSequence(shs, shs.sequence, countdown)
-                    else:
+                # if (countdown <= 6):
+                #     TODO CHECK IF OBSERVABLE ELSE RESCHEDULE
+                if countdown <= JulianSeconds(5):
+                    if self.executing_sequence is None:
+                        if self.switchSequence():
+                            self.executeSequence(shs, shs.sequence, countdown)
+                        else:
+                            self.setNextSequence(shs, shs.sequence, countdown)
+                    elif self.next_sequence is None:
                         self.setNextSequence(shs, shs.sequence, countdown)
-                else:
-                    if (settings.DEBUG):
-                        log.info("Sequence cannot be executed : countdown = " + str(countdown))
-                        self.logDB("Sequence cannot be executed : countdown = " + str(countdown))
+                    else:
+                        return 0
+                elif self.next_sequence is None:
+                    self.setNextSequence(shs, shs.sequence, countdown)
             else:
-                if (settings.DEBUG):
+                if (settings.DEBUG and DEBUG_FILE):
                     log.info("Sequence cannot be executed : Not observable")
-                self.logDB("Sequence cannot be executed : Not observable")
-        return (0)
+                self.logDB("Sequence "+shs.sequence.name+" cannot be executed : Not observable")
+        return 0
     def observable(self, sequence):
-        if (sequence.jd2 - sequence.duration - getCurrentTime() <= 0):
-            return (0)
-        return (1)
+        if (sequence.jd2 - sequence.duration - secondsToPreciseJulianDate(getPreciseCurrentTime()) <= 0):
+            return 0
+        return 1
     '''
         Launch the observation tasks associated to a sequence
     '''
     def executeSequence(self, shs, sequence, countdown):
+        if (countdown > JulianSeconds(5)):
+            if self.next_sequence and self.next_sequence[1].status == Sequence.PENDING:
+                self.next_sequence[1].status = Sequence.PLANNED
+                self.next_sequence[1].save()
+            return 0
+        if self.next_sequence and self.next_sequence[1].status == Sequence.PLANNED:
+            self.next_sequence[1].status = Sequence.PENDING
+            self.next_sequence[1].save()
+
         self.logDB("Executing sequence")
         plans_results = []
-
         if sequence.albums.filter(detector__name="Cagire").exists():
             if (self.isValidStatus(self.status_nir)):
                 for plan in sequence.albums.get(detector__name="Cagire").plans.all():
-                    res = observation_manager.tasks.execute_plan_nir.apply_async((plan.id, countdown))
+                    res = observation_manager.tasks.execute_plan_nir.apply_async((plan.id, float(countdown)))
                     TaskId.objects.create(task_id=res.id, task="execute_plan")
                     plans_results.append(res)
-        else:
-            self.notifyDeviceStatus("Cagire", "Sequence execution", self.status_nir)
-            sequence.status = Sequence.DEVICE_ERROR
-            sequence.save()
-            return (1)
+            else:
+                self.notifyDeviceStatus("Cagire", "Sequence execution", self.status_nir)
+                sequence.status = Sequence.DEVICE_ERROR
+                sequence.save()
+                return (1)
         if sequence.albums.filter(detector__name="Visible camera").exists():
             if (self.isValidStatus(self.status_vis)):
                 for plan in sequence.albums.get(detector__name="Visible camera").plans.all():
-                    res = observation_manager.tasks.execute_plan_vis.apply_async((plan.id, countdown))
+                    res = observation_manager.tasks.execute_plan_vis.apply_async((plan.id, float(countdown)))
                     TaskId.objects.create(task_id=res.id, task="execute_plan")
                     plans_results.append(res)
             else:
@@ -320,20 +332,22 @@ class Majordome(Task):
         Set the next sequence
     '''
     def setNextSequence(self, shs, sequence, countdown):
+        sequence.status = Sequence.PENDING
         self.next_sequence = [shs, sequence, countdown]
+        sequence.save()
         return (0)
     '''
         Switch sequences
     '''
     def switchSequence(self):
-        if (self.next_sequence == None):
-            self.executing_sequence = None
-        else:
-            self.executing_sequence = None
+        self.executing_sequence = None
+        if (self.next_sequence is not None):
             self.executeSequence(self.next_sequence[0],
                                  self.next_sequence[1], self.next_sequence[2])
             self.next_sequence = None
+        else:
+            return 1
         return (0)
     '''
@@ -414,7 +428,7 @@ class Majordome(Task):
     '''
     def getCountdown(self, shs):
         # TODO start sequence as soon as possible (a lot of verifications must be done there)
-        current_time = secondsToJulianDate(getPreciseCurrentTime());
+        current_time = secondsToPreciseJulianDate(getPreciseCurrentTime())
         countdown = shs.tsp - current_time
         return countdown
@@ -6,6 +6,7 @@ from devices import CameraVIS as VIS
 from devices import CameraNIR as NIR
 from devices import Telescope
 import time
+from utils.Logger import setupLogger
 '''
     Super class for execute_plan_vis / _nir
@@ -13,6 +14,7 @@ import time
 class execute_plan(Task):
     def run(self, plan_id, countdown, type):
+
         if countdown > 0:
             time.sleep(countdown)
         TaskId.objects.filter(task_id=self.request.id).delete()
@@ -102,7 +104,10 @@ class execute_plan(Task):
     Send the images to the analyzer
 '''
 class execute_plan_vis(execute_plan):
+    logger = setupLogger("PlanVIS", "PlanVIS")
+
     def run(self, plan_id, countdown):
+        self.log.info("------------------ RUNNING PLAN VIS ----------------------------")
         super().run(plan_id, countdown, "VIS")
@@ -111,8 +116,11 @@ class execute_plan_vis(execute_plan):
     Send the images to the analyzer
 '''
 class execute_plan_nir(execute_plan):
+    log = setupLogger("PlanNIR", "PlanNIR")
+
     def run(self, plan_id, countdown):
         super().run(plan_id, countdown, "NIR")
+        self.log.info("------------------ RUNNING PLAN NIR ----------------------------")
 '''
@@ -120,6 +128,8 @@ class execute_plan_nir(execute_plan):
     When they are all finished, it creates the 'super' calibration files.
 '''
 class create_calibrations(Task):
-     def run(self):
-         # TODO: attendre que tout soit idle
-         pass
+    logger = setupLogger("Calibrations", "Calibrations")
+
+    def run(self):
+        self.log.info("------------------ RUNNING CALIBRATIONS ----------------------------")
+        # TODO: attendre que tout soit idle
@@ -119,7 +119,9 @@ LOGIN_URL = &quot;/&quot;
 # EP modif
-CELERY_TEST = True
+SIMULATOR = True
+
+CELERY_TEST = False
 if not CELERY_TEST:
     if not MYSQL:
@@ -88,8 +88,6 @@ class RequestSerializer():
                 sequence.jd1 = (time.time() + float(sequence.jd1)) / 86400 + TIMESTAMP_JD
                 sequence.jd2 = (time.time() + float(sequence.jd2)) / 86400 + TIMESTAMP_JD
             sequence.request = self.request
-            # TODO: REMOVE WHEN WE KNOW HOW TO DECIDE IF THE SEQUENCE IS OBSERVABLE
-            sequence.status = Sequence.OBSERVABLE
             sequence.save()
             for album, plans in albums:
                 album.sequence = sequence
 from common.models import Sequence
+from django.conf import settings
 def check_plan_validity(plan):
     """
@@ -52,7 +53,11 @@ def check_sequence_validity(seq):
     if seq.albums.filter(complete=False).count() != 0 or seq.albums.count() == 0:
         seq.status = Sequence.INCOMPLETE
     else:
-        seq.status = Sequence.COMPLETE
+        #TODO CHANGE WHEN WE KNOW HOW TO DECIDE IF THE SEQUENCE IS OBSERVABLE
+        if settings.SIMULATOR:
+            seq.status = Sequence.TOBEPLANNED
+        else:
+            seq.status = Sequence.COMPLETE
     seq.save()
     return check_request_validity(seq.request)
@@ -428,7 +428,7 @@ def submit_request(request, req_id, redir):
         return redirect(action_request, req_id=req_id, action="view", status=-1, message=message)
     for seq in req.sequences.all():
-        seq.status = Sequence.OBSERVABLE  # TODO: utiliser le monitoring (regarder les conditions d'obseration pour dire si on met TBP ou OBS)
+        seq.status = Sequence.TOBEPLANNED
         seq.save()
     req.submitted = True
     req.save()
@@ -460,7 +460,7 @@ def unsubmit_request(request, req_id):
     req.submitted = False
     req.save()
-    sequences = req.sequences.filter(Q(status=Sequence.TOBEPLANNED) | Q(status=Sequence.OBSERVABLE) |
+    sequences = req.sequences.filter(Q(status=Sequence.TOBEPLANNED) | Q(status=Sequence.PLANNED) |
                                         Q(status=Sequence.INVALID) | Q(status=Sequence.UNPLANNABLE))
     for seq in sequences:
         seq.status = Sequence.COMPLETE
 from operator import attrgetter
 from .UserManager import UserManager
 from .Interval import *
+from django.db.models import Q
 SIMULATION = False
-
+DEBUG_FILE = False
 class Scheduler(IntervalManagement):
     REJECTED_ROOM = "Insufficient room for this sequence"
@@ -29,27 +30,43 @@ class Scheduler(IntervalManagement):
     def isFirstSchedule(self) -> bool:
         return False
+    def determinePlanStart(self, previous_sched):
+        start = secondsToPreciseJulianDate(getPreciseCurrentTime())
+        if start > previous_sched.plan_start + self.max_overhead:
+            return start + self.max_overhead
+        return previous_sched.plan_start
+
     def copyFromPrevious(self) -> int:
         if len(Schedule.objects.all()) == 1:
             self.schedule.plan_night_start = self.schedule.plan_start
-            self.log("No schedule found")
+            if DEBUG_FILE:
+                self.log("No schedule found")
             return 1
         try:
             previous_sched = Schedule.objects.order_by('-created')[1]
-            previous_exc_seq = previous_sched.sequences.filter(status=Sequence.EXECUTED)
+            previous_exc_seq = previous_sched.sequences.filter(Q(status=Sequence.EXECUTED) |
+                                                               Q(status=Sequence.EXECUTING))
         except:
             self.schedule.plan_night_start = self.schedule.plan_start
-            self.debug("Scheduler could not get information from previous schedule")
+            if DEBUG_FILE:
+                self.debug("Scheduler could not get information from previous schedule")
             return 1
         for seq in previous_exc_seq:
-            shs = seq.shs
+            shs = seq.shs.latest("schedule__created")
             shs.pk = None
             shs.schedule = self.schedule
             shs.save()
+        adder = 0
+        try:
+            executing = Sequence.objects.filter(status=Sequence.EXECUTING)
+            if executing:
+                s = Sequence.shs.latest("schedule__created")
+                adder = s.tsp - secondsToPreciseJulianDate(getPreciseCurrentTime())
+        except:
+            pass
         self.schedule.plan_night_start = previous_sched.plan_night_start
         self.schedule.plan_end = previous_sched.plan_end
-        start = Decimal(secondsToJulianDate(getCurrentTime())) + self.max_overhead
-        self.schedule.plan_start = (start if start > previous_sched.plan_start else previous_sched.plan_start)
+        self.schedule.plan_start = self.determinePlanStart(previous_sched) + adder
         return 0
     def simulateSchedule(self, sequences) -> tuple:
@@ -68,7 +85,8 @@ class Scheduler(IntervalManagement):
     def computeSchedule(self) -> int:
         interval = Interval(self.schedule.plan_start, self.schedule.plan_end)
         self.intervals.append(interval)
-        self.log("Interval created : " + str(interval.__dict__))
+        if DEBUG_FILE:
+            self.log("Interval created : " + str(interval.__dict__))
         self.removeInvalidSequences()
         self.determinePriorities()
         self.removeNonEligible()
@@ -86,21 +104,27 @@ class Scheduler(IntervalManagement):
             if self.copyFromPrevious():
                 self.schedule.plan_night_start = self.schedule.plan_start
-        self.sequences = list(Sequence.objects.filter())
+        self.sequences = list(Sequence.objects.filter(Q(status=Sequence.PLANNED) | Q(status=Sequence.TOBEPLANNED)
+                                                      | Q(status=Sequence.PENDING)))
         self.sequences = [(sequence, ScheduleHasSequences(sequence=sequence, schedule=self.schedule))
                           for sequence in self.sequences]
-        self.log(str(len(self.sequences)) + " sequences found")
+        if DEBUG_FILE:
+            self.log(str(len(self.sequences)) + " sequences found")
         self.computeSchedule()
         self.saveSchedule()
-        self.log("Saving schedule with " + str(len(self.schedule.sequences.all())) + " sequences")
+        if DEBUG_FILE:
+            self.log("Saving schedule with " + str(len(self.schedule.sequences.all())) + " sequences")
         return self.schedule
     def saveSchedule(self) -> int:
         self.schedule.save()
-        for _, shs in self.sequences:
+        for sequence, shs in self.sequences:
+            sequence.status = Sequence.PLANNED
             shs.schedule = self.schedule
+            sequence.save()
             shs.save()
-        self.logSchedule()
+        if DEBUG_FILE:
+            self.logSchedule()
         return 0
@@ -116,7 +140,8 @@ class Scheduler(IntervalManagement):
                     if not SIMULATION:
                         sequence.save()
                 self.sequences.remove((sequence, shs))
-                self.log("Removing non eligible sequence")
+                if DEBUG_FILE:
+                    self.log("Removing non eligible sequence")
         return 0
     def removeInvalidSequences(self):
@@ -124,7 +149,8 @@ class Scheduler(IntervalManagement):
             if (sequence.jd1 < 0 or sequence.jd2 < 0 or
                     is_nearby_less_or_equal(sequence.duration, Decimal(0)) or
                     sequence.jd2 - sequence.jd1 < sequence.duration):
-                self.log("Removing sequence in removeInvalidSequences")
+                if DEBUG_FILE:
+                    self.log("Removing sequence in removeInvalidSequences")
                 self.sequences.remove((sequence, shs))
                 sequence.status = Sequence.INVALID
                 if not SIMULATION:
@@ -160,7 +186,8 @@ class Scheduler(IntervalManagement):
                 shs.status = Sequence.PENDING
                 self.decreaseQuota(sequence, sequence.duration)
             else:
-                self.log("Removing sequence in place_sequences")
+                if DEBUG_FILE:
+                    self.log("Removing sequence in place_sequences")
                 shs.status = Sequence.REJECTED
                 shs.desc = self.REJECTED_ROOM
         return 0
@@ -76,7 +76,7 @@ class Simulator():
             jd1 = Decimal("%.8f" % float(sequence_array[5]))
             jd2 = Decimal("%.8f" % float(sequence_array[6]))
-            sequence = Sequence(request=req, status=Sequence.OBSERVABLE,
+            sequence = Sequence(request=req, status=Sequence.PLANNED,
                                 name="sequence", id=id_seq, priority=priority, duration=duration, jd1=jd1, jd2=jd2, t_prefered=-1)
             sequences.append(sequence)
@@ -11,9 +11,7 @@ class scheduling(Task):
     def run(self, first_schedule=False, alert=False):
         Log.objects.create(agent='Scheduler', message='Start schedule : ' + str(datetime.datetime.now()))
-        log.info("Scheduling start")
         self.scheduler = Scheduler()
         self.scheduler.setNightLimits(secondsToJulianDate(getNightStart()), secondsToJulianDate(getNightEnd()))
         self.scheduler.makeSchedule()
-        log.info("Scheduling done")
         Log.objects.create(agent='Scheduler', message='Scheduling finished : ' + str(datetime.datetime.now()))
 \ No newline at end of file
@@ -63,12 +63,16 @@
                     {% for sequence in sequences %}
                         <tr>
                                                             <td>
-                                                                {% if sequence.processing == 1 %}
-                                                                <img src="{% static "media/arrow_green.png" %}" alt="html5" height="30" width="30" style="margin-left:25%"/>
-                                                                {% elif sequence.processing == 0 and sequence.status == "EXECUTED" %}
-                                                                <img src="{% static "media/validate.jpg" %}" alt="html5" height="30" width="30" style="margin-left:25%"/>
+                                                                {% if sequence.0.status == "EXING" == 1 %}
+                                                                    <img src="{% static "media/arrow_green.png" %}" alt="html5" height="30" width="30" style="margin-left:25%"/>
+                                                                {% elif sequence.0.status == "EXD" %}
+                                                                    <img src="{% static "media/validate.jpg" %}" alt="html5" height="30" width="30" style="margin-left:25%"/>
+                                                                {% elif sequence.0.status == "PNDG" %}
+                                                                    <img src="{% static "media/next.png" %}" alt="html5" height="30" width="30" style="margin-left:25%"/>
+                                                                {% elif sequence.0.status == "PLND" %}
+                                                                    <img src="{% static "media/planned.png" %}" alt="html5" height="30" width="30" style="margin-left:25%"/>
                                                                 {% else %}
-                                                                <img src="{% static "media/error.png" %}" alt="{{sequence.processing}}" height="30" width="30" style="margin-left:25%"/>
+                                                                    <img src="{% static "media/error.png" %}" alt="html5" height="30" width="30" style="margin-left:25%"/>
                                                                 {% endif %}
                                                             </td>
                             <td>{{ sequence.0.id }}</td>
@@ -79,7 +83,7 @@
                             <td>{{ sequence.0.jd2|jdtodate }}</td>
                             <td>{{ sequence.0.duration|jdtoduration }}</td>
                             <td>{{ sequence.0.priority }}</td>
-                            <td>{{ sequence.1.status }}</td>
+                            <td>{{ sequence.0.status }}</td>
                         </tr>
                     {% endfor %}
                 </tbody>
@@ -10,7 +10,7 @@ SIMULATION_FILE = &#39;file:./scheduler/sequences_cador.html&#39;
 def retrieve_schedule(request):
     if (len(Schedule.objects.all()) > 0):                       # checking if the schedule is empty
         schedule = Schedule.objects.order_by("-created")[0]     # Sorting Schedule
-        shs_list = schedule.shs.all()                           # getting all the schedule has sequences references
+        shs_list = schedule.shs.order_by("tsp")                 # getting all the schedule has sequences references
         sequences = [(shs.sequence, shs) for shs in shs_list]   # getting all sequences
         nb_scheduled_sequences = len(shs_list)
@@ -33,7 +33,7 @@ def schedule_simulation(request):
     simulator = Simulator()
     schedule, sequences = simulator.simulate(SIMULATION_FILE)
-    nb_scheduled_sequences = len([sequence for sequence in sequences if sequence[1].status != Sequence.OBSERVABLE])
+    nb_scheduled_sequences = len([sequence for sequence in sequences if sequence[1].status != Sequence.PLANNED])
     executed_sequences = len([sequence for sequence in sequences if sequence[1].status == Sequence.EXECUTED])
+from django.conf import settings
 import datetime
 import time
 from decimal import *
@@ -5,9 +6,23 @@ from decimal import *
 JD_VALUE = 86400
 TIMESTAMP_JD = 2440587.500000
 DAILY_SECOND = 1 / 86400
+SECOND_DIV = 86400
+
+def getSimTime():
+    current_time = datetime.datetime.now()
+    if current_time.minute == 59:
+        current_time = current_time.replace(hour=(current_time.hour + 1), minute=0, second=10)
+    else:
+        if current_time.second >= 50:
+            current_time = current_time.replace(minute=current_time.minute + 1, second=10)
+        else:
+            current_time = current_time.replace(second=(current_time.second + 10))
+    return (time.mktime(current_time.timetuple()))
+
+SIM_TIME_START = getSimTime()
 def JulianSeconds(value):
-    return (Decimal(value * DAILY_SECOND))
+    return (Decimal(value) / SECOND_DIV)
 def getPreciseCurrentTime():
     return (Decimal(getCurrentTime()))
@@ -21,6 +36,9 @@ def getPreciseNightEnd():
 def secondsToJulianDate(time_seconds):
     return (time_seconds / 86400 + TIMESTAMP_JD)
+def secondsToPreciseJulianDate(time_seconds):
+    return (Decimal(time_seconds) / 86400 + Decimal(TIMESTAMP_JD))
+
 def julianDateToSeconds(time_julian):
     return ((time_julian - TIMESTAMP_JD) * 86400)
@@ -46,7 +64,18 @@ def getNextDefaultNightEnd():
 def getDefaultNightStart():
     current_time = datetime.datetime.now()
-    current_time = current_time.replace(hour=18, minute=0, second=0, microsecond=0)
+    if settings.SIMULATOR:
+        if settings.SIMULATOR:
+            return SIM_TIME_START
+        if current_time.minute == 59:
+            current_time = current_time.replace(hour=(current_time.hour + 1), minute=0, second=10)
+        else:
+            if current_time.second > 50:
+                current_time = current_time.replace(minute=current_time.minute + 1, second=10)
+            else:
+                current_time = current_time.replace(second=(current_time.second + 10))
+    else:
+        current_time = current_time.replace(hour=18, minute=0, second=0, microsecond=0)
     return (time.mktime(current_time.timetuple()))
 def getDefaultNightEnd():