radarsys Commit - r397:e40954e05ac0 · Jicamarca Repository

ATRAD actualizando títulos

Renato Huallpa -

r397:e40954e05ac0

parent child

Context file:

r397:e40954e05ac0

Expand all files

.env 644 ➡ 755 +1 0

             REDIS_HOST=radarsys-redis
             REDIS_PORT=6300
             POSTGRES_PORT_5432_TCP_ADDR=radarsys-postgres
             POSTGRES_PORT_5432_TCP_PORT=5432
             #POSTGRES_HOST=postgres
             POSTGRES_HOST=localhost
             POSTGRES_USER=docker
             POSTGRES_PASSWORD=docker
             POSTGRES_DB=radarsys
             # DB_NAME=radarsys
             # DB_USER=docker
             # DB_PASSWORD=docker
             PGDATA=/var/lib/postgresql/data
             LC_ALL=C.UTF-8
             TZ=America/Lima
             DOCKER_DATA=/data/dockers/radarsys/
             LOCAL_IP=192.168.1.128
             MQTT_SERVER=10.10.10.200
             # MQTT_SERVER = 192.168.100.5
             MQTT_PORT = 1883
             MQTT_KEEPALIVE = 3660
             MQTT_USER_ATRAD=''
             MQTT_PASSWORD_ATRAD = ''
             MQTT_TOPIC_ATRAD_RECIEVE = "atrad/test4"
+            MQTT_TOPIC_ATRAD_CONTROL = "atrad/test2"
             MQTT_USER = abs
             MQTT_PASSWORD = abs
             TOPIC_ABS=abs/beams
             TOPIC_ABS_ACK=abs/beams_ack
             TOPIC_ABS_CHANGE=abs/change_beam

apps/abs/models.py +1 -27

             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],)
-                            # print("*************************RUNNING ABS**************************",flush=True)
                             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):
                     self.device.status = 2
                     self.active_beam = 0
                     self.device.save()
                     self.message = 'ABS has been stopped.'
                     self.save()
                     return True
                 def stop_device_mqtt(self):
                     self.device.status = 2
                     self.active_beam = 0
                     # conf_active = None
                     # conf_active.save()
                     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
                     """
                     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("Estoy en write_device normal",flush=True)
                         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
             # DEV_STATES = (
             #                  (0, 'No connected'),
             #                  (1, 'Connected'),
             #                  (2, 'Configured'),
             #                  (3, 'Running'),
             #                  (4, 'Unknown'),
             #                  (5, 'Busy')
             #              )
                 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)
                     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()
                     self.device.status = 3
                     self.save()
                     conf_active, __ = ABSActive.objects.get_or_create(pk=1)
                     conf_active.conf = self
                     conf_active.save()
                     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')
-                    print("Estoy en status_deice",flush=True)
+                    # print("Estoy en status_deice",flush=True)
                     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)
                     print("Estoy en send_beam ",flush=True)
                     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 change_beam_mqtt(self, beam_pos):
                     """
                     This function connects send through mqtt the order of change_beam (id of beam).
                     """
                     print ('Change beam MQTT')
                     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_mqtt_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()
                     mqtt_client.publish('abs/change_beam',str(beam_pos))
                     #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.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/views.py +3 -3

             from django.shortcuts import render
             from django.template import RequestContext
             from django.shortcuts import redirect, render, get_object_or_404
             from django.contrib import messages
             from django.conf import settings
             from django.http import HttpResponse
             from django.urls import reverse
             from django.views.decorators.csrf import csrf_exempt
             from django.utils.safestring import mark_safe
             from datetime import datetime
             from time import sleep
             import os
             import io
             from apps.main.models import Device, Configuration, Experiment
             from apps.main.views import sidebar
             from .models import ABSConfiguration, ABSBeam
             from .forms import ABSConfigurationForm, ABSBeamEditForm, ABSBeamAddForm, ABSImportForm
             from .utils.overJroShow import overJroShow
             #from .utils.OverJRO import OverJRO
             #Create your views here.
             import json, ast
             from .mqtt import client as mqtt_client
             from radarsys.socketconfig import sio as sio
             def get_values_from_form(form_data):
                 sublistup     = []
                 sublistdown   = []
                 subtxlistup   = []
                 subtxlistdown = []
                 subrxlistup   = []
                 subrxlistdown = []
                 up_values_list     = []
                 down_values_list   = []
                 up_txvalues_list   = []
                 down_txvalues_list = []
                 up_rxvalues_list   = []
                 down_rxvalues_list = []
                 values_list = {}
                 cont = 1
                 for i in range(1,65):
                     x = float(form_data['abs_up'+str(i)])
                     y = float(form_data['abs_down'+str(i)])
                     sublistup.append(x)
                     sublistdown.append(y)
                     if str(i) in form_data.getlist('uptx_checks'):
                         subtxlistup.append(1)
                     else:
                         subtxlistup.append(0)
                     if str(i) in form_data.getlist('downtx_checks'):
                         subtxlistdown.append(1)
                     else:
                         subtxlistdown.append(0)
                     if str(i) in form_data.getlist('uprx_checks'):
                         subrxlistup.append(1)
                     else:
                         subrxlistup.append(0)
                     if str(i) in form_data.getlist('downrx_checks'):
                         subrxlistdown.append(1)
                     else:
                         subrxlistdown.append(0)
                     cont = cont+1
                     if cont == 9:
                         up_values_list.append(sublistup)
                         down_values_list.append(sublistdown)
                         sublistup   = []
                         sublistdown = []
                         up_txvalues_list.append(subtxlistup)
                         down_txvalues_list.append(subtxlistdown)
                         subtxlistup   = []
                         subtxlistdown = []
                         up_rxvalues_list.append(subrxlistup)
                         down_rxvalues_list.append(subrxlistdown)
                         subrxlistup   = []
                         subrxlistdown = []
                         cont = 1
                 list_uesup   = []
                 list_uesdown = []
                 for i in range(1,5):
                     if form_data['ues_up'+str(i)] == '':
                         list_uesup.append(0.0)
                     else:
                         list_uesup.append(float(form_data['ues_up'+str(i)]))
                     if form_data['ues_down'+str(i)] == '':
                         list_uesdown.append(0.0)
                     else:
                         list_uesdown.append(float(form_data['ues_down'+str(i)]))
                 onlyrx_list = form_data.getlist('onlyrx')
                 only_rx = {}
                 if '1' in onlyrx_list:
                     only_rx['up'] = True
                 else:
                     only_rx['up'] = False
                 if '2' in onlyrx_list:
                     only_rx['down'] = True
                 else:
                     only_rx['down'] = False
                 antenna = {'antenna_up': up_values_list, 'antenna_down': down_values_list}
                 tx      = {'up': up_txvalues_list, 'down': down_txvalues_list}
                 rx      = {'up': up_rxvalues_list, 'down': down_rxvalues_list}
                 ues     = {'up': list_uesup, 'down': list_uesdown}
                 name    = str(form_data['beam_name'])
                 beam_data = {'name': name, 'antenna': antenna, 'tx': tx, 'rx': rx, 'ues': ues, 'only_rx': only_rx}
                 return beam_data
             def abs_conf(request, id_conf):
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beams = ABSBeam.objects.filter(abs_conf=conf)
                 #------------Colors for Active Beam:-------------
                 all_status = {}
                 module_messages = json.loads(conf.module_messages)
                 color_status   = {}
                 for i, status in enumerate(conf.module_status):
                     if status == '3':    #Running background-color: #00cc00;
                         all_status['{}'.format(i+1)] = 2
                         color_status['{}'.format(i+1)] = 'class=text-success'#'bgcolor=#00cc00'
                     elif status == '2':
                         all_status['{}'.format(i+1)] = 1
                         color_status['{}'.format(i+1)] = 'class=text-info'
                     elif status == '1':  #Connected background-color: #ee902c;
                         all_status['{}'.format(i+1)] = 1
                         color_status['{}'.format(i+1)] = 'class=text-warning'#'bgcolor=#ee902c'
                     else:                #Disconnected background-color: #ff0000;
                         all_status['{}'.format(i+1)] = 0
                         color_status['{}'.format(i+1)] = 'class=text-danger'#'bgcolor=#FF0000'
                 #------------------------------------------------
                 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.html', kwargs)
             def abs_conf_mqtt(request, id_conf):
-                print("Estoy en abs_conf_mqtt",flush=True)
+                # print("Estoy en abs_conf_mqtt",flush=True)
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beams = ABSBeam.objects.filter(abs_conf=conf)
                 #------------Colors for Active Beam:-------------
                 all_status = {}
                 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['mqtt']=True
                 kwargs['beams'] = beams
                 kwargs['modules_status'] = all_status
                 kwargs['module_messages'] = module_messages
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 print("conf.active_beam: {}",format(conf.active_beam))
                 # print(conf.beam.pk)
                 return render(request, 'abs_conf_mqtt.html', kwargs)
                 # // console.log(beam.pk);
                 # // console.log(active_beam);
             # def abs_conf_mqtt(request, id_conf):
             #     # socket.on('beams_ack',function(data){
                 #   ack=data;
                 #   console.log("ack")
                 #   console.log(ack)
                 # })
             def abs_conf_edit(request, id_conf):
                 conf     = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beams = ABSBeam.objects.filter(abs_conf=conf)
                 if request.method=='GET':
                     form = ABSConfigurationForm(instance=conf)
                 if request.method=='POST':
                     form = ABSConfigurationForm(request.POST, instance=conf)
                     if form.is_valid():
                         conf = form.save(commit=False)
                         conf.save()
                         return redirect('url_abs_conf_mqtt', id_conf=conf.id)
                 ###### SIDEBAR ######
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 #kwargs['id_dev'] = conf.id
                 kwargs['id_conf'] = conf.id
                 kwargs['form'] = form
                 kwargs['abs_beams'] = beams
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Save'
                 kwargs['mqtt']=True
                 kwargs['edit'] = True
                 return render(request, 'abs_conf_edit.html', kwargs)
             @csrf_exempt
             def abs_conf_alert(request):
                 if request.method == 'POST':
                     print (request.POST)
                     return HttpResponse(json.dumps({'result':1}), content_type='application/json')
                 else:
                     return redirect('index')
             def import_file(request, id_conf):
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 if request.method=='POST':
                     form = ABSImportForm(request.POST, request.FILES)
                     if form.is_valid():
                         try:
                             parms = conf.import_from_file(request.FILES['file_name'])
                             if parms:
                                 conf.update_from_file(parms)
                                 messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name'])
                                 return redirect(conf.get_absolute_url_edit())
                         except Exception as e:
                             messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], e))
                 else:
                     messages.warning(request, 'Your current configuration will be replaced')
                     form = ABSImportForm()
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'ABS Configuration'
                 kwargs['suptitle'] = 'Import file'
                 kwargs['button'] = 'Upload'
                 kwargs['previous'] = conf.get_absolute_url()
                 return render(request, 'abs_import.html', kwargs)
             def send_beam(request, id_conf, id_beam):
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 abs = Configuration.objects.filter(pk=conf.device.conf_active).first()
                 if abs!=conf:
                     url = '#' if abs is None else abs.get_absolute_url()
                     label = 'None' if abs is None else abs.label
                     messages.warning(
                         request,
                         mark_safe('The current configuration has not been written in the modules, the active configuration is <a href="{}">{}</a>'.format(
                             url,
                             label
                             ))
                         )
                     return redirect(conf.get_absolute_url())
                 beam = get_object_or_404(ABSBeam, pk=id_beam)
                 if request.method == 'POST':
                     beams_list = ABSBeam.objects.filter(abs_conf=conf)
                     conf.active_beam = id_beam
                     i = 0
                     for b in beams_list:
                         if b.id == int(id_beam):
                             break
                         else:
                             i += 1
                     beam_pos = i + 1 #Estandarizar
                     print('{} Position {}'.format(beam.name,str(beam_pos)))
                     conf.send_beam(beam_pos)
                     return redirect('url_abs_conf', conf.id)
                 kwargs = {
                     'title': 'ABS',
                     'suptitle': conf.label,
                     'message': 'Are you sure you want to change ABS Beam through SEND BEAM to: {}?'.format(beam.name),
                     'delete': False
                 }
                 kwargs['menu_configurations'] = 'active'
                 return render(request, 'confirm.html', kwargs)
             def change_beam_mqtt(request, id_conf, id_beam):
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
-                print("conf: {}".format(conf),flush=True)
+                # print("conf: {}".format(conf),flush=True)
                 abs = Configuration.objects.filter(pk=conf.device.conf_active).first()
-                print("abs: {}".format(abs),flush=True)
+                # print("abs: {}".format(abs),flush=True)
                 if abs!=conf:
                     url = '#' if abs is None else abs.get_absolute_url()
                     label = 'None' if abs is None else abs.label
                     messages.warning(
                         request,
                         mark_safe('The current configuration has not been written in the modules, the active configuration is <a href="{}">{}</a>'.format(
                             url,
                             label
                             ))
                         )
                     return redirect(conf.get_absolute_mqtt_url())
                 beams = ABSBeam.objects.filter(abs_conf=conf)
                 beam = get_object_or_404(ABSBeam, pk=id_beam)
                 if request.method == 'POST':
                     beams_list = ABSBeam.objects.filter(abs_conf=conf)
                     conf.active_beam = id_beam
                     i = 0
                     for b in beams_list:
                         if b.id == int(id_beam):
                             break
                         else:
                             i += 1
                     beam_pos = i + 1 #Estandarizar
                     print('{} Position {}'.format(beam.name,str(beam_pos)),flush=True)
                     conf.change_beam_mqtt(beam_pos)
                     # return redirect('url_abs_conf', conf.id)
                     return redirect('url_abs_conf_mqtt', conf.id)
                     # return render(request, 'abs_conf_mqtt.html',kwargs)
                 kwargs = {
                     'title': 'ABS',
                     'mqtt':True,
                     'suptitle': conf.label,
                     'message': 'Are you sure you want to change ABS Beam through MQTT to: {}?'.format(beam.name),
                     'delete': False
                 }
                 kwargs['menu_configurations'] = 'active'
                 return render(request, 'confirm.html', kwargs)
             def add_beam(request, id_conf):
                 conf     = get_object_or_404(ABSConfiguration, pk=id_conf)
                 confs    = Configuration.objects.all()
                 if request.method=='GET':
                     form = ABSBeamAddForm()
                 if request.method=='POST':
                     form = ABSBeamAddForm(request.POST)
                     beam_data = get_values_from_form(request.POST)
                     new_beam = ABSBeam(
                                name     = beam_data['name'],
                                antenna  = json.dumps(beam_data['antenna']),
                                abs_conf = conf,
                                tx       = json.dumps(beam_data['tx']),
                                rx       = json.dumps(beam_data['rx']),
                                ues      = json.dumps(beam_data['ues']),
                                only_rx  = json.dumps(beam_data['only_rx'])
                                )
                     new_beam.save()
                     messages.success(request, 'Beam: "%s" has been added.'  % new_beam.name)
                     return redirect('url_edit_abs_conf', conf.id)
                 ###### SIDEBAR ######
                 kwargs = {}
                 #kwargs['dev_conf']  = conf.device
                 #kwargs['id_dev']    = conf.device
                 #kwargs['previous']  = conf.get_absolute_url_edit()
                 kwargs['id_conf']    = conf.id
                 kwargs['form']       = form
                 kwargs['title']      = 'ABS Beams'
                 kwargs['suptitle']   = 'Add Beam'
                 kwargs['button']     = 'Add'
                 kwargs['no_sidebar'] = True
                 kwargs['edit']       = True
                 return render(request, 'abs_add_beam.html', kwargs)
             def edit_beam(request, id_conf, id_beam):
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beam = get_object_or_404(ABSBeam, pk=id_beam)
                 if request.method=='GET':
                     form = ABSBeamEditForm(initial={'beam': beam})
                 if request.method=='POST':
                     form = ABSBeamEditForm(request.POST)
                     beam_data = get_values_from_form(request.POST)
                     beam.dict_to_parms(beam_data)
                     beam.save()
                     messages.success(request, 'Beam: "%s" has been updated.'  % beam.name)
                     return redirect('url_edit_abs_conf', conf.id)
                 ###### SIDEBAR ######
                 kwargs = {}
                 kwargs['id_conf'] = conf.id
                 kwargs['form'] = form
                 kwargs['title'] = 'ABS Beams'
                 kwargs['suptitle'] = 'Edit Beam'
                 kwargs['button'] = 'Save'
                 kwargs['no_sidebar'] = True
                 #kwargs['previous'] = conf.get_absolute_url_edit()
                 kwargs['edit'] = True
                 return render(request, 'abs_edit_beam.html', kwargs)
             def remove_beam(request, id_conf, id_beam):
                 conf     = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beam     = get_object_or_404(ABSBeam, pk=id_beam)
                 if request.method=='POST':
                     if beam:
                         try:
                             beam.delete()
                             messages.success(request, 'Beam: "%s" has been deleted.'  % beam)
                         except:
                             messages.error(request, 'Unable to delete beam: "%s".' % beam)
                     return redirect('url_edit_abs_conf', conf.id)
                 ###### SIDEBAR ######
                 kwargs = {}
                 kwargs['object'] = beam
                 kwargs['delete'] = True
                 kwargs['title'] = 'Delete'
                 kwargs['suptitle'] = 'Beam'
                 kwargs['previous'] = conf.get_absolute_url_edit()
                 return render(request, 'confirm.html', kwargs)
             def plot_patterns(request, id_conf, id_beam=None):
                 kwargs = {}
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beams = ABSBeam.objects.filter(abs_conf=conf)
                 if id_beam:
                     beam  = get_object_or_404(ABSBeam, pk=id_beam)
                     kwargs['beam'] = beam
                 ###### SIDEBAR ######
                 kwargs['dev_conf']   = conf.device
                 kwargs['id_dev']     = conf.device
                 kwargs['id_conf']    = conf.id
                 kwargs['abs_beams']  = beams
                 kwargs['title']      = 'ABS Patterns'
                 kwargs['suptitle']   = conf.name
                 kwargs['no_sidebar'] = True
                 return render(request, 'abs_patterns.html', kwargs)
             def plot_pattern(request, id_conf, id_beam, antenna):
                 if antenna=='down':
                     sleep(3)
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beam = get_object_or_404(ABSBeam, pk=id_beam)
                 just_rx = 1 if json.loads(beam.only_rx)[antenna] else 0
                 phases = json.loads(beam.antenna)['antenna_{}'.format(antenna)]
                 gain_tx = json.loads(beam.tx)[antenna]
                 gain_rx = json.loads(beam.rx)[antenna]
                 ues = json.loads(beam.ues)[antenna]
                 newOverJro = overJroShow(beam.name)
                 fig = newOverJro.plotPattern2(datetime.today(), phases, gain_tx, gain_rx, ues, just_rx)
                 buf = io.BytesIO()
                 fig.savefig(buf, format='png')
                 response = HttpResponse(buf.getvalue(), content_type='image/png')
                 return response
             import os
             from django.http import HttpResponse
             @sio.on('connection-bind')
             def abs_connection_bind(sid, data):
                 print("sid:",sid,"data",data)
             @sio.on('disconnect')
             def abs_test_disconnect(sid):
                 print("Disconnected")
             @sio.event
             def abs_send_beam_up(sid, message):
                 mqtt_client.publish('abs/beams_up', message['data'])
             @sio.event
             def abs_send_beam_down(sid, message):
                 mqtt_client.publish('abs/beams_down', message['data'])
             # @sio.event
             # def change_beam(sid,message):
             #     data=str(message['data'])
             #     data=data[16]
             #     mqtt_client.publish('abs/change_beam',data)

apps/atrad/models.py +5 0

             from django.db import models
             from apps.main.models import Configuration
             from apps.main.utils import Params
             from django.core.validators import MinValueValidator, MaxValueValidator
             from .files import read_json_file
             import requests
             class ATRADData(models.Model):
                 datetime = models.DateTimeField()
                 nstx = models.SmallIntegerField()
                 status_1 = models.SmallIntegerField()
                 temp_cll_1 = models.SmallIntegerField()
                 nboards_1 = models.SmallIntegerField()
                 tempdvr_1 = models.SmallIntegerField()
                 potincdvr_1 = models.SmallIntegerField()
                 potretdvr_1 = models.SmallIntegerField()
                 temp1_1 = models.SmallIntegerField()
                 potinc1_1 = models.SmallIntegerField()
                 potret1_1 = models.SmallIntegerField()
                 temp2_1 = models.SmallIntegerField()
                 potinc2_1 = models.SmallIntegerField()
                 potret2_1 = models.SmallIntegerField()
                 temp3_1 = models.SmallIntegerField()
                 potinc3_1 = models.SmallIntegerField()
                 potret3_1 = models.SmallIntegerField()
                 temp4_1 = models.SmallIntegerField()
                 potinc4_1 = models.SmallIntegerField()
                 potret4_1 = models.SmallIntegerField()
                 temp5_1 = models.SmallIntegerField()
                 potinc5_1 = models.SmallIntegerField()
                 potret5_1 = models.SmallIntegerField()
                 temp6_1 = models.SmallIntegerField()
                 potinc6_1 = models.SmallIntegerField()
                 potret6_1 = models.SmallIntegerField()
                 status_2 = models.SmallIntegerField()
                 temp_cll_2 = models.SmallIntegerField()
                 nboards_2 = models.SmallIntegerField()
                 tempdvr_2 = models.SmallIntegerField()
                 potincdvr_2 = models.SmallIntegerField()
                 potretdvr_2 = models.SmallIntegerField()
                 temp1_2 = models.SmallIntegerField()
                 potinc1_2 = models.SmallIntegerField()
                 potret1_2 = models.SmallIntegerField()
                 temp2_2 = models.SmallIntegerField()
                 potinc2_2 = models.SmallIntegerField()
                 potret2_2 = models.SmallIntegerField()
                 temp3_2 = models.SmallIntegerField()
                 potinc3_2 = models.SmallIntegerField()
                 potret3_2 = models.SmallIntegerField()
                 temp4_2 = models.SmallIntegerField()
                 potinc4_2 = models.SmallIntegerField()
                 potret4_2 = models.SmallIntegerField()
                 temp5_2 = models.SmallIntegerField()
                 potinc5_2 = models.SmallIntegerField()
                 potret5_2 = models.SmallIntegerField()
                 temp6_2 = models.SmallIntegerField()
                 potinc6_2 = models.SmallIntegerField()
                 potret6_2 = models.SmallIntegerField()
                 status_3 = models.SmallIntegerField()
                 temp_cll_3 = models.SmallIntegerField()
                 nboards_3 = models.SmallIntegerField()
                 tempdvr_3 = models.SmallIntegerField()
                 potincdvr_3 = models.SmallIntegerField()
                 potretdvr_3 = models.SmallIntegerField()
                 temp1_3 = models.SmallIntegerField()
                 potinc1_3 = models.SmallIntegerField()
                 potret1_3 = models.SmallIntegerField()
                 temp2_3 = models.SmallIntegerField()
                 potinc2_3 = models.SmallIntegerField()
                 potret2_3 = models.SmallIntegerField()
                 temp3_3 = models.SmallIntegerField()
                 potinc3_3 = models.SmallIntegerField()
                 potret3_3 = models.SmallIntegerField()
                 temp4_3 = models.SmallIntegerField()
                 potinc4_3 = models.SmallIntegerField()
                 potret4_3 = models.SmallIntegerField()
                 temp5_3 = models.SmallIntegerField()
                 potinc5_3 = models.SmallIntegerField()
                 potret5_3 = models.SmallIntegerField()
                 temp6_3 = models.SmallIntegerField()
                 potinc6_3 = models.SmallIntegerField()
                 potret6_3 = models.SmallIntegerField()
                 status_4 = models.SmallIntegerField()
                 temp_cll_4 = models.SmallIntegerField()
                 nboards_4 = models.SmallIntegerField()
                 tempdvr_4 = models.SmallIntegerField()
                 potincdvr_4 = models.SmallIntegerField()
                 potretdvr_4 = models.SmallIntegerField()
                 temp1_4 = models.SmallIntegerField()
                 potinc1_4 = models.SmallIntegerField()
                 potret1_4 = models.SmallIntegerField()
                 temp2_4 = models.SmallIntegerField()
                 potinc2_4 = models.SmallIntegerField()
                 potret2_4 = models.SmallIntegerField()
                 temp3_4 = models.SmallIntegerField()
                 potinc3_4 = models.SmallIntegerField()
                 potret3_4 = models.SmallIntegerField()
                 temp4_4 = models.SmallIntegerField()
                 potinc4_4 = models.SmallIntegerField()
                 potret4_4 = models.SmallIntegerField()
                 temp5_4 = models.SmallIntegerField()
                 potinc5_4 = models.SmallIntegerField()
                 potret5_4 = models.SmallIntegerField()
                 temp6_4 = models.SmallIntegerField()
                 potinc6_4 = models.SmallIntegerField()
                 potret6_4 = models.SmallIntegerField()
+                combiner1 = models.SmallIntegerField()
+                combiner2 = models.SmallIntegerField()
+                combiner3 = models.SmallIntegerField()
+                combiner4 = models.SmallIntegerField()
                 class Meta:
                     db_table = 'atrad_datas'
                 def __unicode__(self):
                     return u'%s' % (self.name)
             class ATRADConfiguration(Configuration):
                 topic = models.PositiveIntegerField(verbose_name='Topic',validators=[MaxValueValidator(10)], default = 0)
                 def status_device(self):
                     ip=self.device.ip_address
                     port=self.device.port_address
                     route = "http://" + str(ip) + ":" + str(port) + "/status/"
                     try:
                         r = requests.get(route, timeout=0.7)
                     except Exception as e:
                         self.device.status = 0
                         self.device.save()
                         self.message = 'Could not read TX status: ' + str(e)
                         return False
                     response = r.json()
                     self.device.status = response['status']
                     self.message = response['message']
                     self.device.save()
                     if response['components_status']==0:
                         return False
                     return True
                 def start_device(self):
                     ip=self.device.ip_address
                     port=self.device.port_address
                     #---Device must be configured
                     if not self.device.status == 2:
                         self.message = 'TX Device must be configured.'
                         return False
                     #---Frequencies from form
                     post_data = self.parms_to_dict()
                     route = "http://" + str(ip) + ":" + str(port) + "/write/"
                     try:
                         r = requests.post(route, post_data, timeout=0.7)
                     except Exception as e:
                         self.message = "Could not start TX device. "+str(e)
                         return False
                     response = r.json()
                     if response['status']==1:
                         self.device.status = 1
                         self.device.save()
                         self.message = response['message']
                         return False
                     self.device.status = response['status']
                     self.device.save()
                     self.message = response['message']
                     return True
                 def stop_device(self):
                     ip=self.device.ip_address
                     port=self.device.port_address
                     if self.device.status == 2: #Configured
                         self.message = 'TX device is already stopped.'
                         return False
                     post_data = {"topic":0}
                     route = "http://" + str(ip) + ":" + str(port) + "/write/"
                     try:
                         r = requests.post(route, post_data, timeout=0.7)
                     except Exception as e:
                         self.message = "Could not write TX parameters. "+str(e)
                         self.device.status = 0
                         self.device.save()
                         return False
                     response = r.json()
                     status = response['status']
                     if status == 1:
                         self.device.status = status
                         self.device.save()
                         self.message = 'Could not stop TX device.'
                         return False
                     self.message = 'TX device has been stopped successfully.'
                     self.device.status = 2
                     self.device.save()
                     return True
                 def read_device(self):
                     ip=self.device.ip_address
                     port=self.device.port_address
                     route = "http://" + str(ip) + ":" + str(port) + "/read/"
                     try:
                         frequencies = requests.get(route,timeout=0.7)
                     except:
                         self.message = "Could not read TX parameters from this device"
                         return None
                     frequencies = frequencies.json()
                     if frequencies:
                         frequencies = frequencies.get("Frequencies")
                         topic = frequencies.get("topic")
                         parms = {'topic': topic}
                         self.message = "TX parameters have been successfully read"
                         return parms
                     else:
                         self.message = "Error reading TX parameters"
                         return None
                 def write_device(self):
                     ip=self.device.ip_address
                     port=self.device.port_address
                     #---Frequencies from form
                     parms = self.parms_to_dict()['configurations']
                     for parm in parms['allIds']:
                             byid = parm
                     frequencies = parms['byId'][byid]
                     post_data = {}
                     for data in frequencies:
                         if data in ['topic']:
                             post_data[data] = frequencies[data]
                     route = "http://" + str(ip) + ":" + str(port) + "/write/"
                     print (post_data)
                     try:
                         r = requests.post(route, post_data, timeout=0.7)
                     except:
                         self.message = "Could not write TX parameters"
                         self.device.status = 0
                         self.device.save()
                         return False
                     response = r.json()
                     self.message = response['message']
                     self.device.status = response['status']
                     self.device.save()
                     if self.device.status==1:
                         return False
                     return True
                 class Meta:
                     db_table = 'atrad_configurations'

apps/atrad/mqtt.py +8 -6

             import paho.mqtt.client as mqtt
             from radarsys import settings
             from radarsys.socketconfig import sio as sio
             import numpy as np
             import psycopg2
             import os
             def insert(time,data):
                 sql = """INSERT INTO atrad_datas(
                     datetime,nstx,status_1,temp_cll_1,nboards_1,tempdvr_1,potincdvr_1,potretdvr_1,
                     temp1_1,potinc1_1,potret1_1,temp2_1,potinc2_1,potret2_1,temp3_1,potinc3_1,potret3_1,
                     temp4_1,potinc4_1,potret4_1,temp5_1,potinc5_1,potret5_1,temp6_1,potinc6_1,potret6_1,
                     status_2,temp_cll_2,nboards_2,tempdvr_2,potincdvr_2,potretdvr_2,
                     temp1_2,potinc1_2,potret1_2,temp2_2,potinc2_2,potret2_2,temp3_2,potinc3_2,potret3_2,
                     temp4_2,potinc4_2,potret4_2,temp5_2,potinc5_2,potret5_2,temp6_2,potinc6_2,potret6_2,
                     status_3,temp_cll_3,nboards_3,tempdvr_3,potincdvr_3,potretdvr_3,
                     temp1_3,potinc1_3,potret1_3,temp2_3,potinc2_3,potret2_3,temp3_3,potinc3_3,potret3_3,
                     temp4_3,potinc4_3,potret4_3,temp5_3,potinc5_3,potret5_3,temp6_3,potinc6_3,potret6_3,
                     status_4,temp_cll_4,nboards_4,tempdvr_4,potincdvr_4,potretdvr_4,
                     temp1_4,potinc1_4,potret1_4,temp2_4,potinc2_4,potret2_4,temp3_4,potinc3_4,potret3_4,
-                    temp4_4,potinc4_4,potret4_4,temp5_4,potinc5_4,potret5_4,temp6_4,potinc6_4,potret6_4)
+                    temp4_4,potinc4_4,potret4_4,temp5_4,potinc5_4,potret5_4,temp6_4,potinc6_4,potret6_4,
+                    combiner1,combiner2,combiner3,combiner4)
                     VALUES(%s,%s,%s,%s,%s,%s,%s,%s,
                     %s,%s,%s,%s,%s,%s,%s,%s,%s,
                     %s,%s,%s,%s,%s,%s,%s,%s,%s,
                     %s,%s,%s,%s,%s,%s,
                     %s,%s,%s,%s,%s,%s,%s,%s,%s,
                     %s,%s,%s,%s,%s,%s,%s,%s,%s,
                     %s,%s,%s,%s,%s,%s,
                     %s,%s,%s,%s,%s,%s,%s,%s,%s,
                     %s,%s,%s,%s,%s,%s,%s,%s,%s,
                     %s,%s,%s,%s,%s,%s,
                     %s,%s,%s,%s,%s,%s,%s,%s,%s,
-                    %s,%s,%s,%s,%s,%s,%s,%s,%s);"""
+                    %s,%s,%s,%s,%s,%s,%s,%s,%s,
+                    %s,%s,%s,%s);"""
                 try:
                     # connect to the PostgreSQL database
                     conn = psycopg2.connect(database="radarsys", user='docker', password='docker', host='radarsys-postgres', port= '5432')
                     # create a new cursor
                     cur = conn.cursor()
                     # execute the INSERT statement
                     #data_tuple = [tuple(i[:]) for i in a]
-                    values = (time,) + tuple(data[0][:25])+tuple(data[1][1:25])+tuple(data[2][1:25])+tuple(data[3][1:25])
+                    values = (time,) + tuple(data[0][:25])+tuple(data[1][1:25])+tuple(data[2][1:25])+tuple(data[3][1:25]) + tuple(data[0][29:31]) +tuple(data[2][27:29])
                     cur.execute(sql, values)
                     # get the generated id back
                     #vendor_id = cur.fetchone()[0]
                     # commit the changes to the database
                     conn.commit()
                     # close communication with the database
                     cur.close()
                 except (Exception, psycopg2.DatabaseError) as error:
                     print(error)
                 finally:
                     if conn is not None:
                         conn.close()
             def maxTemperature(trs):
                 temps = GetTemperatures(trs)
                 maxT_STX = [max(i) for i in temps]
                 maxT = max(maxT_STX)
                 STXnum = maxT_STX.index(maxT)
                 STXloc = temps[STXnum].index(maxT)
                 maxT_loc = 'Amp ' + str(STXnum+1)
                 if STXloc == 0:
                     maxT_loc = maxT_loc + " Controller"
                 elif STXloc == 1:
                     maxT_loc = maxT_loc + " Driver"
                 elif STXloc<8:
                     maxT_loc = maxT_loc + " PA " + str(STXloc-1)
                 else:
                     maxT_loc = maxT_loc + " Combiners"
                 return maxT,maxT_loc,temps
             def dataConvert(msg):
                 msgStr = str(msg.payload)
                 msgClean = [i for i in msgStr[21:-1].split("*")]
                 dataSTX = [[],[],[],[]]
                 for trs,i in zip(msgClean,[0,1,2,3]) :
                     dataSTX[i]= [int(i) for i in trs[1:-1].split(",")]
                 # Data to database
                 insert(msgStr[2:21],dataSTX)
                 # Data to send by socket
                 id_STX = dataSTX[0][0] // 4
                 status = ''.join([msgClean[i][3] for i in [0,1,2,3]])
                 powers = [dataSTX[0][34],dataSTX[0][36],dataSTX[2][32],dataSTX[2][34],0,0,0,0]
                 # alerta
                 for i in range(4):
                     if powers[i] < 10000 and status == '1111':
                         power[4+i] = 1
                 tmax,index,tempData = maxTemperature(dataSTX)
                 #Json to send
                 data = {'time':msgStr[2:21],'num':id_STX,'pow':powers,'tmax':[str(tmax),index],'status':status}
                 data_temp = {'time':msgStr[2:21],'temp':tempData}
                 return data, data_temp
             def GetTemperatures(data):
                 np_data = [np.array(i) for i in data]
                 temps = [i[i<40] for i in np_data]
                 return [i[i>15].tolist() for i in temps]
             def on_connect(mqtt_client, userdata, flags, rc):
                if rc == 0:
-                   print('Connected successfullyasdss')
+                #    print('Connected successfullyasdss')
-                   mqtt_client.subscribe("atrad/test4")
+                   mqtt_client.subscribe(os.environ.get('MQTT_TOPIC_ATRAD_RECIEVE', 'atrad/test4'))
-                   print("Exito")
+                #    print("Exito")
                else:
                    print('Bad connection. Code:', rc)
             def on_message(mqtt_client, userdata, msg):
                 print('Received message on topic: {} with payload: {}'.format(msg.topic,msg.payload), flush=True)
                 mainData, tempData = dataConvert(msg)
                 sio.emit('test',data = mainData)
                 #socket for temperature details
                 sio.emit('temptx'+str(mainData['num'] + 1),data = tempData)
             client = mqtt.Client()
             client.on_connect = on_connect
             client.on_message = on_message
             client.username_pw_set( '','')
             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', 60))
             )

apps/atrad/templates/atrad_conf.html +8 -8

             {% extends "dev_conf.html" %}
             {% load static %}
             {% block extra-head %}
             <style>
               .dot {
                 height: 25px;
                 width: 25px;
                 background-color: #b0b3af;
                 border-radius: 50%;
                 display: inline-block;
               }
               .row{
                 margin-top: 3px;
                 margin-bottom: 3px;
               }
               .th {
                 vertical-align: middle;
               }
             </style>
             <link href="https://cdn.jsdelivr.net/gh/gitbrent/bootstrap4-toggle@3.6.1/css/bootstrap4-toggle.min.css" rel="stylesheet">
             {% endblock %}
             {% block content-graph %}
             <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.3/jquery.min.js"></script>
             <script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/socket.io/4.4.1/socket.io.min.js"></script>
             <div class="container-fluid">
               <h1 class="py-4 text-center" >ATRAD Monitoring</h1>
                <!-- First row : Control-->
                <div class="row">
                 <div class="card border-light">
                   <div class="card-body">
                     <h3 class="card-title">Control</h3>
                     <table class="table table-borderless">
                       <tbody>
                         <tr>
                           <th class="align-middle">Tx1</th>
                           <td>
                             <button type="button" class="btn btn-outline-success" id="ONBtn1"> ON </button>
                             <button type="button" class="btn btn-outline-danger" id="OFFBtn1"> OFF </button>
                           </td>
                         </tr>
                         <tr>
                           <th class="align-middle">Tx2</th>
                           <td>
                             <button type="button" class="btn btn-outline-success" id="ONBtn2"> ON </button>
                             <button type="button" class="btn btn-outline-danger" id="OFFBtn2"> OFF </button>
                           </td>
                         </tr>
                       </tbody>
                     </table>
                   </div>
                 </div>
               </div>
               <!-- Second row : Status and alerts -->
               <div class="row">
-                <div class="card-deck" style="width: 90%;">
+                <div class="card-deck" style="width: 100%;">
                   <div class="card border-light">
                     <div class="card-body">
                       <h4 class="card-title">Status</h4>
                       <table class="table table-borderless">
                         <tbody>
                           <tr>
                             <th scope="row">Tx1</th>
                             <td><span id="status1" class="dot"></span></td>
                             <td><p id="status-text1" class="font-weight-bold">No data</p></td>
                           </tr>
                           <tr>
                             <th scope="row">Tx2</th>
                             <td><span id="status2" class="dot"></span></td>
                             <td><p id="status-text2" class="font-weight-bold">No data</p></td>
                           </tr>
                         </tbody>
                       </table>
                     </div>
                   </div>
                   <div class="card border-light">
                     <div class="card-body">
                       <h4 class="card-title">High Temperature Alerts</h4>
                       <table class="table table-borderless">
                         <tbody>
                           <tr>
                             <th scope="row"><p id="alerttemp-time1" class="font-weight-bold"></p></th>
                             <td><p id="alerttemp-1" class="font-weight-bold"></p></td>
                             <td><p id="alerttemp-loc1" class="font-weight-bold"></p></td>
                           </tr>
                           <tr>
                             <th scope="row"><p id="alerttemp-time2" class="font-weight-bold"></p></th>
                             <td><p id="alerttemp-2" class="font-weight-bold"></p></td>
                             <td><p id="alerttemp-loc2" class="font-weight-bold"></p></td>
                           </tr>
                         </tbody>
                       </table>
                     </div>
                   </div>
                   <div class="card border-light">
                     <div class="card-body">
                       <h4 class="card-title">Power Alerts</h4>
                       <table class="table table-borderless">
                         <tbody>
                           <tr>
                             <th scope="row"><p id="alertpot-time1" class="font-weight-bold"></p></th>
                             <td><p id="alertpot-1" class="font-weight-bold"></p></td>
                             <td><p id="alertpot-loc1" class="font-weight-bold"></p></td>
                           </tr>
                           <tr>
                             <th scope="row"><p id="alertpot-time2" class="font-weight-bold"></p></th>
                             <td><p id="alertpot-2" class="font-weight-bold"></p></td>
                             <td><p id="alertpot-loc2" class="font-weight-bold"></p></td>
                           </tr>
                         </tbody>
                       </table>
                     </div>
                   </div>
                 </div>
               </div>
               <!-- Third row : power graph-->
               <div class="row ">
                 <div class="card border-light">
                   <div class="card-body">
                     <h3 class="card-title">Power graph</h3>
                     <div class="row justify-content-md-center">
                       <div class="col-md-9">
                         <div id="plot-pot"></div>
                       </div>
                       <div class="col-md-3 text-end">
                         <div class="card-body">
                           <table class="table" style="max-width:170px;">
                             <tbody>
                               <tr>
                                 <th scope="col"># Tx</th>
                                 <th scope="col">Power (kW)</th>
                               </tr>
                               <tr>
                                 <th scope="row">1</th>
                                 <td><p id="pot1"></p></td>
                               </tr>
                               <tr>
                                 <th scope="row">2</th>
                                 <td><p id="pot2"></p></td>
                               </tr>
                             </tbody>
                           </table>
                         </div>
                         <div class="card-body">
                           <button type="button" class="btn btn-primary" data-toggle="modal" data-target="#Pot-1">T1</button>
                           <button type="button" class="btn btn-primary" data-toggle="modal" data-target="#Pot-2">T2</button>
                         </div>
                       </div>
                     </div>
                   </div>
                 </div>
               </div>
               <!--Temperature Graph-->
               <div class="row ">
                 <div class="card border-light">
                   <div class="card-body">
                     <h3 class="card-title">Temperature graph</h3>
                     <div class="row justify-content-md-center">
                       <div class="col-md-9">
                         <div id="plot-temp"></div>
                       </div>
                       <div class="col-md-3 text-end">
                         <div class="card-body">
                           <table class="table table-hover" style="max-width:170px;">
                             <tbody>
                               <tr>
                                 <th scope="col"># Tx</th>
                                 <th scope="col">Temperature (°C)</th>
                               </tr>
                               <tr class="clickable-row" data-href="{% url 'url_tx_atrad' dev_conf.id 'tx1' %}">
                                 <th scope="row">1</th>
                                 <td><p id="temp1"></p></td>
                               </tr>
                               <tr class="clickable-row" data-href="{% url 'url_tx_atrad' dev_conf.id 'tx2' %}">
                                 <th scope="row">2</th>
                                 <td><p id="temp2"></p></td>
                               </tr>
                             </tbody>
                           </table>
                         </div>
                       </div>
                     </div>
                   </div>
                 </div>
               </div>
             </div>
             <!--Modales-->
             <div class="modal fade" id="Pot-1" role="dialog">
-              <div class="modal-dialog modal-lg" style="max-width:50%;min-width:750px">
+              <div class="modal-dialog modal-lg" style="max-width:50%;min-width:928px">
                 <div class="modal-content">
                   <div class="modal-header">
-                    <h4 class="modal-title">Potencia incidente - Transmisor 1</h4>
+                    <h4 class="modal-title">Incident Power - Transmitter 1 </h4>
                     <button type="button" class="close" data-dismiss="modal">&times;</button>
                   </div>
                   <div class="modal-body">
                     <div class="row">
                       <div class="col">
                         <div id="plot-pot-t1"></div>
                       </div>
                       <div class="col">
                         <table class="table" style="max-width: 150px;">
                           <tbody>
                             <tr>
                               <th scope="col"># Amp</th>
-                              <th scope="col">Potencia (kW)</th>
+                              <th scope="col">Power (kW)</th>
                             </tr>
                             <tr>
                               <th scope="row">P1</th>
                               <td><p id="pot1-1"></p></td>
                             </tr>
                             <tr>
                               <th scope="row">P2</th>
                               <td><p id="pot1-2"></p></td>
                             </tr>
                             <tr>
                               <th scope="row">P3</th>
                               <td><p id="pot1-3"></p></td>
                             </tr>
                             <tr>
                               <th scope="row">P4</th>
                               <td><p id="pot1-4"></p></td>
                             </tr>
                           </tbody>
                         </table>
                       </div>
                     </div>
                   </div>
                 </div>
               </div>
             </div>
             <div class="modal fade" id="Pot-2" role="dialog">
-              <div class="modal-dialog modal-lg" style="max-width:50%;min-width:750px">
+              <div class="modal-dialog modal-lg" style="max-width:50%;min-width:928px">
                 <div class="modal-content">
                   <div class="modal-header">
-                    <h4 class="modal-title">Potencia incidente - Transmisor 2</h4>
+                    <h4 class="modal-title">Incident Power - Transmitter 2</h4>
                     <button type="button" class="close" data-dismiss="modal">&times;</button>
                   </div>
                   <div class="modal-body">
                     <div class="row">
                       <div class="col">
                         <div id="plot-pot-t2"></div>
                       </div>
                       <div class="col">
                         <table class="table" style="max-width: 150px;">
                           <tbody>
                             <tr>
                               <th scope="col"># Amp</th>
-                              <th scope="col">Potencia (kW)</th>
+                              <th scope="col">Power (kW)</th>
                             </tr>
                             <tr>
                               <th scope="row">P1</th>
                               <td><p id="pot2-1"></p></td>
                             </tr>
                             <tr>
                               <th scope="row">P2</th>
                               <td><p id="pot2-2"></p></td>
                             </tr>
                             <tr>
                               <th scope="row">P3</th>
                               <td><p id="pot2-3"></p></td>
                             </tr>
                             <tr>
                               <th scope="row">P4</th>
                               <td><p id="pot2-4"></p></td>
                             </tr>
                           </tbody>
                         </table>
                       </div>
                     </div>
                   </div>
                 </div>
               </div>
             </div>
-            <script src="{% static 'js/atrad-conf.js' %}"></script>
+            <script src="{% static 'js/atrad-mainpage.js' %}"></script>
             {% endblock %}

apps/atrad/templates/atrad_tx.html +15 -9

             {% extends "base.html" %}
             {% load static %}
             {% block title %}ATRAD Tx{{id_tx}} Temperatures{% endblock %}
             {% block content-title %}{{title}}{% endblock %}
             {% block content-suptitle %}Tx {{id_tx}}{% endblock %}
             {% block extra-head %}
             <style>
               .panel-body {
                 background:#ffffff;}
               .panel-footer {
                 background:#ffffff;}
               .card-body {
                 padding-top: 1px;
                 padding-bottom: 1px;
               }
             </style>
             {% endblock %}
             {% block content-graph %}
             <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.3/jquery.min.js"></script>
             <script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/socket.io/4.4.1/socket.io.min.js"></script>
             <div class="container-fluid">
                 <!-- Temperatura generales -->
                 <div class="row ">
                   <div class="panel panel-default">
                       <div class="panel-heading">
-                        <h3 class="panel-title">Amplifiers</h3>
+                        <h3 class="panel-title">Amplifiers Temperature (°C)</h3>
                       </div>
                       <div class="panel-body">
                         <div class="card border-0">
                           <div class="row">
                             <div class="card-body">
                               <h5 class="card-title">Amplifier 1</h5>
                               <div id="plot-temp-1"></div>
                             </div>
                             <div class="card-body">
                               <h5 class="card-title">Amplifier 2</h5>
                               <div id="plot-temp-2"></div>
                             </div>
                             <div class="card-body">
                               <h5 class="card-title">Amplifier 3</h5>
                               <div id="plot-temp-3"></div>
                             </div>
                             <div class="card-body">
                               <h5 class="card-title">Amplifier 4</h5>
                               <div id="plot-temp-4"></div>
                             </div>
                           </div>
                         </div>
                       </div>
                   </div>
                 </div>
                 <div class="row">
                   <div class="panel panel-default">
                       <div class="panel-heading">
-                      <h3 class="panel-title">Controllers and combiners</h3>
+                      <h3 class="panel-title">Combiners Temperature °C</h3>
                       </div>
                       <div class="panel-body">
                         <div id="plot-temp-0"></div>
                       </div>
                   </div>
               </div>
             </div>
             <script>
                 $(document).ready(function() {
                   var socket = io.connect('http://' + document.domain + ':' + location.port);
                   socket.on('connect', function(data) {
                     console.log('Connecting... OK');
                     var basedata = JSON.parse('{{data|safe}}')
                     console.log(basedata);
-                    makePlot("plot-temp-0",4,["PC1","PC2","PC3","PC4"],[10,40]);
+                    makePlot("plot-temp-0",4,["PC1","PC2","PC3","PC4"],[10,40],basedata);
                     makePlot2("plot-temp-1",6,["PA1","PA2","PA3","PA4","PA5","PA6"],[10,40],basedata)
                     makePlot2("plot-temp-2",6,["PA1","PA2","PA3","PA4","PA5","PA6"],[10,40],basedata)
                     makePlot2("plot-temp-3",6,["PA1","PA2","PA3","PA4","PA5","PA6"],[10,40],basedata)
                     makePlot2("plot-temp-4",6,["PA1","PA2","PA3","PA4","PA5","PA6"],[10,40],basedata)
                   })
                   socket.on("temptx"+"{{id_tx}}", function(data) {
-                    var controllers = [data.temp[0][1],data.temp[1][1],data.temp[2][1],data.temp[3][1]]
+                    var combiners = [data.temp[0][8],data.temp[0][9],data.temp[2][8],data.temp[2][9]]
                     streamPlot2("plot-temp-0",data.time,controllers,4);
                     streamPlot2("plot-temp-1",data.time,data.temp[0].slice(2,8),6);
                     streamPlot2("plot-temp-2",data.time,data.temp[1].slice(2,8),6);
                     streamPlot2("plot-temp-3",data.time,data.temp[2].slice(2,8),6);
                     streamPlot2("plot-temp-4",data.time,data.temp[3].slice(2,8),6);
                   })
                 });
-                function makePlot(div, n=1, names=["", ""],ranges){
+                function makePlot(div, n=1, names=["", ""],ranges,data){
                   var plotDiv = document.getElementById(div);
                   var traces = [];
+                  var keys = ['combiner1','combiner2','combiner3','combiner4']
                   for (let i = 0; i < n; i++) {
-                    traces.push({x: [], y: [],mode: 'lines', name: names[i]});
+                    var x = [];
+                    var y = [];
+                    for(let j = 0;j < data.length; j++){
+                      x[j] = data[j].datetime;
+                      y[j] = data[j][keys[i]];
+                    }
+                    traces.push({x:x, y:y,mode: 'lines', name: names[i]});
                   }
-                  traces.push({x: [], y: [],mode: 'lines',line: {color:'rgb(219, 64, 82)',dash: 'dot',width: 2},name:"nominal",showlegend: false});
                   var yrange = ranges;
                   var layout = {
                     width: 505,
                     height: 300,
                     font: {size: 12},
                     margin: { t: 10, b:50, r:15 ,l:15},
                     xaxis: {
                       type: 'date'
                     },
                     yaxis: {
                       range: yrange,
                     },
                     legend: {"orientation": "h"},
                   };
                   var config = {responsive: true}
                   Plotly.newPlot(plotDiv, traces, layout,config);
                 };
-                function makePlot2(div, n=1, names=["", ""],ranges,data){
+                function makePlot2(div, n=1, names=["", ""],ranges,data,keys){
                   var plotDiv = document.getElementById(div);
                   var traces = [];
                   var keys = ['temp1','temp2','temp3','temp4','temp5','temp6']
                   for (let i = 0; i < n; i++) {
                     var x = [];
                     var y = [];
                     for(let j = 0;j < data.length; j++){
                       x[j] = data[j].datetime;
                       y[j] = data[j][keys[i]+'_'+div.charAt(10)];
                     }
                     traces.push({x:x, y:y,mode: 'lines', name: names[i]});
                   }
                   var yrange = ranges;
                   var layout = {
                     width: 505,
-                    height: 400,
+                    height: 300,
                     font: {size: 12},
                     margin: { t: 10, b:50, r:15 ,l:15},
                     xaxis: {
                       type: 'date'
                     },
                     yaxis: {
                       range: yrange,
                     },
                     legend: {"orientation": "h"},
                   };
                   var config = {responsive: true}
                   Plotly.newPlot(plotDiv, traces, layout,config);
                 };
                 function streamPlot2(div,x,y,cant){
                   var plotDiv = document.getElementById(div);
                   if (plotDiv.data[0].x.length > 8){
                     for(let i=0;i<cant;i++){
                       plotDiv.data[i].x = plotDiv.data[i].x.slice(-11)
                       plotDiv.data[i].y = plotDiv.data[i].y.slice(-11)
                     }
                   }
                   var tm = [];
                   var values = [];
                   var index = []
                   for(let i=0;i<cant;i++){
                     values[i]=[y[i]];
                     tm[i] = [x];
                     index[i] = i;
                   }
                   var data_update = {x: tm, y: values}
                   Plotly.extendTraces(plotDiv, data_update,index)
                 };
               </script>
             {% endblock %}

apps/atrad/views.py +13 -5

             from django.shortcuts import redirect, render, get_object_or_404
             from django.contrib import messages
             from django.http import HttpResponse
             from django.template.loader import get_template
             from apps.main.models import Experiment
             from .models import ATRADConfiguration, ATRADData
             from .forms import ATRADConfigurationForm, UploadFileForm
             from apps.main.views import sidebar
             import requests
             import json
             import os
             from django.http import JsonResponse
             from .mqtt import client as mqtt_client
             from radarsys.socketconfig import sio as sio
             from datetime import timedelta
+            from datetime import datetime
             def atrad_conf(request, id_conf):
                 conf = get_object_or_404(ATRADConfiguration, pk=id_conf)
                 ip=conf.device.ip_address
                 port=conf.device.port_address
                 kwargs = {}
                 kwargs['status'] = conf.device.get_status_display()
                 kwargs['dev_conf'] = conf
                 kwargs['dev_conf_keys'] = ['label',
                                            'topic']
                 kwargs['title'] = 'ATRAD Configuration'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Edit Configuration'
                 #kwargs['no_play'] = True
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'atrad_conf.html', kwargs)
             def atrad_tx(request, id_conf, id_tx):
                 kwargs = {}
                 kwargs['id_tx'] = id_tx[-1]
                 kwargs['title'] = 'Temperature Details'
                 kwargs['button'] = 'Edit Configuration'
-                time = ATRADData.objects.last().datetime
+                try:
+                    time = ATRADData.objects.last().datetime
+                except:
+                    time = datetime.now()
                 id_stx = (int(id_tx[-1])-1)*4+1
-                mydata = ATRADData.objects.filter(datetime__gte = (time-timedelta(hours=1)),nstx = id_stx).values('datetime','temp1_1','temp2_1','temp3_1','temp4_1','temp5_1','temp6_1',
+                mydata = ATRADData.objects.filter(datetime__gte = (time-timedelta(hours=1)),nstx = id_stx).values('datetime',
-                'temp1_2','temp2_2','temp3_2','temp4_2','temp5_2','temp6_2','temp1_3','temp2_3','temp3_3','temp4_3','temp5_3','temp6_3',
+                'temp1_1','temp2_1','temp3_1','temp4_1','temp5_1','temp6_1',
-                'temp1_4','temp2_4','temp3_4','temp4_4','temp5_4','temp6_4')
+                'temp1_2','temp2_2','temp3_2','temp4_2','temp5_2','temp6_2',
+                'temp1_3','temp2_3','temp3_3','temp4_3','temp5_3','temp6_3',
+                'temp1_4','temp2_4','temp3_4','temp4_4','temp5_4','temp6_4',
+                'combiner1','combiner2','combiner3','combiner4')
                 kwargs['data'] = json.dumps(list(mydata),default=str)
                 return render(request, 'atrad_tx.html', kwargs)
             def QuerytoStr(data):
                 time = data[0]
                 strdata = str(time)
                 return strdata
             def atrad_conf_edit(request, id_conf):
                 conf = get_object_or_404(ATRADConfiguration, pk=id_conf)
                 if request.method=='GET':
                     form = ATRADConfigurationForm(instance=conf)
                 if request.method=='POST':
                     form = ATRADConfigurationForm(request.POST, instance=conf)
                     if form.is_valid():
                         if conf.topic == None:  conf.topic = 0
                         conf = form.save(commit=False)
                         if conf.verify_frequencies():
                             conf.save()
                             return redirect('url_atrad_conf', id_conf=conf.id)
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['form'] = form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Save'
                 return render(request, 'atrad_conf_edit.html', kwargs)
             def publish_message(request):
                 rc, mid = mqtt_client.publish('test/data2',1)
                 return JsonResponse({'code1': 'HIKA', 'code2': 'LUCAS'})
             def monitor(request):
                 kwargs = {'no_sidebar': True}
                 return render(request, 'monitor.html', kwargs)
             def atrad_prueba(request):
                 keys = ['id','temp1','temp2','temp3','temp4','temp5','temp6']
                 time = ATRADData.objects.last().datetime
                 mydata = ATRADData.objects.filter(datetime__gte = (time-timedelta(hours=1))).values('id','temp1_1','temp2_1','temp3_1','temp4_1','temp5_1','temp6_1',
                 'temp1_2','temp2_2','temp3_2','temp4_2','temp5_2','temp6_2','temp1_3','temp2_3','temp3_3','temp4_3','temp5_3','temp6_3',
                 'temp1_4','temp2_4','temp3_4','temp4_4','temp5_4','temp6_4')
                 template = get_template('prueba.html')
                 context = {
                     'last' : time,
                     'temps': mydata,
                     'keys' : keys,
                 }
                 return HttpResponse(template.render(context, request))
             @sio.on('connection-bind')
             def atrad_connection_bind(sid, data):
                 print("sid:",sid,"data",data)
             @sio.on('disconnect')
             def atrad_disconnect(sid):
                 print("Disconnected")
             @sio.event
             def atrad_control_event(sid,message):
-                mqtt_client.publish('test/data2', json.dumps(message))
  No newline at end of file
+                mqtt_client.publish(os.environ.get('MQTT_TOPIC_ATRAD_CONTROL', 'atrad/test2'), json.dumps(message))
  No newline at end of file

apps/jars/models.py +1 -1

             import json
             import requests
             from django.db import models
             from django.core.validators import MinValueValidator, MaxValueValidator
             from django.urls import reverse
             from apps.main.models import Configuration
             from apps.main.utils import Params
             from .utils import create_jarsfiles
             # Create your models here.
             EXPERIMENT_TYPE = (
                 (0, 'RAW_DATA'),
                 (1, 'PDATA'),
             )
             DATA_TYPE = (
                 (0, 'SHORT'),
                 (1, 'FLOAT'),
             )
             DECODE_TYPE = (
                 (0, 'None'),
                 (1, 'TimeDomain'),
                 (2, 'FreqDomain'),
                 (3, 'InvFreqDomain'),
             )
             FILTER = '{"id":1, "clock": 60, "multiplier": 5, "frequency": 49.92, "f_decimal":	721554506, "fir": 2, "cic_2": 12, "cic_5": 25}'
             class JARSFilter(models.Model):
                 JARS_NBITS  = 32
                 name        = models.CharField(verbose_name='Name', max_length=60, unique=True, default='')
                 clock       = models.FloatField(verbose_name='Clock In (MHz)', validators=[
                                           MinValueValidator(5), MaxValueValidator(75)], null=True, default=60)
                 multiplier  = models.PositiveIntegerField(verbose_name='Multiplier', validators=[
                                                          MinValueValidator(1), MaxValueValidator(20)], default=5)
                 frequency   = models.FloatField(verbose_name='Frequency (MHz)', validators=[
                                               MaxValueValidator(150)], null=True, default=49.9200)
                 f_decimal   = models.BigIntegerField(verbose_name='Frequency (Decimal)', validators=[
                                                    MinValueValidator(-9223372036854775808), MaxValueValidator(2**JARS_NBITS-1)], null=True, default=721554505)
                 cic_2       = models.PositiveIntegerField(verbose_name='CIC2', validators=[
                                                     MinValueValidator(2), MaxValueValidator(100)], default=10)
                 scale_cic_2 = models.PositiveIntegerField(verbose_name='Scale CIC2', validators=[
                                                           MinValueValidator(0), MaxValueValidator(6)], default=1)
                 cic_5       = models.PositiveIntegerField(verbose_name='CIC5', validators=[
                                                     MinValueValidator(1), MaxValueValidator(100)], default=1)
                 scale_cic_5 = models.PositiveIntegerField(verbose_name='Scale CIC5', validators=[
                                                           MinValueValidator(0), MaxValueValidator(20)], default=5)
                 fir         = models.PositiveIntegerField(verbose_name='FIR', validators=[
                                                   MinValueValidator(1), MaxValueValidator(100)], default=6)
                 scale_fir   = models.PositiveIntegerField(verbose_name='Scale FIR', validators=[
                                                         MinValueValidator(0), MaxValueValidator(7)], default=3)
                 number_taps = models.PositiveIntegerField(verbose_name='Number of taps', validators=[
                                                           MinValueValidator(1), MaxValueValidator(256)], default=4)
                 taps        = models.CharField(verbose_name='Taps', max_length=1600, default='0')
                 class Meta:
                     db_table = 'jars_filters'
                 def __unicode__(self):
                     return u'%s' % (self.name)
                 def jsonify(self):
                     data    = {}
                     ignored = ()
                     for field in self._meta.fields:
                         if field.name in ignored:
                             continue
                         data[field.name] = field.value_from_object(self)
                     return data
                 def parms_to_dict(self):
                     parameters = {}
                     parameters['name']       = self.name
                     parameters['clock']      = float(self.clock)
                     parameters['multiplier'] = int(self.multiplier)
                     parameters['frequency']  = float(self.frequency)
                     parameters['f_decimal']  = int(self.frequency)
                     parameters['fir']        = int(self.fir)
                     parameters['cic_2']      = int(self.cic_2)
                     parameters['cic_5']      = int(self.cic_5)
                     return parameters
                 def dict_to_parms(self, parameters):
                     self.name       = parameters['name']
                     self.clock      = parameters['clock']
                     self.multiplier = parameters['multiplier']
                     self.frequency  = parameters['frequency']
                     self.f_decimal  = parameters['f_decimal']
                     self.fir        = parameters['fir']
                     self.cic_2      = parameters['cic_2']
                     self.cic_5      = parameters['cic_5']
                 def dict_to_parms_new(self, parameters):
                     self.name        = parameters['name']
                     self.clock       = parameters['clock']
                     self.multiplier  = parameters['multiplier']
                     self.frequency   = parameters['frequency']
                     self.f_decimal   = parameters['f_decimal']
                     self.fir         = parameters['fir']
                     self.cic_2       = parameters['cic_2']
                     self.cic_5       = parameters['cic_5']
                     self.scale_fir   = parameters['scale_fir']
                     self.scale_cic_2 = parameters['scale_cic_2']
                     self.scale_cic_5 = parameters['scale_cic_5']
                     self.number_taps = parameters['number_taps']
                     self.taps        = parameters['taps']
             class JARSConfiguration(Configuration):
                 ADC_RESOLUTION   = 8
                 PCI_DIO_BUSWIDTH = 32
                 HEADER_VERSION   = 1103
                 BEGIN_ON_START   = True
                 REFRESH_RATE     = 1
                 exp_type         = models.PositiveIntegerField(
                     verbose_name='Experiment Type', choices=EXPERIMENT_TYPE, default=0)
                 cards_number     = models.PositiveIntegerField(verbose_name='Number of Cards', validators=[
                                                            MinValueValidator(1), MaxValueValidator(4)], default=1)
                 channels_number  = models.PositiveIntegerField(verbose_name='Number of Channels', validators=[
                                                               MinValueValidator(1), MaxValueValidator(8)], default=5)
                 channels         = models.CharField(
                     verbose_name='Channels', max_length=15, default='1,2,3,4,5')
                 data_type        = models.PositiveIntegerField(
                     verbose_name='Data Type', choices=DATA_TYPE, default=0)
                 raw_data_blocks  = models.PositiveIntegerField(
                     verbose_name='Raw Data Blocks', validators=[MaxValueValidator(5000)], default=60)
                 profiles_block   = models.PositiveIntegerField(
                     verbose_name='Profiles Per Block', default=400)
                 acq_profiles     = models.PositiveIntegerField(
                     verbose_name='Acquired Profiles', default=400)
                 ftp_interval     = models.PositiveIntegerField(
                     verbose_name='FTP Interval', default=60)
                 fftpoints        = models.PositiveIntegerField(
                     verbose_name='FFT Points', default=16)
                 cohe_integr_str  = models.PositiveIntegerField(
                     verbose_name='Coh. Int. Stride', validators=[MinValueValidator(1)], default=30)
                 cohe_integr      = models.PositiveIntegerField(
                     verbose_name='Coherent Integrations', validators=[MinValueValidator(1)], default=30)
                 incohe_integr    = models.PositiveIntegerField(
                     verbose_name='Incoherent Integrations', validators=[MinValueValidator(1)], default=30)
                 decode_data      = models.PositiveIntegerField(
                     verbose_name='Decode Data', choices=DECODE_TYPE, default=0)
                 post_coh_int     = models.BooleanField(
                     verbose_name='Post Coherent Integration', default=False)
                 spectral_number  = models.PositiveIntegerField(
                     verbose_name='# Spectral Combinations', validators=[MinValueValidator(1)], default=1)
                 spectral         = models.CharField(
                     verbose_name='Combinations', max_length=5000, default='[0, 0],')
                 create_directory = models.BooleanField(
                     verbose_name='Create Directory Per Day', default=True)
                 include_expname  = models.BooleanField(
                     verbose_name='Experiment Name in Directory', default=False)
                 #view_raw_data    = models.BooleanField(verbose_name='View Raw Data', default=True)
                 save_ch_dc       = models.BooleanField(
                     verbose_name='Save Channels DC', default=True)
                 save_data        = models.BooleanField(verbose_name='Save Data', default=True)
                 filter_parms     = models.CharField(
                     max_length=10000, default=FILTER)
                 filter           = models.ForeignKey(
                     'JARSFilter', verbose_name='Filter', null=True, blank=True, on_delete=models.CASCADE)
                 class Meta:
                     db_table = 'jars_configurations'
                 def filter_resolution(self):
                     filter_parms = json.loads(self.filter_parms)
                     clock        = float(filter_parms['clock'])
                     cic_2        = filter_parms['cic_2']
                     cic_5        = filter_parms['cic_5']
                     fir          = filter_parms['fir']
                     resolution   = round((clock/(cic_2*cic_5*fir)), 2)
                     return resolution
                 def dict_to_parms(self, params, id=None):
                     if id is not None:
                         data = Params(params).get_conf(id_conf=id)
                     else:
                         data = Params(params).get_conf(dtype='jars')
                         data['filter_parms'] = params['filter_parms']
                     # self.name = data['name']
                     self.exp_type = data['exp_type']
                     #----PDATA----
                     if self.exp_type == 1:
                         self.incohe_integr   = data['incohe_integr']
                         self.spectral_number = data['spectral_number']
                         self.spectral        = data['spectral']
                         self.fftpoints       = data['fftpoints']
                         self.save_ch_dc      = data['save_ch_dc']
                     else:
                         self.raw_data_blocks = data['raw_data_blocks']
                     #----PDATA----
                     self.cards_number    = data['cards_number']
                     self.channels_number = data['channels_number']
                     self.channels        = data['channels']
                     self.data_type       = data['data_type']
                     self.profiles_block  = data['profiles_block']
                     self.acq_profiles    = data['acq_profiles']
                     self.ftp_interval    = data['ftp_interval']
                     self.cohe_integr_str = data['cohe_integr_str']
                     self.cohe_integr     = data['cohe_integr']
                     #----DECODE----
                     self.decode_data  = data['decode_data']
                     self.post_coh_int = data['post_coh_int']
                     #----DECODE----
                     self.create_directory = data['create_directory']
                     self.include_expname  = data['include_expname']
                     self.save_data        = data['save_data']
                     self.filter_parms     = json.dumps(data['filter_parms'])
                     self.save()
                 def parms_to_text(self, file_format='jars'):
                     data = self.experiment.parms_to_dict()
                     for key in data['configurations']['allIds']:
                         if data['configurations']['byId'][key]['device_type'] in ('dds', 'cgs'):
                             data['configurations']['allIds'].remove(key)
                             data['configurations']['byId'].pop(key)
                         elif data['configurations']['byId'][key]['device_type'] == 'jars':
                             data['configurations']['byId'][key] = self.parms_to_dict(
                             )['configurations']['byId'][str(self.pk)]
                         elif data['configurations']['byId'][key]['device_type'] == 'rc':
                                 data['configurations']['byId'][key]['pulses'] = ''
                                 data['configurations']['byId'][key]['delays'] = ''
                     rc_ids = [pk for pk in data['configurations']['allIds']
                               if data['configurations']['byId'][pk]['device_type'] == 'rc']
                     mix_ids = [pk for pk in rc_ids if data['configurations']
                                ['byId'][pk]['mix']]
                     if mix_ids:
                         params = data['configurations']['byId'][mix_ids[0]]['parameters']
                         rc = data['configurations']['byId'][params.split(
                             '-')[0].split('|')[0]]
                         rc['mix'] = True
                         data['configurations']['byId'][rc['id']] = rc
                     elif len(rc_ids) == 0:
                         self.message = 'File needs RC configuration'
                         return ''
                     json_data = json.dumps(data)
                     racp_file, filter_file = create_jarsfiles(json_data)
                     if file_format == 'racp':
                         return racp_file
                     return filter_file
                 def request(self, cmd, method='get', **kwargs):
                     req = getattr(requests, method)(self.device.url(cmd), **kwargs)
                     payload = req.json()
                     return payload
                 def status_device(self):
                     try:
                         payload = self.request('status',
                                                params={'name': self.experiment.name})
                         self.device.status = payload['status']
                         self.device.save()
                         self.message = payload['message']
                     except Exception as e:
                         self.device.status = 0
                         self.message = str(e)
                         self.device.save()
                         return False
                     return True
                 def stop_device(self):
                     # Se crea el modo ocupado para una vez inicia el STOP
                     self.device.status = 5
                     self.device.save()
                     # Por si se demora deteniendo, que su estado sea busy
                     try:
                         payload = self.request('stop', 'post')
                         self.device.status = payload['status']
                         self.device.save()
                         self.message = payload['message']
                     except Exception as e:
                         self.device.status = 0
                         self.message = str(e)
                         self.device.save()
                         return False
                     return True
                 def read_device(self):
                     try:
                         payload = self.request(
                             'read', params={'name': self.experiment.name})
                         self.message = 'Configuration loaded'
                     except:
                         self.device.status = 0
                         self.device.save()
                         self.message = 'Could not read JARS configuration.'
                         return False
                     return payload
                 def write_device(self):
                     if self.device.status == 3:
                         self.message = 'Could not configure device. Software Acquisition is running'
                         print('Could not configure device. Software Acquisition is running')
                         return False
                     data = self.experiment.parms_to_dict()
                     #print(data)
                     for key in data['configurations']['allIds']:
                         if data['configurations']['byId'][key]['device_type'] in ('dds', 'cgs'):
                             data['configurations']['allIds'].remove(key)
                             data['configurations']['byId'].pop(key)
                         elif data['configurations']['byId'][key]['device_type'] == 'rc':
                                 data['configurations']['byId'][key]['pulses'] = ''
                                 data['configurations']['byId'][key]['delays'] = ''
                     rc_ids = [pk for pk in data['configurations']['allIds']
                               if data['configurations']['byId'][pk]['device_type'] == 'rc']
                     if len(rc_ids) == 0:
                         self.message = 'Missing RC configuration'
                         return False
                     json_data = json.dumps(data)
-                    print("STATUS:", self.device.status,flush=True)
+                    # print("STATUS:", self.device.status,flush=True)
                     try:
                         payload = self.request('write', 'post', json=json_data)
                         self.device.status = payload['status']
                         self.message = payload['message']
                         self.device.save()
                         if self.device.status == 1:
                             return False
                     except Exception as e:
                         self.device.status = 0
                         self.message = str(e)
                         self.device.save()
                         return False
                     return True
                 def start_device(self):
                     try:
                         payload = self.request('start', 'post',
                                                json={'name': self.experiment.name})
                         self.device.status = payload['status']
                         self.message = payload['message']
                         self.device.save()
                         if self.device.status == 1:
                             return False
                     except Exception as e:
                         self.device.status = 0
                         self.message = str(e)
                         self.device.save()
                         return False
                     return True
                 def get_log(self):
                     payload = None
                     try:
                         payload = requests.get(self.device.url('get_log'), params={
                                                'name': self.experiment.name})
                     except:
                         self.device.status = 0
                         self.device.save()
                         self.message = 'Jars API is not running.'
                         return False
                     self.message = 'Jars API is running'
                     return payload
                 def update_from_file(self, filename):
                     f = JARSFile(filename)
                     self.dict_to_parms(f.data)
                     self.save()
                 def get_absolute_url_import(self):
                     return reverse('url_import_jars_conf', args=[str(self.id)])
                 def get_absolute_url_read(self):
                     return reverse('url_read_jars_conf', args=[str(self.id)])
                 def get_absolute_url_log(self):
                     return reverse('url_get_jars_log', args=[str(self.id)])

apps/main/management/commands/scheduler.py ~~apps/main/management/commands/hello.py~~ renamed 0 0

NO CONTENT: file renamed from apps/main/management/commands/hello.py to apps/main/management/commands/scheduler.py

apps/main/models.py 0 -3

             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'),
                              (5, 'Busy')
                          )
             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
                              (5,'Busy'),
                          )
             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
                     '''
                     self.status=5 #Busy
                     self.save()
                     print("Realizando operación. \nEXPERIMENT STATUS : {}".format(self.status))
                     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
                     for conf in confs:
                         print("--------------",flush=True)
                         print("STATUS: {}".format(conf.device.status))
                         print("Stop ",conf.name,flush=True)
                         if conf.stop_device() ==False:
                             print("Falló Stop ",conf.name)
                             print("Cancelando Campaña...",flush=True)
                             return 0
                         print("Write ",conf.name,flush=True)
                         if conf.write_device() ==False:
                             print("Falló Write ",conf.name)
                             print("Cancelando Campaña...",flush=True)
                             return 0
                         print("Save",conf.name,flush=True)
                         conf.device.conf_active = conf.pk
                         conf.device.save()
                         print("Start",conf.name,flush=True)
                         if conf.start_device()==False:
                             print("Falló Start ",conf.name)
                             print("Cancelando Campaña...",flush=True)
                             return 0
                         print("--- CONFIGURACIÓN EXITOSA ---",flush=True)
                         time.sleep(1)
                     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'
-                    print("BUENAS SEÑALES??? NO LO CREO2",flush=True)
                     return False
                 def start_device(self):
                     self.message = 'Function not implemented'
-                    print("BUENAS SEÑALES??? NO LO CREO",flush=True)
                     return False
                 def write_device(self, parms):
                     self.message = 'Function not implemented'
-                    print("BUENAS SEÑALES??? NO LO CREO3",flush=True)
                     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_mqtt_url(self):
                     print("----------------- {} ----------------------".format(self.device.device_type.name),flush=True)
                     if self.device.device_type.name=='abs':
                         return reverse('url_%s_conf_mqtt' % self.device.device_type.name, args=[str(self.id)])
                     else:
                         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/rc/views.py +1 -9

             import json
             from django.contrib import messages
             from django.utils.safestring import mark_safe
             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from django.contrib.auth.decorators import login_required
             from apps.main.models import Experiment, Device
             from apps.main.views import sidebar
             from .models import RCConfiguration, RCLine, RCLineType, RCLineCode, RCClock
             from .forms import RCConfigurationForm, RCLineForm, RCLineViewForm, RCLineEditForm, RCImportForm, RCLineCodesForm, RCClockForm
             def conf(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 lines = RCLine.objects.filter(rc_configuration=conf).order_by('channel')
                 clk = RCClock.objects.filter(rc_configuration=conf).first()
                 if clk is None:
                     clk = RCClock(rc_configuration=conf)
                     clk.save()
                 for line in lines:
                     params = json.loads(line.params)
                     line.form = RCLineViewForm(extra_fields=params, line=line)
                     if 'params' in params:
                         line.subforms = [RCLineViewForm(extra_fields=fields, line=line, subform=True) for fields in params['params']]
                 kwargs = {}
                 kwargs['clock'] = clk
                 kwargs['dev_conf'] = conf
                 kwargs['rc_lines'] = lines
                 kwargs['dev_conf_keys'] = ['ipp_unit', 'ntx', 'clock_divider', 'clock',
                                            'time_before', 'time_after', 'sync', 'sampling_reference',
                                            'control_tx', 'control_sw']
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'Detail'
                 kwargs['button'] = 'Edit Configuration'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'rc_conf.html', kwargs)
             @login_required
             def conf_edit(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 clock = RCClock.objects.get(rc_configuration=conf)
                 lines = RCLine.objects.filter(rc_configuration=conf).order_by('channel')
                 for line in lines:
                     params = json.loads(line.params)
                     #print(params)
                     line.form = RCLineEditForm(conf=conf, line=line, extra_fields=params)
                     line.subform = False
                     if 'params' in params:
                         line.subforms = [RCLineEditForm(extra_fields=fields, line=line, subform=i) for i, fields in enumerate(params['params'])]
                         line.subform = True
                     print(params)
                     print("fin de sub carga de params")
                 #print("fin de carga de params")
                 if request.method=='GET':
                     print("GET case")
                     form = RCConfigurationForm(instance=conf)
                     form_clock = RCClockForm(instance=clock)
                 elif request.method=='POST':
                     #print("ingreso a post conf edit")
                     line_data = {}
                     conf_data = {}
                     clock_data = {}
                     extras = []
                     print("Inicio impresion POST#####")
                     print(request.POST.items)
                     print("Fin impresion de POST items#####")
                     #classified post fields
                     for label,value in request.POST.items():
                         if label=='csrfmiddlewaretoken':
                             continue
                         if label.count('|')==0:
                             if label in ('mode', 'multiplier', 'divisor', 'reference', 'frequency'):
                                 clock_data[label] = value
                             else:
                                 conf_data[label] = value
                             continue
                         elif label.split('|')[0]!='-1':
                             extras.append(label)
                             continue
                         #print(label)
                         x, pk, name = label.split('|')
                         if name=='codes':
                             value = [s for s in value.split('\r\n') if s]
                         if pk in line_data:
                             line_data[pk][name] = value
                         else:
                             line_data[pk] = {name:value}
                         #print(line_data[pk])
                     #update conf
                     form_clock = RCClockForm(clock_data, instance=clock)
                     form = RCConfigurationForm(conf_data, instance=conf)
                     #print(request.POST.items())
                     if form_clock.is_valid() and form.is_valid():
                         form_clock.save()
                         form.save()
                         #update lines fields
                         extras.sort()
                         #print("Inicio extras")
                         #print(extras)
                         #print("Fin extras")
                         for label in extras:
                             x, pk, name = label.split('|')
                             if pk not in line_data:
                                 line_data[pk] = {}
                             if 'params' not in line_data[pk]:
                                 line_data[pk]['params'] = []
                             if len(line_data[pk]['params'])<int(x)+1:
                                 line_data[pk]['params'].append({})
                             line_data[pk]['params'][int(x)][name] = float(request.POST[label])
                         for pk, params in line_data.items():
                             line = RCLine.objects.get(pk=pk)
                             if line.line_type.name in ('windows', 'prog_pulses'):
                                 if 'params' not in params:
                                     params['params'] = []
                             line.params = json.dumps(params)
                             #print(line.params)
                             line.save()
                         #update pulses field
                         conf.update_pulses()
                         messages.success(request, 'RC Configuration successfully updated')
                         return redirect(conf.get_absolute_url())
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 kwargs['form'] = form
                 kwargs['form_clock'] = form_clock
                 kwargs['rc_lines'] = lines
                 kwargs['edit'] = True
                 kwargs['title'] = 'RC Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 return render(request, 'rc_conf_edit.html', kwargs)
             def add_line(request, conf_id, line_type_id=None, code_id=None):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 if request.method=='GET':
                     if line_type_id:
                         line_type = get_object_or_404(RCLineType, pk=line_type_id)
                         if code_id:
                             form = RCLineForm(initial={'rc_configuration':conf_id, 'line_type': line_type_id, 'code_id': code_id},
                                               extra_fields=json.loads(line_type.params))
                         else:
                             form = RCLineForm(initial={'rc_configuration':conf_id, 'line_type': line_type_id},
                                               extra_fields=json.loads(line_type.params))
                     else:
                         line_type = {'id':0}
                         form = RCLineForm(initial={'rc_configuration':conf_id})
                 if request.method=='POST':
                     line_type = get_object_or_404(RCLineType, pk=line_type_id)
                     form = RCLineForm(request.POST,
                                       extra_fields=json.loads(line_type.params))
                     if form.is_valid():
                         form.save()
                         form.instance.update_pulses()
                         return redirect('url_edit_rc_conf', conf.id)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'RC Configuration'
                 kwargs['suptitle'] = 'Add Line'
                 kwargs['button'] = 'Add'
                 kwargs['previous'] = conf.get_absolute_url_edit()
                 kwargs['dev_conf'] = conf
                 kwargs['line_type'] = line_type
                 return render(request, 'rc_add_line.html', kwargs)
             def edit_codes(request, conf_id, line_id, code_id=None):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 line = get_object_or_404(RCLine, pk=line_id)
                 params = json.loads(line.params)
                 if request.method=='GET':
                     if code_id:
                         code = get_object_or_404(RCLineCode, pk=code_id)
                         form = RCLineCodesForm(instance=code)
                     else:
                         initial = {'code': params['code'],
                                    'codes': params['codes'] if 'codes' in params else [],
                                    'number_of_codes': len(params['codes']) if 'codes' in params else 0,
                                    'bits_per_code': len(params['codes'][0]) if 'codes' in params else 0,
                                    }
                         form = RCLineCodesForm(initial=initial)
                 if request.method=='POST':
                     form = RCLineCodesForm(request.POST)
                     if form.is_valid():
                         params['code'] = request.POST['code']
                         params['codes'] = [s for s in request.POST['codes'].split('\r\n') if s]
                         line.params = json.dumps(params)
                         line.save()
                         messages.success(request, 'Line: "%s" has been updated.'  % line)
                         return redirect('url_edit_rc_conf', conf.id)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = line
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 kwargs['dev_conf'] = conf
                 kwargs['previous'] = conf.get_absolute_url_edit()
                 kwargs['line'] = line
                 return render(request, 'rc_edit_codes.html', kwargs)
             def add_subline(request, conf_id, line_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 line = get_object_or_404(RCLine, pk=line_id)
                 if request.method == 'POST':
                     if line:
                         params = json.loads(line.params)
                         subparams = json.loads(line.line_type.params)
                         if 'params' in subparams:
                             dum = {}
                             for key, value in subparams['params'].items():
                                 dum[key] = value['value']
                             params['params'].append(dum)
                             line.params = json.dumps(params)
                             line.save()
                         return redirect('url_edit_rc_conf', conf.id)
                 kwargs = {}
                 kwargs['title'] = 'Add new'
                 kwargs['suptitle'] = '%s to %s' % (line.line_type.name, line)
                 return render(request, 'confirm.html', kwargs)
             def remove_line(request, conf_id, line_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 line = get_object_or_404(RCLine, pk=line_id)
                 if request.method == 'POST':
                     if line:
                         try:
                             channel = line.channel
                             line.delete()
                             for ch in range(channel+1, RCLine.objects.filter(rc_configuration=conf).count()+1):
                                 l = RCLine.objects.get(rc_configuration=conf, channel=ch)
                                 l.channel = l.channel-1
                                 l.save()
                             messages.success(request, 'Line: "%s" has been deleted.'  % line)
                         except:
                             messages.error(request, 'Unable to delete line: "%s".' % line)
                     return redirect('url_edit_rc_conf', conf.id)
                 kwargs = {}
                 kwargs['object'] = line
                 kwargs['delete'] = True
                 kwargs['title'] = 'Delete'
                 kwargs['suptitle'] = 'Line'
                 kwargs['previous'] = conf.get_absolute_url_edit()
                 return render(request, 'confirm.html', kwargs)
             def remove_subline(request, conf_id, line_id, subline_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 line = get_object_or_404(RCLine, pk=line_id)
                 if request.method == 'POST':
                     if line:
                         params = json.loads(line.params)
                         params['params'].remove(params['params'][int(subline_id)-1])
                         line.params = json.dumps(params)
                         line.save()
                         return redirect('url_edit_rc_conf', conf.id)
                 kwargs = {}
                 kwargs['object'] = line
                 kwargs['object_name'] = line.line_type.name
                 kwargs['delete_view'] = True
                 kwargs['title'] = 'Confirm delete'
                 return render(request, 'confirm.html', kwargs)
             def update_lines_position(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 print("ingreso a update_lines_position")
                 if request.method=='POST':
                     ch = 0
                     for item in request.POST['items'].split('&'):
                         line = RCLine.objects.get(pk=item.split('=')[-1])
                         line.channel = ch
                         line.save()
                         ch += 1
                     lines = RCLine.objects.filter(rc_configuration=conf).order_by('channel')
                     for line in lines:
                         params = json.loads(line.params)
                         print(params)
                         print("Fin de impresion_lines_position")
                         line.form = RCLineEditForm(conf=conf, line=line, extra_fields=params)
                         if 'params' in params:
                             line.subform = True
                             line.subforms = [RCLineEditForm(extra_fields=fields, line=line, subform=i) for i, fields in enumerate(params['params'])]
                     html = render(request, 'rc_lines.html', {'dev_conf':conf, 'rc_lines':lines, 'edit':True})
                     #html = render('rc_lines.html', {'dev_conf':conf, 'rc_lines':lines, 'edit':True},request)
                     data = {'html': html.content.decode('utf8')}
                     return HttpResponse(json.dumps(data), content_type="application/json")
                 return redirect('url_edit_rc_conf', conf.id)
             def import_file(request, conf_id):
-                # print("HOLA",flush=True)
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
-                # print("HOLA2",flush=True)
                 if request.method=='POST':
                     form = RCImportForm(request.POST, request.FILES)
-                    # print("HOLA3",flush=True)
                     if form.is_valid():
-                        #print("HOLA4",flush=True)
                         # try:
-                        #print("HOLA5",flush=True)
+                        data = conf.import_from_file(request.FILES['file_name'])
-                        data = conf.import_from_file(request.FILES['file_name'])
-                        #print("HOLA6",flush=True)
                         conf.dict_to_parms(data)
-                        #print("1",flush=True)
                         conf.update_pulses()
-                        #print("2",flush=True)
                         messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name'])
                         return redirect(conf.get_absolute_url_edit())
                         # except Exception as e:
                         #     messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], repr(e)))
                 else:
                     messages.warning(request, 'Your current configuration will be replaced')
                     form = RCImportForm()
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'RC Configuration'
                 kwargs['suptitle'] = 'Import file'
                 kwargs['button'] = 'Upload'
                 kwargs['previous'] = conf.get_absolute_url()
                 return render(request, 'rc_import.html', kwargs)
             def plot_pulses(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 km = True if 'km' in request.GET else False
                 script, div = conf.plot_pulses(km=km)
                 kwargs = {}
                 kwargs['no_sidebar'] = True
                 kwargs['title'] = 'RC Pulses'
                 kwargs['suptitle'] = conf.name
                 kwargs['div'] = mark_safe(div)
                 kwargs['script'] = mark_safe(script)
                 kwargs['units'] = conf.km2unit
                 kwargs['kms'] = 1/conf.km2unit
                 if km:
                     kwargs['km_selected'] = True
                 if 'json' in request.GET:
                     return HttpResponse(json.dumps({'div':mark_safe(div), 'script':mark_safe(script)}), content_type="application/json")
                 else:
                     return render(request, 'rc_pulses.html', kwargs)
             def plot_pulses2(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 km = True if 'km' in request.GET else False
                 script, div = conf.plot_pulses2(km=km)
                 kwargs = {}
                 kwargs['no_sidebar'] = True
                 kwargs['title'] = 'RC Pulses'
                 kwargs['suptitle'] = conf.name
                 kwargs['div'] = mark_safe(div)
                 kwargs['script'] = mark_safe(script)
                 kwargs['units'] = conf.km2unit
                 kwargs['kms'] = 1/conf.km2unit
                 if km:
                     kwargs['km_selected'] = True
                 if 'json' in request.GET:
                     return HttpResponse(json.dumps({'div':mark_safe(div), 'script':mark_safe(script)}), content_type="application/json")
                 else:
                     return render(request, 'rc_pulses.html', kwargs)
             def conf_raw(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 raw = conf.write_device(raw=True)
                 return HttpResponse(raw, content_type='application/json')

docker-compose.yml +2 -2

             version: '3'
             services:
              # Django app
               radarsys:
                 container_name: 'radarsys'
                 build: .
                 restart: always
                 image: radarsys
                 ports:
                   - 8000:8000
                 env_file: .env
                 links:
                   - radarsys-postgres
                 volumes:
                   - './:/radarsys'
                   - '${DOCKER_DATA}/static:/radarsys/static'
                 labels:
                   ofelia.enabled: "true"
                   # ofelia.job-exec.restart-reception.schedule: "0 1/5 * * * *"
                   ofelia.job-exec.test.schedule: "@every 5s"
-                  ofelia.job-exec.test.command: "python manage.py hello"
+                  ofelia.job-exec.test.command: "python manage.py scheduler"
                   # ofelia.job-exec.restart-pedestal.schedule: "0 2/10 * * * *"
                   # ofelia.job-exec.restart-pedestal.command: "python manage.py restart_pedestal"
                   # ofelia.job-exec.restart-experiment.schedule: "@midnight"
                   # ofelia.job-exec.restart-experiment.command: "python manage.py restart_experiment"
                 depends_on:
                   - radarsys-postgres
               # PostgreSQL
               radarsys-postgres:
                 container_name: 'radarsys-postgres'
                 build: ./postgres/
                 volumes:
                   - ./postgres/docker-entrypoint-initdb.d:/docker-entrypoint-initdb.d
                   - pgdata:/var/lib/postgresql/data
                 ports:
                  - 5432:5432
                 expose:
                   - 5432
                 env_file: .env
               #Web Server
               radarsys-nginx:
                 container_name: 'radarsys-nginx'
                 restart: always
                 build: ./nginx/
                 ports:
-                  - '0.0.0.0:8086:80'
+                  - '0.0.0.0:80:80'
                 volumes_from:
                   - radarsys
                 links:
                   - radarsys:radarsys
                 depends_on:
                   - radarsys
               #Ofelia Scheduler
               radarsys-job:
                 container_name: 'radarsys-job'
                 image: mcuadros/ofelia:v0.3.6
                 depends_on:
                   - radarsys
                 # networks:
                 #   - backend_sirm
                 command: daemon --docker
                 volumes:
                   - /var/run/docker.sock:/var/run/docker.sock:ro
                 logging:
                   driver: "json-file"
                   options:
                     max-size: "12m"
             volumes:
               pgdata:
                 driver: local

radarsys/settings.py +1 0

             """
             Django settings for radarsys project.
             Generated by 'django-admin startproject' using Django 1.8.6.
             For more information on this file, see
             https://docs.djangoproject.com/en/1.8/topics/settings/
             For the full list of settings and their values, see
             https://docs.djangoproject.com/en/1.8/ref/settings/
             """
             # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
             import os
             BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
             # Quick-start development settings - unsuitable for production
             # See https://docs.djangoproject.com/en/1.8/howto/deployment/checklist/
             # SECURITY WARNING: keep the secret key used in production secret!
             SECRET_KEY = 'xshb$k5fc-+j16)cvyffj&9u__0q3$l!hieh#+tbzqg)*f^km0'
             # SECURITY WARNING: don't run with debug turned on in production!
             DEBUG = True
             ALLOWED_HOSTS = ['*']
             CSRF_TRUSTED_ORIGINS=[
                 "http://*.localhost:8030",
                 "http://localhost:8030",
                 "http://127.0.0.1:8030",
                 "http://*.localhost:8086",
+                "http://0.0.0.0:8086",
                 "http://localhost:8086",
                 "http://127.0.0.1:8086"
             ]
             #Si se requiere que la aplicación salga de este entorno, para otros usuarios es necesario hacer una API request https://fractalideas.com/blog/making-react-and-django-play-well-together-single-page-app-model/
             # Application definition
             INSTALLED_APPS = [
                 'django.contrib.admin',
                 'django.contrib.auth',
                 'django.contrib.contenttypes',
                 'django.contrib.sessions',
                 'django.contrib.messages',
                 'django.contrib.staticfiles',
                 'apps.accounts',
                 'apps.main',
                 'apps.misc',
                 'apps.rc',
                 'apps.dds',
                 'apps.jars',
                 'apps.usrp',
                 'apps.abs',
                 'apps.cgs',
                 'apps.dds_rest',
                 'apps.atrad',
                 "django_bootstrap5",
                 'polymorphic',
                 'radarsys',
             ]
             MIDDLEWARE = [
                 'django.middleware.security.SecurityMiddleware',
                 'django.contrib.sessions.middleware.SessionMiddleware',
                 'django.middleware.common.CommonMiddleware',
                 'django.middleware.csrf.CsrfViewMiddleware',
                 'django.contrib.auth.middleware.AuthenticationMiddleware',
                 'django.contrib.messages.middleware.MessageMiddleware',
                 'django.middleware.clickjacking.XFrameOptionsMiddleware',
             ]
             ROOT_URLCONF = 'radarsys.urls'
             TEMPLATES = [
                 {
                     'BACKEND': 'django.template.backends.django.DjangoTemplates',
                     'DIRS': [os.path.join(BASE_DIR, "templates")],
                     'APP_DIRS': True,
                     'OPTIONS': {
                         'context_processors': [
                             'django.template.context_processors.debug',
                             'django.template.context_processors.request',
                             'django.contrib.auth.context_processors.auth',
                             'django.contrib.messages.context_processors.messages',
                             'apps.main.processors.radarsys_globals',
                         ],
                     },
                 },
             ]
             WSGI_APPLICATION = 'radarsys.wsgi.application'
             ASGI_APPLICATION = 'radarsys.asgi.application'
             # Database
             # https://docs.djangoproject.com/en/1.8/ref/settings/#databases
             DATABASES = {
                 # 'default': {
                 #     'ENGINE': 'django.db.backends.sqlite3',
                 #     'NAME': 'radarsys.sqlite',
                 # }
                 'default': {
                     'ENGINE': 'django.db.backends.postgresql_psycopg2',
                     'NAME': os.environ.get('DB_NAME', 'radarsys'),
                     'USER': os.environ.get('DB_USER', 'docker'),
                     'PASSWORD': os.environ.get('DB_PASSWORD', 'docker'),
                     'HOST': os.environ.get('POSTGRES_PORT_5432_TCP_ADDR', 'localhost'),
                     'PORT': os.environ.get('POSTGRES_PORT_5432_TCP_PORT', '5432'),
                 }
             }
             # Internationalization
             # https://docs.djangoproject.com/en/1.8/topics/i18n/
             LANGUAGE_CODE = 'en-us'
             USE_TZ   = False #True
             TIME_ZONE = os.environ.get('TZ', 'America/Lima')
             USE_I18N = True
             USE_L10N = True
             # Static files (CSS, JavaScript, Images)
             # https://docs.djangoproject.com/en/1.8/howto/static-files/
             MEDIA_URL = '/media/'
             MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
             STATICFILES_DIRS = [
                os.path.join(BASE_DIR, 'radarsys/static/')
             ]
             STATIC_URL = '/static/'
             STATIC_ROOT = os.path.join(BASE_DIR, 'static')
             LOGIN_URL = '/accounts/login'
             LOGOUT_URL = 'logout'
             LOGIN_REDIRECT_URL = '/admin'
             LOGOUT_REDIRECT_URL = '/'
             STATICFILES_FINDERS = (
                 'django.contrib.staticfiles.finders.FileSystemFinder',
                 'django.contrib.staticfiles.finders.AppDirectoriesFinder',
             )
             import django
             from django.utils.encoding import force_str
             django.utils.encoding.force_text = force_str
             # choose of auto-created primary keys
             DEFAULT_AUTO_FIELD='django.db.models.AutoField'

radarsys/static/js/atrad-mainpage.js ~~radarsys/static/js/atrad-conf.js~~ renamed 0 0

NO CONTENT: file renamed from radarsys/static/js/atrad-conf.js to radarsys/static/js/atrad-mainpage.js

radarsys/static/js/bokeh-3.0.0.min.js 644 ➡ 755 0 0