radarsys Commit - r388:7b60d9ecd28a · Jicamarca Repository

Avance scheduler

Renato Huallpa -

r388:7b60d9ecd28a

parent child

Context file:

r388:7b60d9ecd28a

Collapse all files

apps/abs/models.py +1 -1

             from django.db import models
             from apps.main.models import Configuration , User
             from django.urls import reverse
             from celery.execute import send_task
             from datetime import datetime
             import ast
             import socket
             import json
             import requests
             import struct
             import os, sys, time
             from .mqtt import client as mqtt_client
             from radarsys.socketconfig import sio as sio
             import json
             antenna_default = json.dumps({
                                 "antenna_up": [[0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
                                                 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
                                                 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
                                                 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
                                                 [0.5,0.5,0.5,0.5,1.0,1.0,1.0,1.0],
                                                 [0.5,0.5,0.5,0.5,1.0,1.0,1.0,1.0],
                                                 [0.5,0.5,0.5,0.5,1.0,1.0,1.0,1.0],
                                                 [0.5,0.5,0.5,0.5,1.0,1.0,1.0,1.0]
                                                 ]
                                                ,
                                 "antenna_down": [[0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
                                                 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
                                                 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
                                                 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
                                                 [0.5,0.5,0.5,0.5,3.0,3.0,3.0,3.0],
                                                 [0.5,0.5,0.5,0.5,3.0,3.0,3.0,3.0],
                                                 [0.5,0.5,0.5,0.5,3.0,3.0,3.0,3.0],
                                                 [0.5,0.5,0.5,0.5,3.0,3.0,3.0,3.0]],
                             })
             tx_default = json.dumps({
                             "up": [[1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1]],
                           "down": [[1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1]],
                          })
             rx_default = json.dumps({
                             "up": [[1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1]],
                           "down": [[1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [1,1,1,1,0,0,0,0],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1],
                                    [0,0,0,0,1,1,1,1]],
                          })
             status_default = '0000000000000000000000000000000000000000000000000000000000000000'
             default_messages = {}
             for i in range(1,65):
                 default_messages[str(i)] = "Module "+str(i)
             ues_default = json.dumps({
                             "up": [0.533333,0.00000,1.06667,0.00000],
                             "down": [0.533333,0.00000,1.06667,0.00000]
                         })
             onlyrx_default = json.dumps({
                                 "up": False,
                                 "down": False
                             })
             def up_convertion(cadena):
                 valores = []
                 for c in cadena:
                     if c == 1.0: valores=valores+['000']
                     if c == 2.0: valores=valores+['001']
                     if c == 3.0: valores=valores+['010']
                     if c == 0.0: valores=valores+['011']
                     if c == 0.5: valores=valores+['100']
                     if c == 1.5: valores=valores+['101']
                     if c == 2.5: valores=valores+['110']
                     if c == 3.5: valores=valores+['111']
                 return valores
             def up_conv_bits(value):
                 if value == 1.0: bits="000"
                 if value == 2.0: bits="001"
                 if value == 3.0: bits="010"
                 if value == 0.0: bits="011"
                 if value == 0.5: bits="100"
                 if value == 1.5: bits="101"
                 if value == 2.5: bits="110"
                 if value == 3.5: bits="111"
                 return bits
             def down_convertion(cadena):
                 valores = []
                 for c in cadena:
                     if c == 1.0: valores=valores+['000']
                     if c == 2.0: valores=valores+['001']
                     if c == 3.0: valores=valores+['010']
                     if c == 0.0: valores=valores+['011']
                     if c == 0.5: valores=valores+['100']
                     if c == 1.5: valores=valores+['101']
                     if c == 2.5: valores=valores+['110']
                     if c == 3.5: valores=valores+['111']
                 return valores
             def down_conv_bits(value):
                 if value == 1.0: bits="000"
                 if value == 2.0: bits="001"
                 if value == 3.0: bits="010"
                 if value == 0.0: bits="011"
                 if value == 0.5: bits="100"
                 if value == 1.5: bits="101"
                 if value == 2.5: bits="110"
                 if value == 3.5: bits="111"
                 return bits
             def up_conv_value(bits):
                 if bits == "000": value=1.0
                 if bits == "001": value=2.0
                 if bits == "010": value=3.0
                 if bits == "011": value=0.0
                 if bits == "100": value=0.5
                 if bits == "101": value=1.5
                 if bits == "110": value=2.5
                 if bits == "111": value=3.5
                 return value
             def down_conv_value(bits):
                 if bits == "000": value=1.0
                 if bits == "001": value=2.0
                 if bits == "010": value=3.0
                 if bits == "011": value=0.0
                 if bits == "100": value=0.5
                 if bits == "101": value=1.5
                 if bits == "110": value=2.5
                 if bits == "111": value=3.5
                 return value
             def ip2position(module_number):
                 j=0
                 i=0
                 for x in range(0,module_number-1):
                     j=j+1
                     if j==8:
                         i=i+1
                         j=0
                 pos = [i,j]
                 return pos
             def fromBinary2Char(binary_string):
                 number = int(binary_string, 2)
                 #Plus 33 to avoid more than 1 characters values such as: '\x01'-'\x1f'
                 number = number + 33
                 char = chr(number)
                 return char
             def fromChar2Binary(char):
                 number = ord(char) - 33
                 #Minus 33 to get the real value
                 bits = bin(number)[2:]
                 #To ensure we have a string with 6bits
                 if len(bits) < 6:
                     bits = bits.zfill(6)
                 return bits
             OPERATION_MODES = (
                              (0, 'Manual'),
                              (1, 'Automatic'),
                          )
             class ABSConfiguration(Configuration):
                 active_beam     = models.PositiveSmallIntegerField(verbose_name='Active Beam', default=0)
                 module_status   = models.CharField(verbose_name='Module Status', max_length=10000, default=status_default)
                 operation_mode  = models.PositiveSmallIntegerField(verbose_name='Operation Mode', choices=OPERATION_MODES, default = 0)
                 operation_value = models.FloatField(verbose_name='Periodic (seconds)', default="10", null=True, blank=True)
                 module_messages = models.CharField(verbose_name='Modules Messages', max_length=10000, default=json.dumps(default_messages))
                 class Meta:
                     db_table = 'abs_configurations'
                 def get_absolute_url_plot(self):
                     return reverse('url_plot_abs_patterns', args=[str(self.id)])
                 def parms_to_dict(self):
                     parameters = {}
                     parameters['device_id'] = self.device.id
                     parameters['label']      = self.label
                     parameters['device_type']      = self.device.device_type.name
                     parameters['beams']     = {}
                     beams = ABSBeam.objects.filter(abs_conf=self)
                     b=1
                     for beam in beams:
                         #absbeam = ABSBeam.objects.get(pk=beams[beam])
                         parameters['beams']['beam'+str(b)] = beam.parms_to_dict()#absbeam.parms_to_dict()
                         b+=1
                     return parameters
                 def dict_to_parms(self, parameters):
                     self.label = parameters['label']
                     absbeams  = ABSBeam.objects.filter(abs_conf=self)
                     beams     = parameters['beams']
                     if absbeams:
                         beams_number    = len(beams)
                         absbeams_number = len(absbeams)
                         if beams_number==absbeams_number:
                             i = 1
                             for absbeam in absbeams:
                                 absbeam.dict_to_parms(beams['beam'+str(i)])
                                 i = i+1
                         elif beams_number > absbeams_number:
                             i = 1
                             for absbeam in absbeams:
                                 absbeam.dict_to_parms(beams['beam'+str(i)])
                                 i=i+1
                             for x in range(i,beams_number+1):
                                 new_beam = ABSBeam(
                                            name     =beams['beam'+str(i)]['name'],
                                            antenna  =json.dumps(beams['beam'+str(i)]['antenna']),
                                            abs_conf = self,
                                            tx       =json.dumps(beams['beam'+str(i)]['tx']),
                                            rx       =json.dumps(beams['beam'+str(i)]['rx']),
                                            ues      =json.dumps(beams['beam'+str(i)]['ues']),
                                            only_rx  =json.dumps(beams['beam'+str(i)]['only_rx'])
                                            )
                                 new_beam.save()
                                 i=i+1
                         else: #beams_number < absbeams_number:
                             i = 1
                             for absbeam in absbeams:
                                 if i <= beams_number:
                                     absbeam.dict_to_parms(beams['beam'+str(i)])
                                     i=i+1
                                 else:
                                     absbeam.delete()
                     else:
                         for beam in beams:
                             new_beam = ABSBeam(
                                        name     =beams[beam]['name'],
                                        antenna  =json.dumps(beams[beam]['antenna']),
                                        abs_conf = self,
                                        tx       =json.dumps(beams[beam]['tx']),
                                        rx       =json.dumps(beams[beam]['rx']),
                                        ues      =json.dumps(beams[beam]['ues']),
                                        only_rx  =json.dumps(beams[beam]['only_rx'])
                                        )
                             new_beam.save()
                 def update_from_file(self, parameters):
                     self.dict_to_parms(parameters)
                     self.save()
                 def get_beams(self, **kwargs):
                     '''
                     This function returns ABS Configuration beams
                     '''
                     return ABSBeam.objects.filter(abs_conf=self.pk, **kwargs)
                 def clone(self, **kwargs):
                     beams = self.get_beams()
                     self.pk = None
                     self.id = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     for beam in beams:
                         beam.clone(abs_conf=self)
                     #-----For Active Beam-----
                     new_beams = ABSBeam.objects.filter(abs_conf=self)
                     self.active_beam = new_beams[0].id
                     self.save()
                     #-----For Active Beam-----
                     #-----For Device Status---
                     self.device.status = 3
                     self.device.save()
                     #-----For Device Status---
                     return self
                 def start_device(self):
                     if self.device.status == 3:
                         try:
                             #self.write_device()
                             send_task('task_change_beam', [self.id],)
                             self.message = 'ABS running'
                         except Exception as e:
                             self.message = str(e)
                             return False
                         return True
                     else:
                         self.message = 'Please, select Write ABS Device first.'
                         return False
                 def stop_device(self):
+                    print("estoy en ABS models")
                     self.device.status = 2
                     self.device.save()
                     self.message = 'ABS has been stopped.'
                     self.save()
                     return True
                 def stop_device_mqtt(self):
                     self.device.status = 2
                     self.device.save()
                     self.message = 'ABS has been stopped.'
                     self.save()
                     mqtt_client.publish(os.environ.get('TOPIC_ABS', 'abs/beams'),"STOP")
                     return True
                 def write_device(self):
                     """
                     This function sends the beams list to every abs module.
                     It needs 'module_conf' function
                     """
                     print("Write 3")
                     beams  = ABSBeam.objects.filter(abs_conf=self)
                     nbeams = len(beams)
                     # Se manda a cero RC para poder realizar cambio de beam
                     if self.experiment is None:
                         confs = []
                     else:
                         confs = Configuration.objects.filter(experiment = self.experiment).filter(type=0)
                     confdds  = ''
                     confjars = ''
                     confrc   = ''
                     #TO STOP DEVICES: DDS-JARS-RC
                     for i in range(0,len(confs)):
                         if i==0:
                             for conf in confs:
                                 if conf.device.device_type.name == 'dds':
                                     confdds = conf
                                     confdds.stop_device()
                                     break
                         if i==1:
                             for conf in confs:
                                 if conf.device.device_type.name == 'jars':
                                     confjars = conf
                                     confjars.stop_device()
                                     break
                         if i==2:
                             for conf in confs:
                                 if conf.device.device_type.name == 'rc':
                                     confrc = conf
                                     confrc.stop_device()
                                     break
                     '''
                     if self.connected_modules() == 0 :
                         print("No encuentra modulos")
                         self.message = "No ABS Module detected."
                         return False
                     '''
                     #-------------Write each abs module-----------
                     if beams:
                         block_id = 0
                         message = 'SNDF{:03d}{:02d}{:02d}'.format(nbeams, nbeams, block_id)
                         for i, status in enumerate(self.module_status):
                             message += ''.join([fromBinary2Char(beam.module_6bits(i)) for beam in beams])
                         status = ['0'] * 64
                         n = 0
                         print("Llega una antes entrar a multicast4")
                         sock = self.send_multicast(message)
                         while True:
                         #for i in range(32):
                             try:
                                 data, address = sock.recvfrom(1024)
                                 print (address, data)
                                 data = data.decode("utf-8")
                                 if data == '1':
                                     status[int(address[0][10:])-1] = '3'
                                     #print (int(address[0][10:])-1)
                                 elif data == '0':
                                     status[int(address[0][10:])-1] = '1'
                             except socket.timeout:
                                 print('Timeout')
                                 break
                             except Exception as e:
                                 print ('Error {}'.format(e))
                                 n += 1
                         sock.close()
                     else:
                         self.message = "ABS Configuration does not have beams"
                         print('No beams')
                         #Start DDS-RC-JARS
                         if confdds:
                             confdds.start_device()
                         if confrc:
                             #print confrc
                             confrc.start_device()
                         if confjars:
                             confjars.start_device()
                         return False
                     if n == 64:
                         self.message = "Could not write ABS Modules"
                         self.device.status = 0
                         self.module_status = ''.join(status)
                         self.save()
                         print('Could not write ABS')
                         #Start DDS-RC-JARS
                         if confdds:
                             confdds.start_device()
                         if confrc:
                             #print confrc
                             confrc.start_device()
                         if confjars:
                             confjars.start_device()
                         return False
                     else:
                         self.message = "ABS Beams List have been sent to ABS Modules"
                         print('ABS beams list sent')
                         self.active_beam = beams[0].pk
                     #Start DDS-RC-JARS
                     if confdds:
                         confdds.start_device()
                     if confrc:
                         #print confrc
                         confrc.start_device()
                     if confjars:
                         confjars.start_device()
                     print('Inicia intento de salvar device.status')
                     self.device.status = 3
                     self.module_status = ''.join(status)
                     #print(status)
                     self.save()
                     print('Estatus salvado')
                     conf_active, __ = ABSActive.objects.get_or_create(pk=1)
                     conf_active.conf = self
                     conf_active.save()
                     return True
                 def write_device_mqtt(self):
                     if self.experiment is None:
                         confs = []
                     else:
                         confs = Configuration.objects.filter(experiment = self.experiment).filter(type=0)
                     confdds  = ''
                     confjars = ''
                     confrc   = ''
                     #TO STOP DEVICES: DDS-JARS-RC
                     for i in range(0,len(confs)):
                         if i==0:
                             for conf in confs:
                                 if conf.device.device_type.name == 'dds':
                                     confdds = conf
                                     confdds.stop_device()
                                     break
                         if i==1:
                             for conf in confs:
                                 if conf.device.device_type.name == 'jars':
                                     confjars = conf
                                     confjars.stop_device()
                                     break
                         if i==2:
                             for conf in confs:
                                 if conf.device.device_type.name == 'rc':
                                     confrc = conf
                                     confrc.stop_device()
                                     break
                     apuntes_up_down=''
                     beams  = ABSBeam.objects.filter(abs_conf=self)
                     inicializacion="{\"beams\":["
                     finalizacion="]}"
                     for beam in beams:
                         beam.antenna=beam.antenna[1:]
                         info="{\"id\":"+str(beam.id)+","+beam.antenna + ","
                         apuntes_up_down=apuntes_up_down+info
                     apuntes_up_down=apuntes_up_down[:len(apuntes_up_down)-1]
                     apuntes_up_down=inicializacion+ apuntes_up_down+finalizacion
                     mqtt_client.publish(os.environ.get('TOPIC_ABS', 'abs/beams'),apuntes_up_down)
                     #Start DDS-RC-JARS
                     if confdds:
                         confdds.start_device()
                     if confrc:
                         #print confrc
                         confrc.start_device()
                     if confjars:
                         confjars.start_device()
                     return True
                 def read_module(self, module):
                     """
                     Read out-bits (up-down) of 1 abs module NOT for Configuration
                     """
                     ip_address  = self.device.ip_address
                     ip_address  = ip_address.split('.')
                     module_seq  = (ip_address[0],ip_address[1],ip_address[2])
                     dot         = '.'
                     module_ip   = dot.join(module_seq)+'.'+str(module)
                     module_port = self.device.port_address
                     read_route = 'http://'+module_ip+':'+str(module_port)+'/read'
                     module_status = json.loads(self.module_status)
                     print(read_route)
                     module_bits = ''
                     try:
                         r_read      = requests.get(read_route, timeout=0.5)
                         answer      = r_read.json()
                         module_bits = answer['allbits']
                     except:
                         return {}
                     return module_bits
                 def read_device(self):
                     parms = {}
                     # Reads active modules.
                     module_status = json.loads(self.module_status)
                     total = 0
                     for status in module_status:
                         if module_status[status] != 0:
                             module_bits = self.read_module(int(status))
                             bits={}
                             if module_bits:
                                 bits = (str(module_bits['um2']) + str(module_bits['um1']) + str(module_bits['um0']) +
                                         str(module_bits['dm2']) + str(module_bits['dm1']) + str(module_bits['dm0']) )
                                 parms[str(status)] = bits
                             total +=1
                     if total==0:
                         self.message = "No ABS Module detected. Please select 'Status'."
                         return False
                     self.message = "ABS Modules have been read"
                     #monitoreo_tx = JROABSClnt_01CeCnMod000000MNTR10
                     return parms
                 def connected_modules(self):
                     """
                     This function returns the number of connected abs-modules without updating.
                     """
                     num = 0
                     print(self.module_status)
                     for i, status in  enumerate(self.module_status):
                         if status != '0':
                             num += 1
                             #print('status {}:{}'.format(i+1, status))
                     return num
                 def send_multicast(self, message):
                     #print("Send multicast")
                     multicast_group = ('224.3.29.71', 10000)
                     # Create the datagram socket
                     sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
                     sock.settimeout(1)
                     local_ip = os.environ.get('LOCAL_IP', '0.0.0.0')
                     local_ip = '0.0.0.0'
                     print("He llegado a IP local")
                     sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_IF, socket.inet_aton(local_ip))
                     sock.sendto(message.encode(), multicast_group)
                     print('Sending ' + message)
                     return sock
                 def status_device(self):
                     """
                     This function returns the status of all abs-modules as one.
                     If at least one module is connected, its answer is "1"
                     """
                     print ('Status device')
                     print (self.active_beam)
                     beams = ABSBeam.objects.filter(abs_conf=self)
                     #print beams[self.active_beam-1].module_6bits(0)
                     active = ABSActive.objects.get(pk=1)
                     if active.conf != self:
                         self.message = 'La configuracion actual es la del siguiente enlace %s.' % active.conf.get_absolute_url()
                         self.message +=  "\n"
                         self.message += 'Se debe realizar un write en esta configuracion para luego obtener un status valido.'
                         return False
                     sock = self.send_multicast('MNTR')
                     n = 0
                     status = ['0'] * 64
                     while True:
                     #for i in range(32):
                         #if True:
                         try:
                             print("Recibiendo")
                             address = None
                             data, address = sock.recvfrom(2)
                             print (address, data)
                             print("!!!!")
                             data = data.decode()
                             aux_mon = "1"
                             aux_expected = aux_mon
                             if(len(data)==2):
                                 print ("data[1]: ")
                                 print (data[1])
                                 aux_mon = fromChar2Binary(data[1])
                                 print (aux_mon)
                                 aux_i = (str(address[0]).split('.'))[3]
                                 print (aux_i)
                                 print ('Active beam')
                                 beam_active = ABSBeam.objects.get(pk=self.active_beam)
                                 print (beam_active)
                                 aux_expected = beam_active.module_6bits(int(aux_i)-1)
                                 print (aux_expected)
                             print ("data[0]: ")
                             print (data[0])
                             if data[0] == '1':
                                 status[int(address[0][10:])-1] = '3'
                                 if aux_mon == aux_expected:
                                     print ('Es igual')
                                 else:
                                     print ('Es diferente')
                                     status[int(address[0][10:])-1] = '2'
                             elif data[0] == '0':
                                 status[int(address[0][10:])-1] = '1'
                             n += 1
                             print('Module: {} connected'.format(address))
                         except socket.timeout:
                             print('Timeout')
                             break
                         except:
                             print('Module: {} error'.format(address))
                             pass
                     sock.close()
                     if n > 0:
                         self.message = 'ABS modules Status have been updated.'
                         self.device.status = 1
                     else:
                         self.device.status = 0
                         self.message = 'No ABS module is connected.'
                     self.module_status = ''.join(status)
                     self.save()
                     return self.device.status
                 def send_beam(self, beam_pos):
                     """
                     This function connects to a multicast group and sends the beam number
                     to all abs modules.
                     """
                     print ('Send beam')
                     print (self.active_beam)
                     beams = ABSBeam.objects.filter(abs_conf=self)
                     #print beams[self.active_beam-1].module_6bits(0)
                     active = ABSActive.objects.get(pk=1)
                     if active.conf != self:
                         self.message = 'La configuracion actual es la del siguiente enlace %s.' % active.conf.get_absolute_url()
                         self.message +=  "\n"
                         self.message += 'Se debe realizar un write en esta configuracion para luego obtener un status valido.'
                         return False
                     # Se manda a cero RC para poder realizar cambio de beam
                     if self.experiment is None:
                         confs = []
                     else:
                         confs = Configuration.objects.filter(experiment = self.experiment).filter(type=0)
                     confdds  = ''
                     confjars = ''
                     confrc   = ''
                     #TO STOP DEVICES: DDS-JARS-RC
                     for i in range(0,len(confs)):
                         if i==0:
                             for conf in confs:
                                 if conf.device.device_type.name == 'dds':
                                     confdds = conf
                                     confdds.stop_device()
                                     break
                         if i==1:
                             for conf in confs:
                                 if conf.device.device_type.name == 'jars':
                                     confjars = conf
                                     confjars.stop_device()
                                     break
                         if i==2:
                             for conf in confs:
                                 if conf.device.device_type.name == 'rc':
                                     confrc = conf
                                     confrc.stop_device()
                                     break
                     if beam_pos > 0:
                         beam_pos = beam_pos - 1
                     else:
                         beam_pos = 0
                     #El indice del apunte debe ser menor que el numero total de apuntes
                     #El servidor tcp en el embebido comienza a contar desde 0
                     status = ['0'] * 64
                     message = 'CHGB{}'.format(beam_pos)
                     sock = self.send_multicast(message)
                     while True:
                     #for i in range(32):
                         try:
                             data, address = sock.recvfrom(1024)
                             print (address, data)
                             data = data.decode()
                             if data == '1':
                                 status[int(address[0][10:])-1] = '3'
                             elif data == '0':
                                 status[int(address[0][10:])-1] = '1'
                         except socket.timeout:
                             print('Timeout')
                             break
                         except  Exception as e:
                             print ('Error {}'.format(e))
                             pass
                     sock.close()
                     #Start DDS-RC-JARS
                     if confdds:
                         confdds.start_device()
                     if confrc:
                         #print confrc
                         confrc.start_device()
                     if confjars:
                         confjars.start_device()
                     self.message = "ABS Beam has been changed"
                     self.module_status = ''.join(status)
                     self.save()
                     return True
                 def get_absolute_url_import(self):
                     return reverse('url_import_abs_conf', args=[str(self.id)])
             class ABSActive(models.Model):
                 conf = models.ForeignKey(ABSConfiguration, null=True, verbose_name='ABS Configuration', on_delete=models.CASCADE)
                 class Meta:
                     db_table = 'abs_absactive'
             class ABSBeam(models.Model):
                 name         = models.CharField(max_length=60, default='Beam')
                 antenna      = models.CharField(verbose_name='Antenna', max_length=1000, default=antenna_default)
                 abs_conf     = models.ForeignKey('ABSConfiguration', null=True,
                 verbose_name='ABS Configuration', on_delete=models.CASCADE)
                 tx           = models.CharField(verbose_name='Tx', max_length=1000, default=tx_default)
                 rx           = models.CharField(verbose_name='Rx', max_length=1000, default=rx_default)
                 s_time       = models.TimeField(verbose_name='Star Time', default='00:00:00')
                 e_time       = models.TimeField(verbose_name='End Time', default='23:59:59')
                 ues          = models.CharField(verbose_name='Ues', max_length=100, default=ues_default)
                 only_rx      = models.CharField(verbose_name='Only RX', max_length=40, default=onlyrx_default)
                 class Meta:
                     db_table = 'abs_beams'
                 def __unicode__(self):
                     return u'%s' % (self.name)
                 def parms_to_dict(self):
                     parameters = {}
                     parameters['name']          = self.name
                     parameters['antenna']       = ast.literal_eval(self.antenna)
                     parameters['abs_conf']      = self.abs_conf.name
                     parameters['tx']            = ast.literal_eval(self.tx)
                     parameters['rx']            = ast.literal_eval(self.rx)
                     parameters['s_time']        = self.s_time.strftime("%H:%M:%S")
                     parameters['e_time']        = self.e_time.strftime("%H:%M:%S")
                     parameters['ues']           = ast.literal_eval(self.ues)
                     parameters['only_rx']       = json.loads(self.only_rx)
                     return parameters
                 def dict_to_parms(self, parameters):
                     self.name     = parameters['name']
                     self.antenna  = json.dumps(parameters['antenna'])
                     #self.abs_conf = parameters['abs_conf']
                     self.tx       = json.dumps(parameters['tx'])
                     self.rx       = json.dumps(parameters['rx'])
                     #self.s_time = parameters['s_time']
                     #self.e_time = parameters['e_time']
                     self.ues      = json.dumps(parameters['ues'])
                     self.only_rx     = json.dumps(parameters['only_rx'])
                     self.save()
                 def clone(self, **kwargs):
                     self.pk = None
                     self.id = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     return self
                 def module_6bits(self, module):
                     """
                     This function reads antenna pattern and choose 6bits (upbits-downbits) for one abs module
                     """
                     module += 1
                     if module > 64:
                         beam_bits = ""
                         return beam_bits
                     data      = ast.literal_eval(self.antenna)
                     up_data   = data['antenna_up']
                     down_data = data['antenna_down']
                     pos        = ip2position(module)
                     up_value   = up_data[pos[0]][pos[1]]
                     down_value = down_data[pos[0]][pos[1]]
                     up_bits   = up_conv_bits(up_value)
                     down_bits = down_conv_bits(down_value)
                     beam_bits = up_bits+down_bits
                     return beam_bits
                 @property
                 def get_upvalues(self):
                     """
                     This function reads antenna pattern and show the up-value of one abs module
                     """
                     data      = ast.literal_eval(self.antenna)
                     up_data   = data['antenna_up']
                     up_values = []
                     for data in up_data:
                         for i in range(0,8):
                             up_values.append(data[i])
                     return up_values
                 @property
                 def antenna_upvalues(self):
                     """
                     This function reads antenna pattern and show the up - values of one abs beam
                     in a particular order
                     """
                     data      = ast.literal_eval(self.antenna)
                     up_data   = data['antenna_up']
                     return up_data
                 @property
                 def antenna_downvalues(self):
                     """
                     This function reads antenna pattern and show the down - values of one abs beam
                     in a particular order
                     """
                     data      = ast.literal_eval(self.antenna)
                     down_data   = data['antenna_down']
                     return down_data
                 @property
                 def get_downvalues(self):
                     """
                     This function reads antenna pattern and show the down-value of one abs module
                     """
                     data      = ast.literal_eval(self.antenna)
                     down_data = data['antenna_down']
                     down_values = []
                     for data in down_data:
                         for i in range(0,8):
                             down_values.append(data[i])
                     return down_values
                 @property
                 def get_up_ues(self):
                     """
                     This function shows the up-ues-value of one beam
                     """
                     data      = ast.literal_eval(self.ues)
                     up_ues = data['up']
                     return up_ues
                 @property
                 def get_down_ues(self):
                     """
                     This function shows the down-ues-value of one beam
                     """
                     data      = ast.literal_eval(self.ues)
                     down_ues = data['down']
                     return down_ues
                 @property
                 def get_up_onlyrx(self):
                     """
                     This function shows the up-onlyrx-value of one beam
                     """
                     data      = json.loads(self.only_rx)
                     up_onlyrx = data['up']
                     return up_onlyrx
                 @property
                 def get_down_onlyrx(self):
                     """
                     This function shows the down-onlyrx-value of one beam
                     """
                     data      = json.loads(self.only_rx)
                     down_onlyrx = data['down']
                     return down_onlyrx
                 @property
                 def get_tx(self):
                     """
                     This function shows the tx-values of one beam
                     """
                     data = json.loads(self.tx)
                     return data
                 @property
                 def get_uptx(self):
                     """
                     This function shows the up-tx-values of one beam
                     """
                     data = json.loads(self.tx)
                     up_data = data['up']
                     up_values = []
                     for data in up_data:
                         for i in range(0,8):
                             up_values.append(data[i])
                     return up_values
                 @property
                 def get_downtx(self):
                     """
                     This function shows the down-tx-values of one beam
                     """
                     data = json.loads(self.tx)
                     down_data = data['down']
                     down_values = []
                     for data in down_data:
                         for i in range(0,8):
                             down_values.append(data[i])
                     return down_values
                 @property
                 def get_rx(self):
                     """
                     This function shows the rx-values of one beam
                     """
                     data = json.loads(self.rx)
                     return data
                 @property
                 def get_uprx(self):
                     """
                     This function shows the up-rx-values of one beam
                     """
                     data = json.loads(self.rx)
                     up_data = data['up']
                     up_values = []
                     for data in up_data:
                         for i in range(0,8):
                             up_values.append(data[i])
                     return up_values
                 @property
                 def get_downrx(self):
                     """
                     This function shows the down-rx-values of one beam
                     """
                     data = json.loads(self.rx)
                     down_data = data['down']
                     down_values = []
                     for data in down_data:
                         for i in range(0,8):
                             down_values.append(data[i])
                     return down_values

apps/abs/mqtt.py +1 -1

             import os
             import paho.mqtt.client as mqtt
             from radarsys import settings
             from radarsys.socketconfig import sio as sio
             lista_ack=[
                 chr( 33 ), chr( 34 ), chr( 35 ), chr( 36 ), chr( 37 ), chr( 38 ), chr( 39 ), chr( 40 ), chr( 41 ), chr( 42 ), chr( 43 ), chr( 44 ), chr( 45 ), chr( 46 ), chr( 47 ), chr( 48 ), chr( 49 ), chr( 50 ), chr( 51 ), chr( 52 ), chr( 53 ), chr( 54 ), chr( 55 ), chr( 56 ), chr( 57 ), chr( 58 ), chr( 59 ), chr( 60 ), chr( 61 ), chr( 62 ), chr( 63 ), chr( 64 ), chr( 65 ), chr( 66 ), chr( 67 ), chr( 68 ), chr( 69 ), chr( 70 ), chr( 71 ), chr( 72 ), chr( 73 ), chr( 74 ), chr( 75 ), chr( 76 ), chr( 77 ), chr( 78 ), chr( 79 ), chr( 80 ), chr( 81 ), chr( 82 ), chr( 83 ), chr( 84 ), chr( 85 ), chr( 86 ), chr( 87 ), chr( 88 ), chr( 89 ), chr( 90 ), chr( 91 ), chr( 92 ), chr( 93 ), chr( 94 ), chr( 95 ), chr( 96 )
                 ]
             lista_ack_dismatching=[
                 chr( 97 ), chr( 98 ), chr( 99 ), chr( 100 ), chr( 101 ), chr( 102 ), chr( 103 ), chr( 104 ), chr( 105 ), chr( 106 ), chr( 107 ), chr( 108 ), chr( 109 ), chr( 110 ), chr( 111 ), chr( 112 ), chr( 113 ), chr( 114 ), chr( 115 ), chr( 116 ), chr( 117 ), chr( 118 ), chr( 119 ), chr( 120 ), chr( 121 ), chr( 122 ), chr( 123 ), chr( 124 ), chr( 125 ), chr( 126 ), chr( 127 ), chr( 128 ), chr( 129 ), chr( 130 ), chr( 131 ), chr( 132 ), chr( 133 ), chr( 134 ), chr( 135 ), chr( 136 ), chr( 137 ), chr( 138 ), chr( 139 ), chr( 140 ), chr( 141 ), chr( 142 ), chr( 143 ), chr( 144 ), chr( 145 ), chr( 146 ), chr( 147 ), chr( 148 ), chr( 149 ), chr( 150 ), chr( 151 ), chr( 152 ), chr( 153 ), chr( 154 ), chr( 155 ), chr( 156 ), chr( 157 ), chr( 158 ), chr( 159 ), chr(160)
             ]
             def on_connect(mqtt_client, userdata, flags, rc):
                if rc == 0:
-                   print('Connected successfully')
+                #    print('Connected successfully')
                    mqtt_client.subscribe(os.environ.get('TOPIC_ABS_ACK','abs/beams_ack'))
                else:
                    print('Bad connection. Code:', rc)
             def on_message(mqtt_client, userdata, msg):
                 # print(f'Received message on topic: {msg.topic} with payload: {msg.payload}', flush=True)
                 # message= str(msg.payload)
                 # sio.emit('abs_ws',data={'msg':message})
                 #message=str(msg.payload)
                 #lista_ack.pop(message)
                 print("Mientras"   ,flush=True)
             client = mqtt.Client()
             client.on_connect = on_connect
             client.on_message = on_message
             client.username_pw_set(os.environ.get('MQTT_USER', 'abs'), os.environ.get('MQTT_PASSWORD', 'abs'))
             client.connect(
                 host=os.environ.get('MQTT_SERVER', '10.10.10.200'),
                 port=int(settings.os.environ.get('MQTT_PORT', 1883)),
                 keepalive=int(os.environ.get('MQTT_KEEPALIVE', 36000))
             )

apps/atrad/mqtt.py +1 -1

             import os
             import paho.mqtt.client as mqtt
             from radarsys import settings
             from radarsys.socketconfig import sio as sio
             import numpy as np
             def on_connect(mqtt_client, userdata, flags, rc):
                if rc == 0:
-                   print('Connected successfully')
+                #    print('Connected successfully')
                    mqtt_client.subscribe('atrad/test3')
                else:
                    print('Bad connection. Code:', rc)
             def maxima_temp(trs):
                 np_array = [np.array(i) for i in trs]
                 temps = [max(i[i<40]) for i in np_array]
                 return max(temps)
             def on_message(mqtt_client, userdata, msg):
                 # print(f'Received message on topic: {msg.topic} with payload: {msg.payload}', flush=True)
                 trsi = [[],[],[],[]]
                 mensaje = str(msg.payload)
                 datos = [i for i in mensaje[21:-1].split("*")]
                 status=''.join([datos[i][3] for i in range(3)])
                 for trs,i in zip(datos,[0,1,2,3]) :
                     trsi[i]= [int(i) for i in trs[1:-1].split(",")]
                 potencias = [trsi[0][34],trsi[0][36],trsi[2][32],trsi[2][34]]
                 tmax = maxima_temp(trsi)
                 sio.emit('test', data={'time':mensaje[2:21],'num':trsi[0][0],'pow':potencias,'tmax':str(tmax),'status':status})
             client = mqtt.Client()
             client.on_connect = on_connect
             client.on_message = on_message
             client.username_pw_set(os.environ.get('MQTT_USER_ATRAD', 'atrad'), os.environ.get('MQTT_PASSWORD_ATRAD', 'atrad'))
             client.connect(
                 host=os.environ.get('MQTT_SERVER', '10.10.10.200'),
                 port=int(settings.os.environ.get('MQTT_PORT', 1883)),
                 keepalive=int(os.environ.get('MQTT_KEEPALIVE', 36000))
             )

apps/main/management/commands/hello.py +90 -6

@@ -1,19 +1,103
1	from django.core.management.base import BaseCommand	1	from django.core.management.base import BaseCommand
2		2	from apps.main.models import Campaign, Location
		3	from datetime import datetime,timedelta
		4	from apps.main.views import radar_start
		5	from django.shortcuts import render, redirect,get_object_or_404, HttpResponse
		6	from django.urls import reverse
		7	from django.utils.timezone import is_aware
		8	from django.contrib import messages
		9	from django.http import HttpResponseRedirect
		10	from apps.main.views import experiment_start
		11	from apps.main.models import Experiment, Configuration
3		12
4	class Command(BaseCommand):	13	class Command(BaseCommand):
5	"""	14	"""
6	Restart experiment every night at 05:00 am.	15	Restart experiment every night at 05:00 am.
7	Example:	16	Example:
8	manage.py restart_experiment	17	manage.py restart_experiment
9	"""	18	"""
10	def handle(self, args, *options):	19	def handle(self, args, *options):
11	print("~~Hola~~")	20	print("")
		21	campaigns = Campaign.objects.filter(start_date__lte=datetime.now(),
		22	end_date__gte=datetime.now()).order_by('-start_date')
		23
		24	if campaigns:
		25
		26	for campaign in campaigns:
		27	print(campaign.name)
		28	print(campaign.start_date)
		29	print(campaign.end_date)
		30	print(campaign.experiments.all()[0].id)
		31	print("STATUS: ",campaign.experiments.all()[0].status)
		32
		33	radar=campaign.get_experiments_by_radar(radar=None)
		34	radar_id=radar[0]["id"]
		35	print(radar_id)
		36
		37	now = datetime.now()
		38	if now<campaign.end_date and now >campaign.start_date:
		39	print("La campaña",campaign.name ,"se ejecuta!",flush=True)
		40	radar_start_scheduler(campaign.id,radar_id)
		41
		42	else:
		43	copy_campaigns=Campaign.objects.all()
		44	print("-------------Deteniendo procesos-------------")
		45	for campaign in copy_campaigns:
		46	print(campaign.name)
		47	print(campaign.start_date)
		48	print(campaign.end_date)
		49	print("ID: ",campaign.experiments.all()[0].id)
		50	print("STATUS: ",campaign.experiments.all()[0].status)
		51	print("----,,,---")
		52	radar=campaign.get_experiments_by_radar(radar=None)
		53	radar_id=radar[0]["id"]
		54
		55	if campaign.experiments.all()[0].status !=1:
		56	print("Estoy en :",campaign.experiments.all()[0].status)
		57	print("Con ID: ",campaign.experiments.all()[0].id)
		58	print("\n\n")
		59	a=radar_stop_scheduler(campaign.id,radar_id,campaign.experiments.all()[0].id)
		60	print("RETURN", a)
		61
		62
		63	def radar_start_scheduler(id_camp,id_radar):
		64	print("-------------------")
		65	campaign = get_object_or_404(Campaign, pk=id_camp)
		66	experiments = campaign.get_experiments_by_radar(id_radar)[0]['experiments']
		67	now = datetime.now()
		68
		69	for exp in experiments:
		70	exp = get_object_or_404(Experiment, pk=exp.id)
12		71
13	# def main():	72	if exp.status == 2:
14	# print("Hola")	73	print('Experiment {} already runnnig'.format(exp))
		74	else:
		75	exp.status = exp.start()
		76	if exp.status == 0:
		77	print('Experiment {} not start'.format(exp))
		78	if exp.status == 2:
		79	print('Experiment {} started'.format(exp))
		80	exp.save()
15		81
16	# if __name__=='__main__':	82	def radar_stop_scheduler(id_camp,id_radar,id_experiment):
17	# main()	83	print("-------------------")
		84	'''
		85	Stop experiments's devices
		86	DDS-JARS-RC-CGS-ABS
		87	'''
		88	exp=get_object_or_404(Experiment,pk=id_experiment)
18		89
		90	if exp.status == 2:
		91	confs = Configuration.objects.filter(experiment=id_experiment,type = 0).order_by('device__device_type__sequence')
		92	confs = confs.exclude(device__device_type__name='cgs')
		93	try:
		94	for conf in confs:
		95	print("Estoy en conf_scheduler")
		96	print(conf)
		97	conf.stop_device()
		98	exp.status= 1
		99	except:
		100	exp.status= 0
		101	exp.save()
19		102
		103	return exp.status No newline at end of file

apps/main/models.py 0 -1

             import os
             import json
             import requests
             import time
             from datetime import datetime
             try:
                 from polymorphic.models import PolymorphicModel
             except:
                 from polymorphic import PolymorphicModel
             from django.template.base import kwarg_re
             from django.db import models
             from django.urls import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from django.shortcuts import get_object_or_404
             from django.contrib.auth.models import User
             from django.db.models.signals import post_save
             from django.dispatch import receiver
             from apps.main.utils import Params
             from apps.rc.utils import RCFile
             from apps.jars.utils import RacpFile
             from devices.dds import api as dds_api
             from devices.dds import data as dds_data
             DEV_PORTS = {
                             'rc'    : 2000,
                             'dds'   : 2000,
                             'jars'  : 2000,
                             'usrp'  : 2000,
                             'cgs'   : 8080,
                             'abs'   : 8080,
                             'dds_rest': 80
                         }
             RADAR_STATES = (
                              (0, 'No connected'),
                              (1, 'Connected'),
                              (2, 'Configured'),
                              (3, 'Running'),
                              (4, 'Scheduled'),
                          )
             EXPERIMENT_TYPE = (
                                (0, 'RAW_DATA'),
                                (1, 'PDATA'),
                                )
             DECODE_TYPE = (
                          (0, 'None'),
                          (1, 'TimeDomain'),
                          (2, 'FreqDomain'),
                          (3, 'InvFreqDomain'),
                          )
             DEV_STATES = (
                              (0, 'No connected'),
                              (1, 'Connected'),
                              (2, 'Configured'),
                              (3, 'Running'),
                              (4, 'Unknown'),
                          )
             DEV_TYPES = (
                             ('', 'Select a device type'),
                             ('rc', 'Radar Controller'),
                             ('dds', 'Direct Digital Synthesizer'),
                             ('jars', 'Jicamarca Radar Acquisition System'),
                             ('usrp', 'Universal Software Radio Peripheral'),
                             ('cgs', 'Clock Generator System'),
                             ('abs', 'Automatic Beam Switching'),
                             ('dds_rest', 'Direct Digital Synthesizer_REST'),
                             ('atrad', 'Transmitter ATRAD'),
                         )
             EXP_STATES = (
                              (0,'Error'),                 #RED
                              (1,'Cancelled'),             #YELLOW
                              (2,'Running'),               #GREEN
                              (3,'Scheduled'),             #BLUE
                              (4,'Unknown'),               #WHITE
                          )
             CONF_TYPES = (
                              (0, 'Active'),
                              (1, 'Historical'),
                          )
             class Profile(models.Model):
                 user = models.OneToOneField(User, on_delete=models.CASCADE)
                 theme = models.CharField(max_length=30, default='spacelab')
             @receiver(post_save, sender=User)
             def create_user_profile(sender, instance, created, **kwargs):
                 if created:
                     Profile.objects.create(user=instance)
             @receiver(post_save, sender=User)
             def save_user_profile(sender, instance, **kwargs):
                 instance.profile.save()
             class Location(models.Model):
                 name = models.CharField(max_length = 30)
                 description = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'db_location'
                 def __str__(self):
                     return u'%s' % self.name
                 def get_absolute_url(self):
                     return reverse('url_location', args=[str(self.id)])
             class DeviceType(models.Model):
                 name = models.CharField(max_length = 10, choices = DEV_TYPES, default = 'dds_rest')
                 sequence = models.PositiveSmallIntegerField(default=55)
                 description = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'db_device_types'
                 def __str__(self):
                     return u'%s' % self.get_name_display()
             class Device(models.Model):
                 device_type  = models.ForeignKey('DeviceType', on_delete=models.CASCADE)
                 location     = models.ForeignKey('Location', on_delete=models.CASCADE)
                 ip_address   = models.GenericIPAddressField(protocol='IPv4', default='0.0.0.0')
                 port_address = models.PositiveSmallIntegerField(default=2000)
                 description  = models.TextField(blank=True, null=True)
                 status       = models.PositiveSmallIntegerField(default=4, choices=DEV_STATES)
                 conf_active  = models.PositiveIntegerField(default=0, verbose_name='Current configuration')
                 class Meta:
                     db_table = 'db_devices'
                 def __str__(self):
                     ret = u'{} [{}]'.format(self.device_type.name.upper(), self.location.name)
                     return ret
                 @property
                 def name(self):
                     return str(self)
                 def get_status(self):
                     return self.status
                 @property
                 def status_color(self):
                     color = 'muted'
                     if self.status == 0:
                         color = "danger"
                     elif self.status == 1:
                         color = "warning"
                     elif self.status == 2:
                         color = "info"
                     elif self.status == 3:
                         color = "success"
                     return color
                 def url(self, path=None):
                     if path:
                         return 'http://{}:{}/{}/'.format(self.ip_address, self.port_address, path)
                     else:
                         return 'http://{}:{}/'.format(self.ip_address, self.port_address)
                 def get_absolute_url(self):
                     return reverse('url_device', args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_device', args=[str(self.id)])
                 def get_absolute_url_delete(self):
                     return reverse('url_delete_device', args=[str(self.id)])
                 def change_ip(self, ip_address, mask, gateway, dns, **kwargs):
                     if self.device_type.name=='dds':
                         try:
                             answer = dds_api.change_ip(ip = self.ip_address,
                                                        port = self.port_address,
                                                        new_ip = ip_address,
                                                        mask = mask,
                                                        gateway = gateway)
                             if answer[0]=='1':
                                 self.message = '25|DDS - {}'.format(answer)
                                 self.ip_address = ip_address
                                 self.save()
                             else:
                                 self.message = '30|DDS - {}'.format(answer)
                                 return False
                         except Exception as e:
                             self.message = '40|{}'.format(str(e))
                             return False
                     elif self.device_type.name=='rc':
                         headers = {'content-type': "application/json",
                                    'cache-control': "no-cache"}
                         ip      = [int(x) for x in ip_address.split('.')]
                         dns     = [int(x) for x in dns.split('.')]
                         gateway = [int(x) for x in gateway.split('.')]
                         subnet  = [int(x) for x in mask.split('.')]
                         payload = {
                             "ip": ip,
                             "dns": dns,
                             "gateway": gateway,
                             "subnet": subnet
                             }
                         req = requests.post(self.url('changeip'), data=json.dumps(payload), headers=headers)
                         try:
                             answer = req.json()
                             if answer['changeip']=='ok':
                                 self.message    = '25|IP succesfully changed'
                                 self.ip_address = ip_address
                                 self.save()
                             else:
                                 self.message = '30|An error ocuur when changing IP'
                         except Exception as e:
                             self.message = '40|{}'.format(str(e))
                     else:
                         self.message = 'Not implemented'
                         return False
                     return True
             class Campaign(models.Model):
                 template    = models.BooleanField(default=False)
                 name        = models.CharField(max_length=60, unique=True)
                 start_date  = models.DateTimeField(blank=True, null=True)
                 end_date    = models.DateTimeField(blank=True, null=True)
                 tags        = models.CharField(max_length=40, blank=True, null=True)
                 description = models.TextField(blank=True, null=True)
                 experiments = models.ManyToManyField('Experiment', blank=True)
                 author      = models.ForeignKey(User, null=True, blank=True,on_delete=models.CASCADE)
                 class Meta:
                     db_table = 'db_campaigns'
                     ordering = ('name',)
                 def __str__(self):
                     if self.template:
                         return u'{} (template)'.format(self.name)
                     else:
                         return u'{}'.format(self.name)
                 def jsonify(self):
                     data = {}
                     ignored = ('template')
                     for field in self._meta.fields:
                         if field.name in ignored:
                             continue
                         data[field.name] = field.value_from_object(self)
                     data['start_date'] = data['start_date'].strftime('%Y-%m-%d')
                     data['end_date']   = data['end_date'].strftime('%Y-%m-%d')
                     return data
                 def parms_to_dict(self):
                     params = Params({})
                     params.add(self.jsonify(), 'campaigns')
                     for exp in Experiment.objects.filter(campaign = self):
                         params.add(exp.jsonify(), 'experiments')
                         configurations = Configuration.objects.filter(experiment=exp, type=0)
                         for conf in configurations:
                             params.add(conf.jsonify(), 'configurations')
                             if conf.device.device_type.name=='rc':
                                 for line in conf.get_lines():
                                     params.add(line.jsonify(), 'lines')
                     return params.data
                 def dict_to_parms(self, parms, CONF_MODELS):
                     experiments = Experiment.objects.filter(campaign = self)
                     if experiments:
                         for experiment in experiments:
                             experiment.delete()
                     for id_exp in parms['experiments']['allIds']:
                         exp_parms = parms['experiments']['byId'][id_exp]
                         dum = (datetime.now() - datetime(1970, 1, 1)).total_seconds()
                         exp = Experiment(name='{}'.format(dum))
                         exp.save()
                         exp.dict_to_parms(parms, CONF_MODELS, id_exp=id_exp)
                         self.experiments.add(exp)
                     camp_parms = parms['campaigns']['byId'][parms['campaigns']['allIds'][0]]
                     self.name       = '{}-{}'.format(camp_parms['name'], datetime.now().strftime('%y%m%d'))
                     self.start_date = camp_parms['start_date']
                     self.end_date   = camp_parms['end_date']
                     self.tags       = camp_parms['tags']
                     self.save()
                     return self
                 def get_experiments_by_radar(self, radar=None):
                     ret = []
                     if radar:
                         locations = Location.objects.filter(pk=radar)
                     else:
                         locations = set([e.location for e in self.experiments.all()])
                     for loc in locations:
                         dum = {}
                         dum['name']        = loc.name
                         dum['id']          = loc.pk
                         dum['experiments'] = [e for e in self.experiments.all() if e.location==loc]
                         ret.append(dum)
                     return ret
                 def get_absolute_url(self):
                     return reverse('url_campaign', args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_campaign', args=[str(self.id)])
                 def get_absolute_url_delete(self):
                     return reverse('url_delete_campaign', args=[str(self.id)])
                 def get_absolute_url_export(self):
                     return reverse('url_export_campaign', args=[str(self.id)])
                 def get_absolute_url_import(self):
                     return reverse('url_import_campaign', args=[str(self.id)])
             class RunningExperiment(models.Model):
                 radar              = models.OneToOneField('Location', on_delete=models.CASCADE)
                 running_experiment = models.ManyToManyField('Experiment', blank = True)
                 status             = models.PositiveSmallIntegerField(default=0, choices=RADAR_STATES)
             class Experiment(models.Model):
                 template   = models.BooleanField(default=False)
                 name       = models.CharField(max_length=40, default='', unique=True)
                 location   = models.ForeignKey('Location', null=True, blank=True, on_delete=models.CASCADE)
                 freq       = models.FloatField(verbose_name='Operating Freq. (MHz)', validators=[MinValueValidator(1), MaxValueValidator(10000)], default=49.9200)
                 start_time = models.TimeField(default='00:00:00')
                 end_time   = models.TimeField(default='23:59:59')
                 task       = models.CharField(max_length=36, default='', blank=True, null=True)
                 status     = models.PositiveSmallIntegerField(default=4, choices=EXP_STATES)
                 author     = models.ForeignKey(User, null=True, blank=True,on_delete=models.CASCADE)
                 hash       = models.CharField(default='', max_length=64, null=True, blank=True)
                 class Meta:
                     db_table = 'db_experiments'
                     ordering = ('template', 'name')
                 def __str__(self):
                     if self.template:
                         return u'%s (template)' % (self.name)
                     else:
                         return u'%s' % (self.name)
                 def jsonify(self):
                     data = {}
                     ignored = ('template')
                     for field in self._meta.fields:
                         if field.name in ignored:
                             continue
                         data[field.name] = field.value_from_object(self)
                     data['start_time'] = data['start_time'].strftime('%H:%M:%S')
                     data['end_time']   = data['end_time'].strftime('%H:%M:%S')
                     data['location']   = self.location.name
                     data['configurations'] = ['{}'.format(conf.pk) for
                         conf in Configuration.objects.filter(experiment=self, type=0)]
                     return data
                 @property
                 def radar_system(self):
                     return self.location
                 def clone(self, **kwargs):
                     confs = Configuration.objects.filter(experiment=self, type=0)
                     self.pk = None
                     self.name = '{}_{:%y%m%d%H%M%S}'.format(self.name, datetime.now())
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     for conf in confs:
                         conf.clone(experiment=self, template=False)
                     return self
                 def start(self):
                     '''
                     Configure and start experiments's devices
                     ABS-CGS-DDS-RC-JARS
                     '''
                     confs = []
                     allconfs = Configuration.objects.filter(experiment=self, type = 0).order_by('-device__device_type__sequence')
                     rc_mix   = [conf for conf in allconfs if conf.device.device_type.name=='rc' and conf.mix]
                     if rc_mix:
                         for conf in allconfs:
                             if conf.device.device_type.name == 'rc' and  not conf.mix:
                                 continue
                             confs.append(conf)
                     else:
                         confs = allconfs
                     print("confs: ",confs)
                     #try:
                     for conf in confs:
                         print("conf->",conf)
                         conf.stop_device()
                         conf.write_device()
                         conf.device.conf_active = conf.pk
                         conf.device.save()
                         conf.start_device()
                         time.sleep(1)
                     #except:
                         #return 0
                     return 2
                 def stop(self):
                     '''
                     Stop experiments's devices
                     DDS-JARS-RC-CGS-ABS
                     '''
                     confs = Configuration.objects.filter(experiment=self, type = 0).order_by('device__device_type__sequence')
                     confs = confs.exclude(device__device_type__name='cgs')
                     try:
                         for conf in confs:
                             conf.stop_device()
                     except:
                         return 0
                     return 1
                 def get_status(self):
                     if self.status == 3:
                         return
                     confs =  Configuration.objects.filter(experiment=self, type=0)
                     for conf in confs:
                         conf.status_device()
                     total = confs.aggregate(models.Sum('device__status'))['device__status__sum']
                     if total==2*confs.count():
                         status = 1
                     elif total == 3*confs.count():
                         status = 2
                     else:
                         status = 0
                     self.status = status
                     self.save()
                 def status_color(self):
                     color = 'muted'
                     if self.status == 0:
                         color = "danger"
                     elif self.status == 1:
                         color = "warning"
                     elif self.status == 2:
                         color = "success"
                     elif self.status == 3:
                         color = "info"
                     return color
                 def parms_to_dict(self):
                     params = Params({})
                     params.add(self.jsonify(), 'experiments')
                     configurations = Configuration.objects.filter(experiment=self, type=0)
                     for conf in configurations:
                         params.add(conf.jsonify(), 'configurations')
                         if conf.device.device_type.name=='rc':
                             for line in conf.get_lines():
                                 params.add(line.jsonify(), 'lines')
                     return params.data
                 def dict_to_parms(self, parms, CONF_MODELS, id_exp=None):
                     configurations = Configuration.objects.filter(experiment=self)
                     if id_exp is not None:
                         exp_parms = parms['experiments']['byId'][id_exp]
                     else:
                         exp_parms = parms['experiments']['byId'][parms['experiments']['allIds'][0]]
                     if configurations:
                         for configuration in configurations:
                             configuration.delete()
                     for id_conf in exp_parms['configurations']:
                         conf_parms = parms['configurations']['byId'][id_conf]
                         device     = Device.objects.filter(device_type__name=conf_parms['device_type'])[0]
                         model      = CONF_MODELS[conf_parms['device_type']]
                         conf = model(
                             experiment = self,
                             device = device,
                             )
                         conf.dict_to_parms(parms, id=id_conf)
                     location, created = Location.objects.get_or_create(name=exp_parms['location'])
                     self.name = '{}-{}'.format(exp_parms['name'], datetime.now().strftime('%y%m%d'))
                     self.location   = location
                     self.start_time = exp_parms['start_time']
                     self.end_time   = exp_parms['end_time']
                     self.save()
                     return self
                 def get_absolute_url(self):
                     return reverse('url_experiment', args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_experiment', args=[str(self.id)])
                 def get_absolute_url_delete(self):
                     return reverse('url_delete_experiment', args=[str(self.id)])
                 def get_absolute_url_import(self):
                     return reverse('url_import_experiment', args=[str(self.id)])
                 def get_absolute_url_export(self):
                     return reverse('url_export_experiment', args=[str(self.id)])
                 def get_absolute_url_start(self):
                     return reverse('url_start_experiment', args=[str(self.id)])
                 def get_absolute_url_stop(self):
                     return reverse('url_stop_experiment', args=[str(self.id)])
             class Configuration(PolymorphicModel):
                 template        = models.BooleanField(default=False)
                 # name          = models.CharField(verbose_name="Configuration Name", max_length=40, default='')
                 device          = models.ForeignKey('Device', verbose_name='Device', null=True, on_delete=models.CASCADE)
                 label           = models.CharField(verbose_name="Label", max_length=40, default='', blank=True, null=True)
                 experiment      = models.ForeignKey('Experiment', verbose_name='Experiment', null=True, blank=True, on_delete=models.CASCADE)
                 type            = models.PositiveSmallIntegerField(default=0, choices=CONF_TYPES)
                 created_date    = models.DateTimeField(auto_now_add=True)
                 programmed_date = models.DateTimeField(auto_now=True)
                 parameters      = models.TextField(default='{}')
                 author          = models.ForeignKey(User, null=True, blank=True,on_delete=models.CASCADE)
                 hash            = models.CharField(default='', max_length=64, null=True, blank=True)
                 message = ""
                 class Meta:
                     db_table = 'db_configurations'
                     ordering = ('device__device_type__name',)
                 def __str__(self):
                     ret = u'{} '.format(self.device.device_type.name.upper())
                     if 'mix' in [f.name for f in self._meta.get_fields()]:
                         if self.mix:
                             ret = '{} MIX '.format(self.device.device_type.name.upper())
                     if 'label' in [f.name for f in self._meta.get_fields()]:
                         ret += '{}'.format(self.label)
                     if self.template:
                         ret += ' (template)'
                     return ret
                 @property
                 def name(self):
                     return str(self)
                 def jsonify(self):
                     data = {}
                     ignored = ('type', 'polymorphic_ctype', 'configuration_ptr',
                                'created_date', 'programmed_date', 'template', 'device',
                                'experiment')
                     for field in self._meta.fields:
                         if field.name in ignored:
                             continue
                         data[field.name] = field.value_from_object(self)
                     data['device_type'] = self.device.device_type.name
                     if self.device.device_type.name == 'rc':
                         data['lines'] = ['{}'.format(line.pk) for line in self.get_lines()]
                         data['delays'] = self.get_delays()
                         data['pulses'] = self.get_pulses()
                     elif self.device.device_type.name == 'jars':
                         data['decode_type'] = DECODE_TYPE[self.decode_data][1]
                     elif self.device.device_type.name == 'dds':
                         data['frequencyA_Mhz'] = float(data['frequencyA_Mhz'])
                         data['frequencyB_Mhz'] = float(data['frequencyB_Mhz'])
                         data['phaseA'] = dds_data.phase_to_binary(data['phaseA_degrees'])
                         data['phaseB'] = dds_data.phase_to_binary(data['phaseB_degrees'])
                     elif self.device.device_type.name == 'dds_rest':
                         data['frequencyA_Mhz'] = float(data['frequencyA_Mhz'])
                         data['frequencyB_Mhz'] = float(data['frequencyB_Mhz'])
                         data['phaseA'] = dds_data.phase_to_binary(data['phaseA_degrees'])
                         data['phaseB'] = dds_data.phase_to_binary(data['phaseB_degrees'])
                         data['delta_frequency_Mhz'] = float(data['delta_frequency_Mhz'] or 0.00)
                         data['update_clock_Mhz']    = float(data['update_clock_Mhz'] or 0.00)
                         data['ramp_rate_clock_Mhz'] = float(data['ramp_rate_clock_Mhz'] or 0.0)
                     return data
                 def clone(self, **kwargs):
                     self.pk = None
                     self.id = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     return self
                 def parms_to_dict(self):
                     params = Params({})
                     params.add(self.jsonify(), 'configurations')
                     if self.device.device_type.name=='rc':
                         for line in self.get_lines():
                             params.add(line.jsonify(), 'lines')
                     return params.data
                 def parms_to_text(self):
                     raise NotImplementedError("This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper())
                 def parms_to_binary(self):
                     raise NotImplementedError("This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper())
                 def dict_to_parms(self, parameters, id=None):
                     params = Params(parameters)
                     if id:
                         data = params.get_conf(id_conf=id)
                     else:
                         data = params.get_conf(dtype=self.device.device_type.name)
                     if data['device_type']=='rc':
                         self.clean_lines()
                         lines = data.pop('lines', None)
                         for line_id in lines:
                             pass
                     for key, value in data.items():
                         if key not in ('id', 'device_type'):
                             setattr(self, key, value)
                     self.save()
                 def export_to_file(self, format="json"):
                     content_type = ''
                     if format == 'racp':
                         content_type = 'text/plain'
                         filename = '%s_%s.%s' %(self.device.device_type.name, self.name, 'racp')
                         content = self.parms_to_text(file_format = 'racp')
                     if format == 'text':
                         content_type = 'text/plain'
                         filename = '%s_%s.%s' %(self.device.device_type.name, self.name, self.device.device_type.name)
                         content = self.parms_to_text()
                     if format == 'binary':
                         content_type = 'application/octet-stream'
                         filename = '%s_%s.bin' %(self.device.device_type.name, self.name)
                         content = self.parms_to_binary()
                     if not content_type:
                         content_type = 'application/json'
                         filename = '%s_%s.json' %(self.device.device_type.name, self.name)
                         content = json.dumps(self.parms_to_dict(), indent=2)
                     fields = {'content_type':content_type,
                               'filename':filename,
                               'content':content
                               }
                     return fields
                 def import_from_file(self, fp):
                     parms = {}
                     path, ext = os.path.splitext(fp.name)
                     if ext == '.json':
                         parms = json.load(fp)
                     if ext == '.dds':
                         lines = fp.readlines()
                         parms = dds_data.text_to_dict(lines)
                     if ext == '.racp':
                         if self.device.device_type.name == 'jars':
                             parms = RacpFile(fp).to_dict()
                             parms['filter_parms'] = json.loads(self.filter_parms)
                             return parms
                         parms = RCFile(fp).to_dict()
                     return parms
                 def status_device(self):
                     self.message = 'Function not implemented'
                     return False
                 def stop_device(self):
                     self.message = 'Function not implemented'
                     return False
                 def start_device(self):
                     self.message = 'Function not implemented'
                     return False
                 def write_device(self, parms):
                     self.message = 'Function not implemented'
                     return False
                 def write_device_mqtt(self, parms):
                     self.message = 'Function not implemented'
                     return False
                 def read_device(self):
                     self.message = 'Function not implemented'
                     return False
                 def get_absolute_url(self):
                     return reverse('url_%s_conf' % self.device.device_type.name, args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_%s_conf' % self.device.device_type.name, args=[str(self.id)])
                 def get_absolute_url_delete(self):
                     return reverse('url_delete_dev_conf', args=[str(self.id)])
                 def get_absolute_url_import(self):
                     return reverse('url_import_dev_conf', args=[str(self.id)])
                 def get_absolute_url_export(self):
                     return reverse('url_export_dev_conf', args=[str(self.id)])
                 def get_absolute_url_write(self):
                     return reverse('url_write_dev_conf', args=[str(self.id)])
                 def get_absolute_url_write_mqtt(self):
                     return reverse('url_write_mqtt_dev_conf', args=[str(self.id)])
                 def get_absolute_url_read(self):
                     return reverse('url_read_dev_conf', args=[str(self.id)])
                 def get_absolute_url_start(self):
                     return reverse('url_start_dev_conf', args=[str(self.id)])
                 def get_absolute_url_stop(self):
                     return reverse('url_stop_dev_conf', args=[str(self.id)])
                 def get_absolute_url_stop_mqtt(self):
                     return reverse('url_stop_mqtt_dev_conf', args=[str(self.id)])
                 def get_absolute_url_status(self):
                     return reverse('url_status_dev_conf', args=[str(self.id)])

apps/main/mqtt.py +1 -1

             import os
             import paho.mqtt.client as mqtt
             from radarsys import settings
             from radarsys.socketconfig import sio as sio
             lista_ack=[
 , 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, 124, 125, 126, 127, 128
                     ]
             def on_connect(mqtt_client, userdata, flags, rc):
                if rc == 0:
-                   print('Connected successfully')
+                   #print('Connected successfully')
                    mqtt_client.subscribe(os.environ.get('TOPIC_ABS_ACK','abs/beams_ack'))
                else:
                    print('Bad connection. Code:', rc)
             def on_message(mqtt_client, userdata, msg):
                 # print(f'Received message on topic: {msg.topic} with payload: {msg.payload}', flush=True)
                 # message= str(msg.payload)
                 # sio.emit('abs_ws',data={'msg':message})
                 #print("HOLA",flush=True)
                 # message=msg.payload[1]
                 # print("HOLAAA ",message,flush=True)
                 # #lista_ack.remove(msg.payload)
                 # print("LISTA     ",lista_ack)
                 global lista_ack
                 global lista_ack_dismatching
                 message= str(msg.payload)
                 message=message[2:len(message)-1]
                 if(message=="UPDATE"):
                     print("UUPDATE")
                     sio.emit('beams_ack',data={'msg':lista_ack})
                     print(lista_ack,flush=True)
                     lista_ack=[
 , 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, 124, 125, 126, 127, 128
                     ]
                 else:
                     message=int(message)
                     if(message<=64):
                         # print(message,"\t MATCH",flush=True)
                         lista_ack.remove(message+64)
                     elif(message>64):
                         # print(message,"\t DISMATCH",flush=True)
                         lista_ack.remove(message-64)
                     else:
                         print(len(message))
             client = mqtt.Client()
             client.on_connect = on_connect
             client.on_message = on_message
             client.username_pw_set(os.environ.get('MQTT_USER', 'abs'), os.environ.get('MQTT_PASSWORD', 'abs'))
             client.connect(
                 host=os.environ.get('MQTT_SERVER', '10.10.10.200'),
                 port=int(settings.os.environ.get('MQTT_PORT', 1883)),
                 keepalive=int(os.environ.get('MQTT_KEEPALIVE', 60000))
             )

apps/main/views.py +12 -12

             import ast
             import json
             import hashlib
             from datetime import datetime, timedelta
             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from django.utils.safestring import mark_safe
             from django.http import HttpResponseRedirect
             from django.urls import reverse
             from django.db.models import Q
             from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
             from django.contrib import messages
             from django.http.request import QueryDict
             from django.contrib.auth.decorators import login_required, user_passes_test
             from django.utils.timezone import is_aware
             try:
                 from urllib.parse import urlencode
             except ImportError:
                 from urllib import urlencode
             from .forms import CampaignForm, ExperimentForm, DeviceForm, ConfigurationForm, LocationForm, UploadFileForm, DownloadFileForm, OperationForm, NewForm
             from .forms import OperationSearchForm, FilterForm, ChangeIpForm
             from apps.rc.forms import RCConfigurationForm, RCLineCode, RCMixConfigurationForm
             from apps.dds.forms import DDSConfigurationForm
             from apps.jars.forms import JARSConfigurationForm
             from apps.cgs.forms import CGSConfigurationForm
             from apps.abs.forms import ABSConfigurationForm
             from apps.usrp.forms import USRPConfigurationForm
             from apps.dds_rest.forms import DDSRestConfigurationForm
             from apps.atrad.forms import ATRADConfigurationForm
             from .utils import Params
             from .models              import Campaign, Experiment, Device, Configuration, Location, RunningExperiment, DEV_STATES
             from apps.cgs.models      import CGSConfiguration
             from apps.jars.models     import JARSConfiguration, EXPERIMENT_TYPE
             from apps.usrp.models     import USRPConfiguration
             from apps.abs.models      import ABSConfiguration, ABSBeam
             from apps.rc.models       import RCConfiguration, RCLine, RCLineType, RCClock
             from apps.dds.models      import DDSConfiguration
             from apps.dds_rest.models import DDSRestConfiguration
             from apps.atrad.models import ATRADConfiguration
             #from .tasks import task_start
             from radarsys.celery import app
             from .mqtt import client as mqtt_client
             from radarsys.socketconfig import sio as sio
             #comentario test
             CONF_FORMS = {
                 'rc': RCConfigurationForm,
                 'dds': DDSConfigurationForm,
                 'dds_rest': DDSRestConfigurationForm,
                 'jars': JARSConfigurationForm,
                 'cgs': CGSConfigurationForm,
                 'abs': ABSConfigurationForm,
                 'usrp': USRPConfigurationForm,
                 'atrad': ATRADConfigurationForm,
             }
             CONF_MODELS = {
                 'rc': RCConfiguration,
                 'dds': DDSConfiguration,
                 'dds_rest': DDSRestConfiguration,
                 'jars': JARSConfiguration,
                 'cgs': CGSConfiguration,
                 'abs': ABSConfiguration,
                 'usrp': USRPConfiguration,
                 'atrad': ATRADConfiguration,
             }
             MIX_MODES = {
                 '0': 'P',
                 '1': 'S',
             }
             MIX_OPERATIONS = {
                 '0': 'OR',
                 '1': 'XOR',
                 '2': 'AND',
                 '3': 'NAND',
             }
             def is_developer(user):
                 groups = [str(g.name) for g in user.groups.all()]
                 return 'Developer' in groups or user.is_staff
             def is_operator(user):
                 groups = [str(g.name) for g in user.groups.all()]
                 return 'Operator' in groups or user.is_staff
             def has_been_modified(model):
                 prev_hash = model.hash
                 new_hash = hashlib.sha256(str(model.parms_to_dict).encode()).hexdigest()
                 if prev_hash != new_hash:
                     model.hash = new_hash
                     model.save()
                     return True
                 return False
             def index(request):
                 kwargs = {'no_sidebar': True}
                 return render(request, 'index.html', kwargs)
             def locations(request):
                 page = request.GET.get('page')
                 order = ('name',)
                 kwargs = get_paginator(Location, page, order)
                 kwargs['keys'] = ['name', 'description']
                 kwargs['title'] = 'Radar System'
                 kwargs['suptitle'] = 'List'
                 kwargs['no_sidebar'] = True
                 return render(request, 'base_list.html', kwargs)
             def location(request, id_loc):
                 location = get_object_or_404(Location, pk=id_loc)
                 kwargs = {}
                 kwargs['location'] = location
                 kwargs['location_keys'] = ['name', 'description']
                 kwargs['title'] = 'Location'
                 kwargs['suptitle'] = 'Details'
                 return render(request, 'location.html', kwargs)
             @login_required
             def location_new(request):
                 if request.method == 'GET':
                     form = LocationForm()
                 if request.method == 'POST':
                     form = LocationForm(request.POST)
                     if form.is_valid():
                         form.save()
                         return redirect('url_locations')
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Radar System'
                 kwargs['suptitle'] = 'New'
                 kwargs['button'] = 'Create'
                 return render(request, 'base_edit.html', kwargs)
             @login_required
             def location_edit(request, id_loc):
                 location = get_object_or_404(Location, pk=id_loc)
                 if request.method == 'GET':
                     form = LocationForm(instance=location)
                 if request.method == 'POST':
                     form = LocationForm(request.POST, instance=location)
                     if form.is_valid():
                         form.save()
                         return redirect('url_locations')
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Location'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 return render(request, 'base_edit.html', kwargs)
             @login_required
             def location_delete(request, id_loc):
                 location = get_object_or_404(Location, pk=id_loc)
                 if request.method == 'POST':
                     if is_developer(request.user):
                         location.delete()
                         return redirect('url_locations')
                     messages.error(request, 'Not enough permission to delete this object')
                     return redirect(location.get_absolute_url())
                 kwargs = {
                     'title': 'Delete',
                     'suptitle': 'Location',
                     'object': location,
                     'delete': True
                 }
                 return render(request, 'confirm.html', kwargs)
             def devices(request):
                 page = request.GET.get('page')
                 order = ('location', 'device_type')
                 filters = request.GET.copy()
                 kwargs = get_paginator(Device, page, order, filters)
                 form = FilterForm(initial=request.GET, extra_fields=['tags'])
                 kwargs['keys'] = ['device_type', 'location',
                                   'ip_address', 'port_address', 'actions']
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'List'
                 kwargs['no_sidebar'] = True
                 kwargs['form'] = form
                 kwargs['add_url'] = reverse('url_add_device')
                 filters.pop('page', None)
                 kwargs['q'] = urlencode(filters)
                 kwargs['menu_devices'] = 'active'
                 return render(request, 'base_list.html', kwargs)
             def device(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 kwargs = {}
                 kwargs['device'] = device
                 kwargs['device_keys'] = ['device_type',
                                          'ip_address', 'port_address', 'description']
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'Details'
                 kwargs['menu_devices'] = 'active'
                 return render(request, 'device.html', kwargs)
             @login_required
             def device_new(request):
                 if request.method == 'GET':
                     form = DeviceForm()
                 if request.method == 'POST':
                     form = DeviceForm(request.POST)
                     if form.is_valid():
                         form.save()
                         return redirect('url_devices')
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'New_2'
                 kwargs['button'] = 'Create'
                 kwargs['menu_devices'] = 'active'
                 return render(request, 'base_edit.html', kwargs)
             @login_required
             def device_edit(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 if request.method == 'GET':
                     form = DeviceForm(instance=device)
                 if request.method == 'POST':
                     form = DeviceForm(request.POST, instance=device)
                     if form.is_valid():
                         form.save()
                         return redirect(device.get_absolute_url())
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 kwargs['menu_devices'] = 'active'
                 return render(request, 'base_edit.html', kwargs)
             @login_required
             def device_delete(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 if request.method == 'POST':
                     if is_developer(request.user):
                         device.delete()
                         return redirect('url_devices')
                     messages.error(request, 'Not enough permission to delete this object')
                     return redirect(device.get_absolute_url())
                 kwargs = {
                     'title': 'Delete',
                     'suptitle': 'Device',
                     'object': device,
                     'delete': True
                 }
                 kwargs['menu_devices'] = 'active'
                 return render(request, 'confirm.html', kwargs)
             @login_required
             def device_change_ip(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 if request.method == 'POST':
                     if is_developer(request.user):
                         device.change_ip(**request.POST.dict())
                         print(device.ip_address, device.message)
                         level, message = device.message.split('|')
                         messages.add_message(request, level, message)
                     else:
                         messages.error(
                             request, 'Not enough permission to delete this object')
                     return redirect(device.get_absolute_url())
                 kwargs = {
                     'title': 'Device',
                     'suptitle': 'Change IP',
                     'object': device,
                     'previous': device.get_absolute_url(),
                     'form': ChangeIpForm(initial={'ip_address': device.ip_address}),
                     'message': ' ',
                 }
                 kwargs['menu_devices'] = 'active'
                 return render(request, 'confirm.html', kwargs)
             def campaigns(request):
                 page = request.GET.get('page')
                 order = ('-start_date',)
                 filters = request.GET.copy()
                 kwargs = get_paginator(Campaign, page, order, filters)
                 form = FilterForm(initial=request.GET, extra_fields=[
                                   'range_date', 'tags', 'template'])
                 kwargs['keys'] = ['name', 'start_date', 'end_date', 'actions']
                 kwargs['title'] = 'Campaign'
                 kwargs['suptitle'] = 'List'
                 kwargs['no_sidebar'] = True
                 kwargs['form'] = form
                 kwargs['add_url'] = reverse('url_add_campaign')
                 filters.pop('page', None)
                 kwargs['q'] = urlencode(filters)
                 kwargs['menu_campaigns'] = 'active'
                 return render(request, 'base_list.html', kwargs)
             def campaign(request, id_camp):
                 campaign = get_object_or_404(Campaign, pk=id_camp)
                 experiments = Experiment.objects.filter(campaign=campaign)
                 form = CampaignForm(instance=campaign)
                 kwargs = {}
                 kwargs['campaign'] = campaign
                 kwargs['campaign_keys'] = ['template', 'name',
                                            'start_date', 'end_date', 'tags', 'description']
                 kwargs['experiments'] = experiments
                 kwargs['experiment_keys'] = [
                     'name', 'radar_system', 'start_time', 'end_time']
                 kwargs['title'] = 'Campaign'
                 kwargs['suptitle'] = 'Details'
                 kwargs['form'] = form
                 kwargs['button'] = 'Add Experiment'
                 kwargs['menu_campaigns'] = 'active'
                 return render(request, 'campaign.html', kwargs)
             @login_required
             def campaign_new(request):
                 kwargs = {}
                 if request.method == 'GET':
                     if 'template' in request.GET:
                         if request.GET['template'] == '0':
                             form = NewForm(initial={'create_from': 2},
                                            template_choices=Campaign.objects.filter(template=True).values_list('id', 'name'))
                         else:
                             kwargs['button'] = 'Create'
                             kwargs['experiments'] = Configuration.objects.filter(
                                 experiment=request.GET['template'])
                             kwargs['experiment_keys'] = ['name', 'start_time', 'end_time']
                             camp = Campaign.objects.get(pk=request.GET['template'])
                             form = CampaignForm(instance=camp,
                                                 initial={'name': '{}_{:%Y%m%d%H%M%S}'.format(camp.name, datetime.now()),
                                                          'template': False})
                     elif 'blank' in request.GET:
                         kwargs['button'] = 'Create'
                         form = CampaignForm()
                     else:
                         form = NewForm()
                 if request.method == 'POST':
                     kwargs['button'] = 'Create'
                     post = request.POST.copy()
                     experiments = []
                     for id_exp in post.getlist('experiments'):
                         exp = Experiment.objects.get(pk=id_exp)
                         new_exp = exp.clone(template=False)
                         experiments.append(new_exp)
                     post.setlist('experiments', [])
                     form = CampaignForm(post)
                     if form.is_valid():
                         campaign = form.save(commit=False)
                         campaign.author = request.user
                         campaign.save()
                         for exp in experiments:
                             campaign.experiments.add(exp)
                         return redirect('url_campaign', id_camp=campaign.id)
                 kwargs['form']           = form
                 kwargs['title']          = 'Campaign'
                 kwargs['suptitle']       = 'New'
                 kwargs['menu_campaigns'] = 'active'
                 return render(request, 'campaign_edit.html', kwargs)
             @login_required
             def campaign_edit(request, id_camp):
                 campaign = get_object_or_404(Campaign, pk=id_camp)
                 if request.method == 'GET':
                     form = CampaignForm(instance=campaign)
                 if request.method == 'POST':
                     exps     = campaign.experiments.all().values_list('pk', flat=True)
                     post     = request.POST.copy()
                     new_exps = post.getlist('experiments')
                     post.setlist('experiments', [])
                     form     = CampaignForm(post, instance=campaign)
                     if form.is_valid():
                         camp = form.save()
                         for id_exp in new_exps:
                             if int(id_exp) in exps:
                                 exps.pop(id_exp)
                             else:
                                 exp = Experiment.objects.get(pk=id_exp)
                                 if exp.template:
                                     camp.experiments.add(exp.clone(template=False))
                                 else:
                                     camp.experiments.add(exp)
                         for id_exp in exps:
                             camp.experiments.remove(Experiment.objects.get(pk=id_exp))
                         return redirect('url_campaign', id_camp=id_camp)
                 kwargs                   = {}
                 kwargs['form']           = form
                 kwargs['title']          = 'Campaign'
                 kwargs['suptitle']       = 'Edit'
                 kwargs['button']         = 'Update'
                 kwargs['menu_campaigns'] = 'active'
                 return render(request, 'campaign_edit.html', kwargs)
             @login_required
             def campaign_delete(request, id_camp):
                 campaign = get_object_or_404(Campaign, pk=id_camp)
                 if request.method == 'POST':
                     if is_developer(request.user):
                         for exp in campaign.experiments.all():
                             for conf in Configuration.objects.filter(experiment=exp):
                                 conf.delete()
                             exp.delete()
                         campaign.delete()
                         return redirect('url_campaigns')
                     messages.error(request, 'Not enough permission to delete this object')
                     return redirect(campaign.get_absolute_url())
                 kwargs = {
                     'title': 'Delete',
                     'suptitle': 'Campaign',
                     'object': campaign,
                     'delete': True
                 }
                 kwargs['menu_campaigns'] = 'active'
                 return render(request, 'confirm.html', kwargs)
             @login_required
             def campaign_export(request, id_camp):
                 campaign = get_object_or_404(Campaign, pk=id_camp)
                 content = campaign.parms_to_dict()
                 content_type = 'application/json'
                 filename = '%s_%s.json' % (campaign.name, campaign.id)
                 response = HttpResponse(content_type=content_type)
                 response['Content-Disposition'] = 'attachment; filename="%s"' % filename
                 response.write(json.dumps(content, indent=2))
                 return response
             @login_required
             def campaign_import(request, id_camp):
                 campaign = get_object_or_404(Campaign, pk=id_camp)
                 if request.method == 'GET':
                     file_form = UploadFileForm()
                 if request.method == 'POST':
                     file_form = UploadFileForm(request.POST, request.FILES)
                     if file_form.is_valid():
                         new_camp = campaign.dict_to_parms(
                             json.load(request.FILES['file']), CONF_MODELS)
                         messages.success(
                             request, "Parameters imported from: '%s'." % request.FILES['file'].name)
                         return redirect(new_camp.get_absolute_url_edit())
                     messages.error(request, "Could not import parameters from file")
                 kwargs = {}
                 kwargs['title'] = 'Campaign'
                 kwargs['form'] = file_form
                 kwargs['suptitle'] = 'Importing file'
                 kwargs['button'] = 'Import'
                 kwargs['menu_campaigns'] = 'active'
                 return render(request, 'campaign_import.html', kwargs)
             def experiments(request):
                 page = request.GET.get('page')
                 order = ('location',)
                 filters = request.GET.copy()
                 if 'my experiments' in filters:
                     filters.pop('my experiments', None)
                     filters['mine'] = request.user.id
                 kwargs = get_paginator(Experiment, page, order, filters)
                 fields = ['tags', 'template']
                 if request.user.is_authenticated:
                     fields.append('my experiments')
                 form = FilterForm(initial=request.GET, extra_fields=fields)
                 kwargs['keys'] = ['name', 'radar_system',
                                   'start_time', 'end_time', 'actions']
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'List'
                 kwargs['no_sidebar'] = True
                 kwargs['form'] = form
                 kwargs['add_url'] = reverse('url_add_experiment')
                 filters = request.GET.copy()
                 filters.pop('page', None)
                 kwargs['q'] = urlencode(filters)
                 kwargs['menu_experiments'] = 'active'
                 return render(request, 'base_list.html', kwargs)
             def experiment(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 configurations = Configuration.objects.filter(
                     experiment=experiment, type=0)
                 kwargs = {}
                 kwargs['experiment_keys'] = ['template', 'radar_system',
                                              'name', 'freq', 'start_time', 'end_time']
                 kwargs['experiment'] = experiment
                 kwargs['configuration_keys'] = ['name', 'device__ip_address',
                                                 'device__port_address', 'device__status']
                 kwargs['configurations'] = configurations
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Add Configuration'
                 kwargs['menu_experiments'] = 'active'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(experiment=experiment))
                 return render(request, 'experiment.html', kwargs)
             @login_required
             def experiment_new(request, id_camp=None):
                 if not is_developer(request.user):
                     messages.error(
                         request, 'Developer required, to create new Experiments')
                     return redirect('index')
                 kwargs = {}
                 if request.method == 'GET':
                     if 'template' in request.GET:
                         if request.GET['template'] == '0':
                             form = NewForm(initial={'create_from': 2},
                                            template_choices=Experiment.objects.filter(template=True).values_list('id', 'name'))
                         else:
                             kwargs['button'] = 'Create'
                             kwargs['configurations'] = Configuration.objects.filter(
                                 experiment=request.GET['template'])
                             kwargs['configuration_keys'] = ['name', 'device__name',
                                                             'device__ip_address', 'device__port_address']
                             exp = Experiment.objects.get(pk=request.GET['template'])
                             form = ExperimentForm(instance=exp,
                                                   initial={'name': '{}_{:%y%m%d}'.format(exp.name, datetime.now()),
                                                            'template': False})
                     elif 'blank' in request.GET:
                         kwargs['button'] = 'Create'
                         form = ExperimentForm()
                     else:
                         form = NewForm()
                 if request.method == 'POST':
                     form = ExperimentForm(request.POST)
                     if form.is_valid():
                         experiment = form.save(commit=False)
                         experiment.author = request.user
                         experiment.save()
                         if 'template' in request.GET:
                             configurations = Configuration.objects.filter(
                                 experiment=request.GET['template'], type=0)
                             for conf in configurations:
                                 conf.clone(experiment=experiment, template=False)
                         return redirect('url_experiment', id_exp=experiment.id)
                 kwargs['form'] = form
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'New'
                 kwargs['menu_experiments'] = 'active'
                 return render(request, 'experiment_edit.html', kwargs)
             @login_required
             def experiment_edit(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 if request.method == 'GET':
                     form = ExperimentForm(instance=experiment)
                 if request.method == 'POST':
                     form = ExperimentForm(request.POST, instance=experiment)
                     if form.is_valid():
                         experiment = form.save()
                         return redirect('url_experiment', id_exp=experiment.id)
                 kwargs                     = {}
                 kwargs['form']             = form
                 kwargs['title']            = 'Experiment'
                 kwargs['suptitle']         = 'Edit'
                 kwargs['button']           = 'Update'
                 kwargs['menu_experiments'] = 'active'
                 return render(request, 'experiment_edit.html', kwargs)
             @login_required
             def experiment_delete(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 if request.method == 'POST':
                     if is_developer(request.user):
                         for conf in Configuration.objects.filter(experiment=experiment):
                             conf.delete()
                         experiment.delete()
                         return redirect('url_experiments')
                     messages.error(request, 'Not enough permission to delete this object')
                     return redirect(experiment.get_absolute_url())
                 kwargs = {
                     'title': 'Delete',
                     'suptitle': 'Experiment',
                     'object': experiment,
                     'delete': True
                 }
                 return render(request, 'confirm.html', kwargs)
             @login_required
             def experiment_export(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 content = experiment.parms_to_dict()
                 content_type = 'application/json'
                 filename = '%s_%s.json' % (experiment.name, experiment.id)
                 response = HttpResponse(content_type=content_type)
                 response['Content-Disposition'] = 'attachment; filename="%s"' % filename
                 response.write(json.dumps(content, indent=2))
                 return response
             @login_required
             def experiment_import(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 configurations = Configuration.objects.filter(experiment=experiment)
                 if request.method == 'GET':
                     file_form = UploadFileForm()
                 if request.method == 'POST':
                     file_form = UploadFileForm(request.POST, request.FILES)
                     if file_form.is_valid():
                         new_exp = experiment.dict_to_parms(
                             json.load(request.FILES['file']), CONF_MODELS)
                         messages.success(
                             request, "Parameters imported from: '%s'." % request.FILES['file'].name)
                         return redirect(new_exp.get_absolute_url_edit())
                     messages.error(request, "Could not import parameters from file")
                 kwargs = {}
                 kwargs['title'] = 'Experiment'
                 kwargs['form'] = file_form
                 kwargs['suptitle'] = 'Importing file'
                 kwargs['button'] = 'Import'
                 kwargs['menu_experiments'] = 'active'
                 kwargs.update(sidebar(experiment=experiment))
                 return render(request, 'experiment_import.html', kwargs)
             @login_required
             def experiment_start(request, id_exp):
                 exp = get_object_or_404(Experiment, pk=id_exp)
                 if exp.status == 2:
                     messages.warning(request, 'Experiment {} already runnnig'.format(exp))
                 else:
                     exp.status = exp.start()
                     if exp.status == 0:
                         messages.error(request, 'Experiment {} not start'.format(exp))
                     if exp.status == 2:
                         messages.success(request, 'Experiment {} started'.format(exp))
                     exp.save()
                 return redirect(exp.get_absolute_url())
             @login_required
             def experiment_stop(request, id_exp):
                 exp = get_object_or_404(Experiment, pk=id_exp)
                 if exp.status == 2:
                     exp.status = exp.stop()
                     exp.save()
                     messages.success(request, 'Experiment {} stopped'.format(exp))
                 else:
                     messages.error(request, 'Experiment {} not running'.format(exp))
                 return redirect(exp.get_absolute_url())
             def experiment_status(request, id_exp):
                 exp = get_object_or_404(Experiment, pk=id_exp)
                 exp.get_status()
                 return redirect(exp.get_absolute_url())
             @login_required
             def experiment_mix(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 rc_confs = [conf for conf in RCConfiguration.objects.filter(
                     experiment=id_exp,
                     type=0,
                     mix=False)]
                 if len(rc_confs) < 2:
                     messages.warning(
                         request, 'You need at least two RC Configurations to make a mix')
                     return redirect(experiment.get_absolute_url())
                 mix_confs = RCConfiguration.objects.filter(experiment=id_exp, mix=True, type=0)
                 if mix_confs:
                     mix = mix_confs[0]
                 else:
                     mix = RCConfiguration(experiment=experiment,
                                           device=rc_confs[0].device,
                                           ipp=rc_confs[0].ipp,
                                           clock_in=rc_confs[0].clock_in,
                                           clock_divider=rc_confs[0].clock_divider,
                                           mix=True,
                                           parameters='')
                     mix.save()
                     line_type = RCLineType.objects.get(name='mix')
                     print("VIew obteniendo len getlines")
                     print(len(rc_confs[0].get_lines()))
                     for i in range(len(rc_confs[0].get_lines())):
                         line = RCLine(rc_configuration=mix, line_type=line_type, channel=i)
                         line.save()
                 initial = {'name': mix.name,
                            'result': parse_mix_result(mix.parameters),
                            'delay': 0,
                            'mask': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
                            }
                 if request.method == 'GET':
                     form = RCMixConfigurationForm(confs=rc_confs, initial=initial)
                 if request.method == 'POST':
                     result = mix.parameters
                     if '{}|'.format(request.POST['experiment']) in result:
                         messages.error(request, 'Configuration already added')
                     else:
                         if 'operation' in request.POST:
                             operation = MIX_OPERATIONS[request.POST['operation']]
                         else:
                             operation = '   '
                         mode = MIX_MODES[request.POST['mode']]
                         if result:
                             result = '{}-{}|{}|{}|{}|{}'.format(mix.parameters,
                                                                 request.POST['experiment'],
                                                                 mode,
                                                                 operation,
                                                                 float(
                                                                     request.POST['delay']),
                                                                 parse_mask(
                                                                     request.POST.getlist('mask'))
                                                                 )
                         else:
                             result = '{}|{}|{}|{}|{}'.format(request.POST['experiment'],
                                                              mode,
                                                              operation,
                                                              float(request.POST['delay']),
                                                              parse_mask(
                                                                  request.POST.getlist('mask'))
                                                              )
                         mix.parameters = result
                         mix.save()
                         mix.update_pulses()
                     initial['result'] = parse_mix_result(result)
                     initial['name'] = mix.name
                     form = RCMixConfigurationForm(initial=initial, confs=rc_confs)
                 kwargs = {
                     'title': 'Experiment',
                     'suptitle': 'Mix Configurations',
                     'form': form,
                     'extra_button': 'Delete',
                     'button': 'Add',
                     'cancel': 'Back',
                     'previous': experiment.get_absolute_url(),
                     'id_exp': id_exp,
                 }
                 kwargs['menu_experiments'] = 'active'
                 return render(request, 'experiment_mix.html', kwargs)
             @login_required
             def experiment_mix_delete(request, id_exp):
                 conf = RCConfiguration.objects.get(experiment=id_exp, mix=True, type=0)
                 values = conf.parameters.split('-')
                 conf.parameters = '-'.join(values[:-1])
                 conf.save()
                 return redirect('url_mix_experiment', id_exp=id_exp)
             def experiment_summary(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 configurations = Configuration.objects.filter(
                     experiment=experiment, type=0)
                 kwargs = {}
                 kwargs['experiment_keys'] = ['radar_system',
                                              'name', 'freq', 'start_time', 'end_time']
                 kwargs['experiment'] = experiment
                 kwargs['configurations'] = []
                 kwargs['title'] = 'Experiment Summary'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Verify Parameters'
                 c_vel = 3.0*(10**8)  # m/s
                 ope_freq = experiment.freq*(10**6)  # 1/s
                 radar_lambda = c_vel/ope_freq  # m
                 kwargs['radar_lambda'] = radar_lambda
                 ipp = None
                 nsa = 1
                 code_id = 0
                 tx_line = {}
                 for configuration in configurations.filter(device__device_type__name = 'rc'):
                     if configuration.mix:
                         continue
                     conf = {'conf': configuration}
                     conf['keys'] = []
                     conf['NTxs'] = configuration.ntx
                     conf['keys'].append('NTxs')
                     ipp = configuration.ipp
                     conf['IPP'] = ipp
                     conf['keys'].append('IPP')
                     lines = configuration.get_lines(line_type__name='tx')
                     for tx_line in lines:
                         tx_params = json.loads(tx_line.params)
                         conf[tx_line.get_name()] = '{} Km'.format(tx_params['pulse_width'])
                         conf['keys'].append(tx_line.get_name())
                         delays = tx_params['delays']
                         if delays not in ('', '0'):
                             n = len(delays.split(','))
                             taus = '{} Taus: {}'.format(n, delays)
                         else:
                             taus = '-'
                         conf['Taus ({})'.format(tx_line.get_name())] = taus
                         conf['keys'].append('Taus ({})'.format(tx_line.get_name()))
                         for code_line in configuration.get_lines(line_type__name='codes'):
                             code_params = json.loads(code_line.params)
                             code_id = code_params['code']
                             if tx_line.pk == int(code_params['TX_ref']):
                                 conf['Code ({})'.format(tx_line.get_name())] = '{}:{}'.format(RCLineCode.objects.get(pk=code_params['code']),
                                                                 '-'.join(code_params['codes']))
                                 conf['keys'].append('Code ({})'.format(tx_line.get_name()))
                         for windows_line in configuration.get_lines(line_type__name='windows'):
                             win_params = json.loads(windows_line.params)
                             if tx_line.pk == int(win_params['TX_ref']):
                                 windows = ''
                                 nsa = win_params['params'][0]['number_of_samples']
                                 for i, params in enumerate(win_params['params']):
                                     windows += 'W{}: Ho={first_height} km DH={resolution} km NSA={number_of_samples}<br>'.format(
                                         i, **params)
                                 conf['Window'] = mark_safe(windows)
                                 conf['keys'].append('Window')
                     kwargs['configurations'].append(conf)
                 for configuration in configurations.filter(device__device_type__name = 'jars'):
                     conf = {'conf': configuration}
                     conf['keys'] = []
                     conf['Type of Data'] = EXPERIMENT_TYPE[configuration.exp_type][1]
                     conf['keys'].append('Type of Data')
                     channels_number = configuration.channels_number
                     exp_type = configuration.exp_type
                     fftpoints = configuration.fftpoints
                     filter_parms = json.loads(configuration.filter_parms)
                     spectral_number = configuration.spectral_number
                     acq_profiles = configuration.acq_profiles
                     cohe_integr = configuration.cohe_integr
                     profiles_block = configuration.profiles_block
                     conf['Num of Profiles'] = acq_profiles
                     conf['keys'].append('Num of Profiles')
                     conf['Prof per Block'] = profiles_block
                     conf['keys'].append('Prof per Block')
                     conf['Blocks per File'] = configuration.raw_data_blocks
                     conf['keys'].append('Blocks per File')
                     if exp_type == 0:  # Short
                         bytes_ = 2
                         b = nsa*2*bytes_*channels_number
                     else:  # Float
                         bytes_ = 4
                         channels = channels_number + spectral_number
                         b = nsa*2*bytes_*fftpoints*channels
                     codes_num = 7
                     if code_id == 2:
                         codes_num = 7
                     elif code_id == 12:
                         codes_num = 15
                     #Jars filter values:
                     clock = float(filter_parms['clock'])
                     filter_2 = int(filter_parms['cic_2'])
                     filter_5 = int(filter_parms['cic_5'])
                     filter_fir = int(filter_parms['fir'])
                     Fs_MHz = clock/(filter_2*filter_5*filter_fir)
                     #Jars values:
                     if ipp is not None:
                         IPP_units = ipp/0.15*Fs_MHz
                         IPP_us = IPP_units / Fs_MHz
                         IPP_s = IPP_units / (Fs_MHz * (10**6))
                         Ts = 1/(Fs_MHz*(10**6))
                         Va = radar_lambda/(4*Ts*cohe_integr)
                         rate_bh = ((nsa-codes_num)*channels_number*2 *
                                     bytes_/IPP_us)*(36*(10**8)/cohe_integr)
                         rate_gh = rate_bh/(1024*1024*1024)
                         conf['Time per Block'] = IPP_s * profiles_block * cohe_integr
                         conf['keys'].append('Time per Block')
                         conf['Acq time'] = IPP_s * acq_profiles
                         conf['keys'].append('Acq time')
                         conf['Data rate'] = str(rate_gh)+" (GB/h)"
                         conf['keys'].append('Data rate')
                         conf['Va (m/s)'] = Va
                         conf['keys'].append('Va (m/s)')
                         conf['Vrange (m/s)'] = 3/(2*IPP_s*cohe_integr)
                         conf['keys'].append('Vrange (m/s)')
                     kwargs['configurations'].append(conf)
                 kwargs['menu_experiments'] = 'active'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(experiment=experiment))
                 return render(request, 'experiment_summary.html', kwargs)
             @login_required
             def experiment_verify(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 experiment_data = experiment.parms_to_dict()
                 configurations = Configuration.objects.filter(
                     experiment=experiment, type=0)
                 kwargs = {}
                 kwargs['experiment_keys'] = ['template',
                                              'radar_system', 'name', 'start_time', 'end_time']
                 kwargs['experiment'] = experiment
                 kwargs['configuration_keys'] = ['name', 'device__ip_address',
                                                 'device__port_address', 'device__status']
                 kwargs['configurations'] = configurations
                 kwargs['experiment_data'] = experiment_data
                 kwargs['title'] = 'Verify Experiment'
                 kwargs['suptitle'] = 'Parameters'
                 kwargs['button'] = 'Update'
                 jars_conf = False
                 rc_conf = False
                 dds_conf = False
                 for configuration in configurations:
                     #-------------------- JARS -----------------------:
                     if configuration.device.device_type.name == 'jars':
                         jars_conf = True
                         jars = configuration
                         kwargs['jars_conf'] = jars_conf
                         filter_parms = json.loads(jars.filter_parms)
                         kwargs['filter_parms'] = filter_parms
                         #--Sampling Frequency
                         clock = filter_parms['clock']
                         filter_2 = filter_parms['cic_2']
                         filter_5 = filter_parms['cic_5']
                         filter_fir = filter_parms['fir']
                         samp_freq_jars = clock/filter_2/filter_5/filter_fir
                         kwargs['samp_freq_jars'] = samp_freq_jars
                         kwargs['jars'] = configuration
                     #--------------------- RC ----------------------:
                     if configuration.device.device_type.name == 'rc' and not configuration.mix:
                         rc_conf = True
                         rc = configuration
                         rc_parms = configuration.parms_to_dict()
                         win_lines = rc.get_lines(line_type__name='windows')
                         if win_lines:
                             dh = json.loads(win_lines[0].params)['params'][0]['resolution']
                             #--Sampling Frequency
                             samp_freq_rc = 0.15/dh
                             kwargs['samp_freq_rc'] = samp_freq_rc
                             kwargs['rc_conf'] = rc_conf
                             kwargs['rc'] = configuration
                     #-------------------- DDS ----------------------:
                     if configuration.device.device_type.name == 'dds':
                         dds_conf = True
                         dds = configuration
                         dds_parms = configuration.parms_to_dict()
                         kwargs['dds_conf'] = dds_conf
                         kwargs['dds'] = configuration
                 #------------Validation------------:
                 #Clock
                 if dds_conf and rc_conf and jars_conf:
                     if float(filter_parms['clock']) != float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) and float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) != float(dds_parms['configurations']['byId'][str(dds.pk)]['clock']):
                         messages.warning(request, "Devices don't have the same clock.")
                 elif rc_conf and jars_conf:
                     if float(filter_parms['clock']) != float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']):
                         messages.warning(request, "Devices don't have the same clock.")
                 elif rc_conf and dds_conf:
                     if float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) != float(dds_parms['configurations']['byId'][str(dds.pk)]['clock']):
                         messages.warning(request, "Devices don't have the same clock.")
                     if float(samp_freq_rc) != float(dds_parms['configurations']['byId'][str(dds.pk)]['frequencyA']):
                         messages.warning(
                             request, "Devices don't have the same Frequency A.")
                 #------------POST METHOD------------:
                 if request.method == 'POST':
                     if request.POST['suggest_clock']:
                         try:
                             suggest_clock = float(request.POST['suggest_clock'])
                         except:
                             messages.warning(request, "Invalid value in CLOCK IN.")
                             return redirect('url_verify_experiment', id_exp=experiment.id)
                     else:
                         suggest_clock = ""
                     if suggest_clock:
                         if rc_conf:
                             rc.clock_in = suggest_clock
                             rc.save()
                         if jars_conf:
                             filter_parms = jars.filter_parms
                             filter_parms = ast.literal_eval(filter_parms)
                             filter_parms['clock'] = suggest_clock
                             jars.filter_parms = json.dumps(filter_parms)
                             jars.save()
                             kwargs['filter_parms'] = filter_parms
                         if dds_conf:
                             dds.clock = suggest_clock
                             dds.save()
                     if request.POST['suggest_frequencyA']:
                         try:
                             suggest_frequencyA = float(request.POST['suggest_frequencyA'])
                         except:
                             messages.warning(request, "Invalid value in FREQUENCY A.")
                             return redirect('url_verify_experiment', id_exp=experiment.id)
                     else:
                         suggest_frequencyA = ""
                     if suggest_frequencyA:
                         if jars_conf:
                             filter_parms = jars.filter_parms
                             filter_parms = ast.literal_eval(filter_parms)
                             filter_parms['fch'] = suggest_frequencyA
                             jars.filter_parms = json.dumps(filter_parms)
                             jars.save()
                             kwargs['filter_parms'] = filter_parms
                         if dds_conf:
                             dds.frequencyA_Mhz = request.POST['suggest_frequencyA']
                             dds.save()
                 kwargs['menu_experiments'] = 'active'
                 kwargs.update(sidebar(experiment=experiment))
                 return render(request, 'experiment_verify.html', kwargs)
             def parse_mix_result(s):
                 values = s.split('-')
                 html = 'EXP                MOD OPE DELAY         MASK\r\n'
                 if not values or values[0] in ('', ' '):
                     return mark_safe(html)
                 for i, value in enumerate(values):
                     if not value:
                         continue
                     pk, mode, operation, delay, mask = value.split('|')
                     conf = RCConfiguration.objects.get(pk=pk)
                     if i == 0:
                         html += '{:20.18}{:3}{:4}{:9}km{:>6}\r\n'.format(
                             conf.name,
                             mode,
                             '   ',
                             delay,
                             mask)
                     else:
                         html += '{:20.18}{:3}{:4}{:9}km{:>6}\r\n'.format(
                             conf.name,
                             mode,
                             operation,
                             delay,
                             mask)
                 return mark_safe(html)
             def parse_mask(l):
                 values = []
                 for x in range(16):
                     if '{}'.format(x) in l:
                         values.append(1)
                     else:
                         values.append(0)
                 values.reverse()
                 return int(''.join([str(x) for x in values]), 2)
             def dev_confs(request):
                 page = request.GET.get('page')
                 order = ('-programmed_date', )
                 filters = request.GET.copy()
                 if 'my configurations' in filters:
                     filters.pop('my configurations', None)
                     filters['mine'] = request.user.id
                 kwargs = get_paginator(Configuration, page, order, filters)
                 fields = ['tags', 'template', 'historical']
                 if request.user.is_authenticated:
                     fields.append('my configurations')
                 form = FilterForm(initial=request.GET, extra_fields=fields)
                 kwargs['keys'] = ['name', 'experiment',
                                   'type', 'programmed_date', 'actions']
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'List'
                 kwargs['no_sidebar'] = True
                 kwargs['form'] = form
                 kwargs['add_url'] = reverse('url_add_dev_conf', args=[0])
                 filters = request.GET.copy()
                 filters.pop('page', None)
                 kwargs['q'] = urlencode(filters)
                 kwargs['menu_configurations'] = 'active'
                 return render(request, 'base_list.html', kwargs)
             def dev_conf(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 return redirect(conf.get_absolute_url())
             @login_required
             def dev_conf_new(request, id_exp=0, id_dev=0):
                 if not is_developer(request.user):
                     messages.error(
                         request, 'Developer required, to create new configurations')
                     return redirect('index')
                 initial = {}
                 kwargs = {}
                 if id_exp != 0:
                     initial['experiment'] = id_exp
                 if id_dev != 0:
                     initial['device'] = id_dev
                 if request.method == 'GET':
                     if id_dev:
                         kwargs['button'] = 'Create'
                         device = Device.objects.get(pk=id_dev)
                         DevConfForm = CONF_FORMS[device.device_type.name]
                         initial['name'] = request.GET['name']
                         form = DevConfForm(initial=initial)
                     else:
                         if 'template' in request.GET:
                             if request.GET['template'] == '0':
                                 choices = [(conf.pk, '{}'.format(conf))
                                            for conf in Configuration.objects.filter(template=True)]
                                 form = NewForm(initial={'create_from': 2},
                                                template_choices=choices)
                             else:
                                 kwargs['button'] = 'Create'
                                 conf = Configuration.objects.get(
                                     pk=request.GET['template'])
                                 id_dev = conf.device.pk
                                 DevConfForm = CONF_FORMS[conf.device.device_type.name]
                                 form = DevConfForm(instance=conf,
                                                    initial={'name': '{}_{:%y%m%d}'.format(conf.name, datetime.now()),
                                                             'template': False,
                                                             'experiment': id_exp})
                         elif 'blank' in request.GET:
                             kwargs['button'] = 'Create'
                             form = ConfigurationForm(initial=initial)
                         else:
                             form = NewForm()
                 if request.method == 'POST':
                     device = Device.objects.get(pk=request.POST['device'])
                     DevConfForm = CONF_FORMS[device.device_type.name]
                     form = DevConfForm(request.POST)
                     kwargs['button'] = 'Create'
                     if form.is_valid():
                         conf = form.save(commit=False)
                         conf.author = request.user
                         conf.save()
                         if 'template' in request.GET and conf.device.device_type.name == 'rc':
                             lines = RCLine.objects.filter(
                                 rc_configuration=request.GET['template'])
                             for line in lines:
                                 line.clone(rc_configuration=conf)
                             new_lines = conf.get_lines()
                             for line in new_lines:
                                 line_params = json.loads(line.params)
                                 if 'TX_ref' in line_params:
                                     ref_line = RCLine.objects.get(pk=line_params['TX_ref'])
                                     line_params['TX_ref'] = ['{}'.format(
                                         l.pk) for l in new_lines if l.get_name() == ref_line.get_name()][0]
                                     line.params = json.dumps(line_params)
                                     line.save()
                         elif conf.device.device_type.name == 'rc':
                             clk = RCClock(rc_configuration=conf)
                             clk.save()
                         return redirect('url_dev_conf', id_conf=conf.pk)
                 kwargs['id_exp'] = id_exp
                 kwargs['form'] = form
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'New'
                 kwargs['menu_configurations'] = 'active'
                 if id_dev != 0:
                     device = Device.objects.get(pk=id_dev)
                     kwargs['device'] = device.device_type.name
                 print(id_exp)
                 return render(request, 'dev_conf_edit.html', kwargs)
             @login_required
             def dev_conf_edit(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfForm = CONF_FORMS[conf.device.device_type.name]
                 if request.method == 'GET':
                     form = DevConfForm(instance=conf)
                 if request.method == 'POST':
                     form = DevConfForm(request.POST, instance=conf)
                     if form.is_valid():
                         form.save()
                         return redirect('url_dev_conf', id_conf=id_conf)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 kwargs['menu_configurations'] = 'active'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
             @login_required
             def dev_conf_start(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if conf.start_device():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 #conf.status_device()
                 return redirect(conf.get_absolute_url())
             @login_required
             def dev_conf_stop(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if conf.stop_device():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 #conf.status_device()
                 return redirect(conf.get_absolute_url())
             @login_required
             def dev_conf_stop_mqtt(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if conf.stop_device_mqtt():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 #conf.status_device()
                 return redirect(conf.get_absolute_url())
             @login_required
             def dev_conf_status(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 conf_active = Configuration.objects.filter(pk=conf.device.conf_active).first()
                 if conf_active!=conf:
                     url = '#' if conf_active is None else conf_active.get_absolute_url()
                     label = 'None' if conf_active is None else conf_active.label
                     messages.warning(
                         request,
                         mark_safe('The current configuration has not been written to device, the active configuration is <a href="{}">{}</a>'.format(
                             url,
                             label
                             ))
                         )
                     return redirect(conf.get_absolute_url())
                 if conf.status_device():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 return redirect(conf.get_absolute_url())
             @login_required
             def dev_conf_reset(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if conf.reset_device():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 return redirect(conf.get_absolute_url())
             @login_required
             def dev_conf_write(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if request.method == 'POST':
                     if conf.write_device():
                         conf.device.conf_active = conf.pk
                         conf.device.save()
                         messages.success(request, conf.message)
                         if has_been_modified(conf):
                             conf.clone(type=1, template=False)
                     else:
                         messages.error(request, conf.message)
                     return redirect(get_object_or_404(Configuration, pk=id_conf).get_absolute_url())
                 kwargs = {
                     'title': 'Write Configuration',
                     'suptitle': conf.label,
                     'message': 'Are you sure yo want to write this {} configuration?'.format(conf.device),
                     'delete': False
                 }
                 kwargs['menu_configurations'] = 'active'
                 return render(request, 'confirm.html', kwargs)
             @login_required
             def dev_conf_write_mqtt(request,id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 beams = ABSBeam.objects.filter(abs_conf=conf)
                 if request.method == 'POST':
                     if conf.write_device_mqtt():
                         conf.device.conf_active = conf.pk
                         conf.device.save()
                         messages.success(request, conf.message)
                         if has_been_modified(conf):
                             conf.clone(type=1, template=False)
                     else:
                         messages.error(request, conf.message)
                     print("return",flush=True)
                     #return redirect(get_object_or_404(Configuration, pk=id_conf).get_absolute_url())
                     module_messages = json.loads(conf.module_messages)
                     kwargs = {}
                     kwargs['connected_modules'] = str(conf.connected_modules())+'/64'
                     kwargs['dev_conf'] = conf
                     if conf.operation_mode == 0:
                         kwargs['dev_conf_keys'] = ['label', 'operation_mode']
                     else:
                         kwargs['dev_conf_keys'] = ['label', 'operation_mode', 'operation_value']
                     kwargs['title'] = 'ABS Configuration'
                     kwargs['suptitle'] = 'Details'
                     kwargs['button'] = 'Edit Configuration'
                     if conf.active_beam != 0:
                         kwargs['active_beam'] = int(conf.active_beam)
                     kwargs['beams'] = beams
                     # kwargs['modules_status'] = all_status
                     # kwargs['color_status']   = color_status
                     kwargs['module_messages'] = module_messages
                     ###### SIDEBAR ######
                     kwargs.update(sidebar(conf=conf))
                     return render(request, 'abs_conf_mqtt.html',kwargs)
                 kwargs = {
                     'title': 'MQTT Write Configuration',
                     'suptitle': conf.label,
                     'message': 'Are you sure yo want to write through MQTT this {} configuration?'.format(conf.device),
                     'delete': False
                 }
                 kwargs['menu_configurations'] = 'active'
                 print("Confirm",flush=True)
                 return render(request, 'confirm.html', kwargs)
             @login_required
             def dev_conf_read(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfForm = CONF_FORMS[conf.device.device_type.name]
                 if request.method == 'GET':
                     parms = conf.read_device()
                     #conf.status_device()
                     if not parms:
                         messages.error(request, conf.message)
                         return redirect(conf.get_absolute_url())
                     form = DevConfForm(initial=parms, instance=conf)
                 if request.method == 'POST':
                     form = DevConfForm(request.POST, instance=conf)
                     if form.is_valid():
                         form.save()
                         return redirect(conf.get_absolute_url())
                     messages.error(request, "Parameters could not be saved")
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['form'] = form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Parameters read from device'
                 kwargs['button'] = 'Save'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
             @login_required
             def dev_conf_import(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfForm = CONF_FORMS[conf.device.device_type.name]
                 if request.method == 'GET':
                     file_form = UploadFileForm()
                 if request.method == 'POST':
                     file_form = UploadFileForm(request.POST, request.FILES)
                     if file_form.is_valid():
                         data = conf.import_from_file(request.FILES['file'])
                         parms = Params(data=data).get_conf(
                             dtype=conf.device.device_type.name)
                         if parms:
                             form = DevConfForm(initial=parms, instance=conf)
                             kwargs = {}
                             kwargs['id_dev'] = conf.id
                             kwargs['form'] = form
                             kwargs['title'] = 'Device Configuration'
                             kwargs['suptitle'] = 'Parameters imported'
                             kwargs['button'] = 'Save'
                             kwargs['action'] = conf.get_absolute_url_edit()
                             kwargs['previous'] = conf.get_absolute_url()
                             ###### SIDEBAR ######
                             kwargs.update(sidebar(conf=conf))
                             messages.success(
                                 request, "Parameters imported from: '%s'." % request.FILES['file'].name)
                             return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
                     messages.error(request, "Could not import parameters from file")
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['title'] = 'Device Configuration'
                 kwargs['form'] = file_form
                 kwargs['suptitle'] = 'Importing file'
                 kwargs['button'] = 'Import'
                 kwargs['menu_configurations'] = 'active'
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'dev_conf_import.html', kwargs)
             @login_required
             def dev_conf_export(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if request.method == 'GET':
                     file_form = DownloadFileForm(conf.device.device_type.name)
                 if request.method == 'POST':
                     file_form = DownloadFileForm(
                         conf.device.device_type.name, request.POST)
                     if file_form.is_valid():
                         fields = conf.export_to_file(
                             format=file_form.cleaned_data['format'])
                         if not fields['content']:
                             messages.error(request, conf.message)
                             return redirect(conf.get_absolute_url_export())
                         response = HttpResponse(content_type=fields['content_type'])
                         response['Content-Disposition'] = 'attachment; filename="%s"' % fields['filename']
                         response.write(fields['content'])
                         return response
                     messages.error(request, "Could not export parameters")
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['title'] = 'Device Configuration'
                 kwargs['form'] = file_form
                 kwargs['suptitle'] = 'Exporting file'
                 kwargs['button'] = 'Export'
                 kwargs['menu_configurations'] = 'active'
                 return render(request, 'dev_conf_export.html', kwargs)
             @login_required
             def dev_conf_delete(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if request.method == 'POST':
                     if is_developer(request.user):
                         conf.delete()
                         return redirect('url_dev_confs')
                     messages.error(request, 'Not enough permission to delete this object')
                     return redirect(conf.get_absolute_url())
                 kwargs = {
                     'title': 'Delete',
                     'suptitle': 'Configuration',
                     'object': conf,
                     'delete': True
                 }
                 kwargs['menu_configurations'] = 'active'
                 return render(request, 'confirm.html', kwargs)
             def sidebar(**kwargs):
                 side_data = {}
                 conf = kwargs.get('conf', None)
                 experiment = kwargs.get('experiment', None)
                 if not experiment:
                     experiment = conf.experiment
                 if experiment:
                     side_data['experiment'] = experiment
                     campaign = experiment.campaign_set.all()
                     if campaign:
                         side_data['campaign'] = campaign[0]
                         experiments = campaign[0].experiments.all().order_by('name')
                     else:
                         experiments = [experiment]
                     configurations = experiment.configuration_set.filter(type=0)
                     side_data['side_experiments'] = experiments
                     side_data['side_configurations'] = configurations.order_by(
                         'device__device_type__name')
                 return side_data
             def get_paginator(model, page, order, filters={}, n=8):
                 kwargs = {}
                 query = Q()
                 if isinstance(filters, QueryDict):
                     filters = filters.dict()
                 copy_filters=filters.copy()
                 [filters.pop(key) for key in copy_filters.keys() if copy_filters[key] in ('    ', ' ')]
                 filters.pop('page', None)
                 fields = [f.name for f in model._meta.get_fields()]
                 if 'template' in copy_filters:
                     filters['template'] = True
                 if 'historical' in copy_filters:
                     filters.pop('historical')
                     filters['type'] = 1
                 elif 'type' in fields:
                    filters['type'] = 0
                 if 'start_date' in copy_filters:
                    filters['start_date__gte'] =filters.pop('start_date')
                 if 'end_date' in copy_filters:
                    filters['start_date__lte'] =filters.pop('end_date')
                 if 'tags' in copy_filters:
                     tags =filters.pop('tags')
                     if 'tags' in fields:
                         query = query | Q(tags__icontains=tags)
                     if 'label' in fields:
                         query = query | Q(label__icontains=tags)
                     if 'location' in fields:
                         query = query | Q(location__name__icontains=tags)
                     if 'device' in fields:
                         query = query | Q(device__device_type__name__icontains=tags)
                         query = query | Q(device__location__name__icontains=tags)
                     if 'device_type' in fields:
                         query = query | Q(device_type__name__icontains=tags)
                 if 'mine' in copy_filters:
                    filters['author_id'] =filters['mine']
                    filters.pop('mine')
                 object_list = model.objects.filter(query, **filters).order_by(*order)
                 paginator = Paginator(object_list, n)
                 try:
                     objects = paginator.page(page)
                 except PageNotAnInteger:
                     objects = paginator.page(1)
                 except EmptyPage:
                     objects = paginator.page(paginator.num_pages)
                 kwargs['objects'] = objects
                 kwargs['offset'] = (int(page)-1)*n if page else 0
                 return kwargs
             # def get_paginator(model, page, order, filters={}, n=8):
             #     kwargs = {}
             #     query = Q()
             #     if isinstance(filters, QueryDict):
             #         filters = filters.dict()
             #     [filters.pop(key) for key in filters.keys() if filters[key] in ('', ' ')]
             #     filters.pop('page', None)
             #     fields = [f.name for f in model._meta.get_fields()]
             #     if 'template' in filters:
             #         filters['template'] = True
             #     if 'historical' in filters:
             #         filters.pop('historical')
             #         filters['type'] = 1
             #     elif 'type' in fields:
             #         filters['type'] = 0
             #     if 'start_date' in filters:
             #         filters['start_date__gte'] = filters.pop('start_date')
             #     if 'end_date' in filters:
             #         filters['start_date__lte'] = filters.pop('end_date')
             #     if 'tags' in filters:
             #         tags = filters.pop('tags')
             #         if 'tags' in fields:
             #             query = query | Q(tags__icontains=tags)
             #         if 'label' in fields:
             #             query = query | Q(label__icontains=tags)
             #         if 'location' in fields:
             #             query = query | Q(location__name__icontains=tags)
             #         if 'device' in fields:
             #             query = query | Q(device__device_type__name__icontains=tags)
             #             query = query | Q(device__location__name__icontains=tags)
             #         if 'device_type' in fields:
             #             query = query | Q(device_type__name__icontains=tags)
             #     if 'mine' in filters:
             #         filters['author_id'] = filters['mine']
             #         filters.pop('mine')
             #     object_list = model.objects.filter(query, **filters).order_by(*order)
             #     paginator = Paginator(object_list, n)
             #     try:
             #         objects = paginator.page(page)
             #     except PageNotAnInteger:
             #         objects = paginator.page(1)
             #     except EmptyPage:
             #         objects = paginator.page(paginator.num_pages)
             #     kwargs['objects'] = objects
             #     kwargs['offset'] = (int(page)-1)*n if page else 0
             #     return kwargs
             def operation(request, id_camp=None):
                 kwargs = {}
                 kwargs['title'] = 'Radars Operation'
                 kwargs['no_sidebar'] = True
                 kwargs['menu_operation'] = 'active'
                 campaigns = Campaign.objects.filter(start_date__lte=datetime.now(),
                                                     end_date__gte=datetime.now()).order_by('-start_date')
                 if id_camp:
                     campaign = get_object_or_404(Campaign, pk=id_camp)
                     form = OperationForm(
                         initial={'campaign': campaign.id}, campaigns=campaigns)
                     kwargs['campaign'] = campaign
                 else:
                     # form = OperationForm(campaigns=campaigns)
                     kwargs['campaigns'] = campaigns
                     return render(request, 'operation.html', kwargs)
                 #---Experiment
                 keys = ['id', 'name', 'start_time', 'end_time', 'status']
                 kwargs['experiment_keys'] = keys[1:]
                 kwargs['experiments'] = experiments
                 #---Radar
                 kwargs['locations'] = campaign.get_experiments_by_radar()
                 kwargs['form'] = form
                 return render(request, 'operation.html', kwargs)
             @login_required
             def radar_start(request, id_camp, id_radar):
+                print("Boton presionados",flush=True)
                 campaign    = get_object_or_404(Campaign, pk=id_camp)
                 experiments = campaign.get_experiments_by_radar(id_radar)[0]['experiments']
                 now         = datetime.now()
                 for exp in experiments:
                     #app.control.revoke(exp.task)
                     print("----------------------")
-                    print("status:->", exp.status)
+                    print("status:->", exp.status,flush=True)
                     start = datetime.combine(datetime.now().date(), exp.start_time)
                     end   = datetime.combine(datetime.now().date(), exp.end_time)
-                    print("start exp: ",exp.start_time)
+                    print("start exp: ",exp.start_time,flush=True)
-                    print("end exp: ",exp.end_time)
+                    print("end exp: ",exp.end_time,flush=True)
-                    print("start comb: ",start)
+                    print("start comb: ",start,flush=True)
-                    print("end comb: ",end)
+                    print("end comb: ",end,flush=True)
-                    print(is_aware(start))
+                    print(is_aware(start),flush=True)
-                    print("start camp",campaign.start_date)
+                    print("start camp",campaign.start_date,flush=True)
-                    print("end camp",campaign.end_date)
+                    print("end camp",campaign.end_date,flush=True)
-                    print(is_aware(campaign.start_date))
+                    print(is_aware(campaign.start_date),flush=True)
                     if end < start:
                         end += timedelta(1)
                     if exp.status == 2:
                         messages.warning(
                             request, 'Experiment {} already running'.format(exp))
                         #continue
                     if exp.status == 3:
                         messages.warning(
                             request, 'Experiment {} already programmed'.format(exp))
                         #continue
                     if exp.status == 1:
                         messages.warning(
                             request, 'Experiment {} stopped'.format(exp))
                         #continue
                     if start > campaign.end_date:
                         messages.warning(
                             request, 'Experiment {} out of date'.format(exp))
                     #app.control.revoke(exp.task)
-                    print("Llego luego del revoke")
+                    print("Llego luego del revoke",flush=True)
                     if now >= start and now <= end:
-                        print("Caso now > start and < end -- (1)")
+                        print("Caso now > start and < end -- (1)",flush=True)
                         # -------------------------------------------
                         # task = task_start.delay(exp.id)
                         # exp.task   = task.id
                         # exp.status = task.get()
                         # -------------------------------------------
                         #exp.status = task.wait()
                         if exp.status == 0:
                             messages.error(request, 'Experiment {} not start'.format(exp))
                         if exp.status == 2:
                             messages.success(request, 'Experiment {} started'.format(exp))
                     elif now < start:
                         print("Caso now <= start -- (2)",exp.pk)
                         #task = task_start.apply_async((exp.pk, ), eta=start)#start+timedelta(hours=5))
                         # task = task_start.apply_async((exp.pk, ), eta=start+timedelta(hours=5))#)
                         # exp.task   = task.id
                         # exp.status = 3
                         messages.success(request, 'Experiment {} programmed to start at {}'.format(exp, start))
                     else:
                         print("Caso now > end -- (3)")
                         exp.status = 4
                         messages.warning(
                             request, 'Experiment {} out of date'.format(exp))
                     exp.save()
                 return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
             @login_required
             def radar_stop(request, id_camp, id_radar):
                 campaign    = get_object_or_404(Campaign, pk=id_camp)
                 experiments = campaign.get_experiments_by_radar(id_radar)[0]['experiments']
                 print("Ingreso en stop radar_stop")
                 #for exp in experiments:
                     # if exp.task:
                     #     print("Ingreso antes de revoke stop")
                     #     app.control.revoke(exp.task)
                     # if exp.status == 2: #status 2 es started
                     #     print("llama a exp.stop")
                     #     exp.stop()
                     #     messages.warning(request, 'Experiment {} stopped'.format(exp))
                     # exp.status = 1
                     # exp.save()
                 #return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
             @login_required
             def radar_refresh(request, id_camp, id_radar):
                 campaign    = get_object_or_404(Campaign, pk=id_camp)
                 experiments = campaign.get_experiments_by_radar(id_radar)[0]['experiments']
                 i         = app.control.inspect()
                 print("inspect",i)
                 print(i.scheduled())
                 print(i.scheduled().values())
                 scheduled = list(i.scheduled().values())[0]
                 revoked   = list(i.revoked().values())[0]
                 # for exp in experiments:
                 #     if exp.task in revoked:
                 #         exp.status = 1
                 #     elif exp.task in [t['request']['id'] for t in scheduled if 'task_stop' in t['request']['name']]:
                 #         exp.status = 2
                 #     elif exp.task in [t['request']['id'] for t in scheduled if 'task_start' in t['request']['name']]:
                 #         exp.status = 3
                 #     else:
                 #         exp.status = 4
                 #     exp.save()
                 # return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
             #@login_required
             # def revoke_tasks(request, id_camp):
             #     i         = app.control.inspect()
             #     scheduled = list(i.scheduled().values())[0]
             #     revoked   = list(i.revoked().values())[0]
             #     for t in scheduled:
             #         if t['request']['id'] in revoked:
             #             continue
             #         app.control.revoke(t['request']['id'])
             #         exp  = Experiment.objects.get(pk=eval(str(t['request']['args']))[0])
             #         eta  = t['eta']
             #         #task = t['request']['name'].split('.')[-1]
             #         messages.warning(request, 'Scheduled {} at {} for experiment {} revoked'.format(task, eta, exp.name))
             #     return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
             # @login_required
             # def show_tasks(request, id_camp):
             #     i         = app.control.inspect()
             #     scheduled = list(i.scheduled().values())[0]
             #     revoked   = list(i.revoked().values())[0]
             #     for t in scheduled:
             #         if t['request']['id'] in revoked:
             #             continue
             #         exp = Experiment.objects.get(pk=eval(str(t['request']['args']))[0])
             #         eta = t['eta']
             #         #task = t['request']['name'].split('.')[-1]
             #         #messages.success(request, 'Task {} scheduled at {} for experiment {}'.format(task, eta, exp.name))
             #     return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
             def real_time(request):
                 graphic_path = "/home/fiorella/Pictures/catwbeanie.jpg"
                 kwargs = {}
                 kwargs['title'] = 'CLAIRE'
                 kwargs['suptitle'] = 'Real Time'
                 kwargs['no_sidebar'] = True
                 kwargs['graphic_path'] = graphic_path
                 kwargs['graphic1_path'] = 'http://www.bluemaize.net/im/girls-accessories/shark-beanie-11.jpg'
                 return render(request, 'real_time.html', kwargs)
             def theme(request, theme):
                 user = request.user
                 user.profile.theme = theme
                 user.save()
                 return redirect('index')

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages