radarsys Commit - r395:cfb0f9955b15 · Jicamarca Repository

Scheduler funcional

Renato Huallpa -

r395:cfb0f9955b15

parent child

Context file:

r395:cfb0f9955b15

Collapse all files

.env +2 -2

             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=10.10.10.200
-            MQTT_SERVER = 192.168.100.5
+            # 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_USER = abs
             MQTT_PASSWORD = abs
             TOPIC_ABS=abs/beams
             TOPIC_ABS_ACK=abs/beams_ack
             TOPIC_ABS_CHANGE=abs/change_beam

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 = models.SmallIntegerField()
                 temp_cll = models.SmallIntegerField()
                 nboards = models.SmallIntegerField()
                 tempdvr = models.SmallIntegerField()
                 potincdvr = models.SmallIntegerField()
                 potretdvr = models.SmallIntegerField()
                 temp1 = models.SmallIntegerField()
                 potinc1 = models.SmallIntegerField()
                 potret1 = models.SmallIntegerField()
                 temp2 = models.SmallIntegerField()
                 potinc2 = models.SmallIntegerField()
                 potret2 = models.SmallIntegerField()
                 temp3 = models.SmallIntegerField()
                 potinc3 = models.SmallIntegerField()
                 potret3 = models.SmallIntegerField()
                 temp4 = models.SmallIntegerField()
                 potinc4 = models.SmallIntegerField()
                 potret4 = models.SmallIntegerField()
                 temp5 = models.SmallIntegerField()
                 potinc5 = models.SmallIntegerField()
                 potret5 = models.SmallIntegerField()
                 temp6 = models.SmallIntegerField()
                 potinc6 = models.SmallIntegerField()
                 potret6 = 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
+                    # 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
                     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/cgs/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
             # Create your models here. validators=[MinValueValidator(62.5e6), MaxValueValidator(450e6)]
             class CGSConfiguration(Configuration):
                 freq0 = models.PositiveIntegerField(verbose_name='Frequency 0 (Hz)',validators=[MaxValueValidator(450e6)], default = 60)
                 freq1 = models.PositiveIntegerField(verbose_name='Frequency 1 (Hz)',validators=[MaxValueValidator(450e6)], default = 60)
                 freq2 = models.PositiveIntegerField(verbose_name='Frequency 2 (Hz)',validators=[MaxValueValidator(450e6)], default = 60)
                 freq3 = models.PositiveIntegerField(verbose_name='Frequency 3 (Hz)',validators=[MaxValueValidator(450e6)], default = 60)
                 def verify_frequencies(self):
                     return True
                 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 CGS 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 = 'CGS 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 CGS 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 = 'CGS device is already stopped.'
                         return False
+                    # 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
                     post_data = {"freq0":0, "freq1":0, "freq2":0, "freq3":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 CGS 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 CGS device.'
                         return False
                     self.message = 'CGS 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 CGS parameters from this device"
                         return None
                     frequencies = frequencies.json()
                     if frequencies:
                         frequencies = frequencies.get("Frequencies")
                         freq0 = frequencies.get("freq0")
                         freq1 = frequencies.get("freq1")
                         freq2 = frequencies.get("freq2")
                         freq3 = frequencies.get("freq3")
                         parms = {'freq0': freq0,
                              'freq1': freq1,
                              'freq2': freq2,
                              'freq3': freq3}
                         self.message = "CGS parameters have been successfully read"
                         return parms
                     else:
                         self.message = "Error reading CGS 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 ['freq0','freq1','freq2','freq3']:
                             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 CGS 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 = 'cgs_configurations'

apps/dds/models.py +5 0

             from django.db import models
             from apps.main.models import Configuration
             from apps.main.utils import Params
             # Create your models here.
             from django.core.validators import MinValueValidator, MaxValueValidator
             from django.core.exceptions import ValidationError
             from devices.dds import api, data
             ENABLE_TYPE = (
                            (False, 'Disabled'),
                            (True, 'Enabled'),
                            )
             MOD_TYPES = (
                             (0, 'Single Tone'),
                             (1, 'FSK'),
                             (2, 'Ramped FSK'),
                             (3, 'Chirp'),
                             (4, 'BPSK'),
                         )
             class DDSConfiguration(Configuration):
                 DDS_NBITS = 48
                 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=4)
                 frequencyA_Mhz = models.DecimalField(verbose_name='Frequency A (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=19, decimal_places=16, null=True, default=49.9200)
                 frequencyA = models.BigIntegerField(verbose_name='Frequency A (Decimal)',validators=[MinValueValidator(0), MaxValueValidator(2**DDS_NBITS-1)], blank=True, null=True)
                 frequencyB_Mhz = models.DecimalField(verbose_name='Frequency B (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=19, decimal_places=16, blank=True, null=True)
                 frequencyB = models.BigIntegerField(verbose_name='Frequency B (Decimal)',validators=[MinValueValidator(0), MaxValueValidator(2**DDS_NBITS-1)], blank=True, null=True)
                 phaseA_degrees = models.FloatField(verbose_name='Phase A (Degrees)', validators=[MinValueValidator(0), MaxValueValidator(360)], default=0)
                 phaseB_degrees = models.FloatField(verbose_name='Phase B (Degrees)', validators=[MinValueValidator(0), MaxValueValidator(360)], blank=True, null=True)
                 modulation = models.PositiveIntegerField(verbose_name='Modulation Type', choices = MOD_TYPES, default = 0)
                 amplitude_enabled = models.BooleanField(verbose_name='Amplitude Control', choices=ENABLE_TYPE, default=False)
                 amplitudeI = models.PositiveIntegerField(verbose_name='Amplitude CH1',validators=[MinValueValidator(0), MaxValueValidator(2**12-1)], blank=True, null=True)
                 amplitudeQ = models.PositiveIntegerField(verbose_name='Amplitude CH2',validators=[MinValueValidator(0), MaxValueValidator(2**12-1)], blank=True, null=True)
                 def get_nbits(self):
                     return self.DDS_NBITS
                 def clean(self):
                     if self.modulation in [1,2,3]:
                         if self.frequencyB is None or self.frequencyB_Mhz is None:
                             raise ValidationError({
                                 'frequencyB': 'Frequency modulation has to be defined when FSK or Chirp modulation is selected'
                             })
                     if self.modulation in [4,]:
                         if self.phaseB_degrees is None:
                             raise ValidationError({
                                 'phaseB': 'Phase modulation has to be defined when BPSK modulation is selected'
                             })
                     self.frequencyA_Mhz = data.binary_to_freq(self.frequencyA, self.clock*self.multiplier)
                     self.frequencyB_Mhz = data.binary_to_freq(self.frequencyB, self.clock*self.multiplier)
                 def verify_frequencies(self):
                     return True
                 def parms_to_text(self):
                     my_dict = self.parms_to_dict()['configurations']['byId'][str(self.id)]
                     text = data.dict_to_text(my_dict)
                     return text
                 def status_device(self):
                     try:
                         answer = api.status(ip = self.device.ip_address,
                                             port = self.device.port_address)
                         if 'clock' in answer:
                             self.device.status = 1
                         else:
                             self.device.status = answer[0]
                         self.message = 'DDS - {}'.format(answer[2:])
                     except Exception as e:
                         self.message = str(e)
                         self.device.status = 0
                     self.device.save()
                     if self.device.status in (0, '0'):
                         return False
                     else:
                         return True
                 def reset_device(self):
                     answer = api.reset(ip = self.device.ip_address,
                                        port = self.device.port_address)
                     if answer[0] != "1":
                         self.message = 'DDS - {}'.format(answer[2:])
                         return 0
                     self.message = 'DDS - {}'.format(answer[2:])
                     return 1
                 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:
                         answer = api.disable_rf(ip = self.device.ip_address,
                                                 port = self.device.port_address)
                         return self.status_device()
                     except Exception as e:
                         self.message = str(e)
                         return False
                 def start_device(self):
                     try:
                         answer = api.enable_rf(ip = self.device.ip_address,
                                                 port = self.device.port_address)
                         return self.status_device()
                     except Exception as e:
                         self.message = str(e)
                         return False
                 def read_device(self):
                     parms = api.read_config(ip = self.device.ip_address,
                                             port = self.device.port_address)
                     if not parms:
                         self.message = "Could not read DDS parameters from this device"
                         return parms
                     self.message = ""
                     return parms
                 def write_device(self):
                     try:
                         answer = api.write_config(ip = self.device.ip_address,
                                                   port = self.device.port_address,
                                                   parms = self.parms_to_dict()['configurations']['byId'][str(self.id)])
                         return self.status_device()
                     except Exception as e:
                         self.message = str(e)
                         return False
                 class Meta:
                     db_table = 'dds_configurations'

apps/dds_rest/models.py +5 0

             import ast
             import json
             import requests
             import numpy as np
             from base64 import b64encode
             from struct import pack
             from django.urls import reverse
             from django.db import models
             from apps.main.models import Configuration
             from apps.main.utils import Params
             # Create your models here.
             from django.core.validators import MinValueValidator, MaxValueValidator
             from django.core.exceptions import ValidationError
             from devices.dds_rest import api, data
             ENABLE_TYPE = (
                            (False, 'Disabled'),
                            (True, 'Enabled'),
                            )
             MOD_TYPES = (
                             (0, 'Single Tone'),
                             (1, 'FSK'),
                             (2, 'Ramped FSK'),
                             (3, 'Chirp'),
                             (4, 'BPSK'),
                         )
             class DDSRestConfiguration(Configuration):
                 DDS_NBITS = 48
                 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=4)
                 frequencyA_Mhz = models.DecimalField(verbose_name='Frequency A (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=19, decimal_places=16, null=True, default=49.9200)
                 frequencyA     = models.BigIntegerField(verbose_name='Frequency A (Decimal)',validators=[MinValueValidator(0), MaxValueValidator(2**DDS_NBITS-1)], blank=True, null=True)
                 frequencyB_Mhz = models.DecimalField(verbose_name='Frequency B (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=19, decimal_places=16, blank=True, null=True)
                 frequencyB     = models.BigIntegerField(verbose_name='Frequency B (Decimal)',validators=[MinValueValidator(0), MaxValueValidator(2**DDS_NBITS-1)], blank=True, null=True)
                 delta_frequency_Mhz = models.DecimalField(verbose_name='Delta frequency (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=19, decimal_places=16, blank=True, null=True)
                 delta_frequency     = models.BigIntegerField(verbose_name='Delta frequency (Decimal)',validators=[MinValueValidator(0), MaxValueValidator(2**DDS_NBITS-1)], blank=True, null=True)
                 update_clock_Mhz = models.DecimalField(verbose_name='Update clock (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=19, decimal_places=16, blank=True, null=True)
                 update_clock     = models.BigIntegerField(verbose_name='Update clock (Decimal)',validators=[MinValueValidator(0), MaxValueValidator(2**32-1)], blank=True, null=True)
                 ramp_rate_clock_Mhz = models.DecimalField(verbose_name='Ramp rate clock (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=19, decimal_places=16, blank=True, null=True)
                 ramp_rate_clock     = models.BigIntegerField(verbose_name='Ramp rate clock (Decimal)',validators=[MinValueValidator(0), MaxValueValidator(2**18-1)], blank=True, null=True)
                 phaseA_degrees = models.FloatField(verbose_name='Phase A (Degrees)', validators=[MinValueValidator(0), MaxValueValidator(360)], default=0)
                 phaseB_degrees = models.FloatField(verbose_name='Phase B (Degrees)', validators=[MinValueValidator(0), MaxValueValidator(360)], blank=True, null=True)
                 modulation = models.PositiveIntegerField(verbose_name='Modulation Type', choices = MOD_TYPES, default = 0)
                 amplitude_enabled = models.BooleanField(verbose_name='Amplitude Control', choices=ENABLE_TYPE, default=False)
                 amplitudeI = models.PositiveIntegerField(verbose_name='Amplitude CH1',validators=[MinValueValidator(0), MaxValueValidator(2**12-1)], blank=True, null=True)
                 amplitudeQ = models.PositiveIntegerField(verbose_name='Amplitude CH2',validators=[MinValueValidator(0), MaxValueValidator(2**12-1)], blank=True, null=True)
                 def get_nbits(self):
                     return self.DDS_NBITS
                 def clean(self):
                     if self.modulation in [1,2,3]:
                         if self.frequencyB is None or self.frequencyB_Mhz is None:
                             raise ValidationError({
                                 'frequencyB': 'Frequency modulation has to be defined when FSK or Chirp modulation is selected'
                             })
                     if self.modulation in [4,]:
                         if self.phaseB_degrees is None:
                             raise ValidationError({
                                 'phaseB': 'Phase modulation has to be defined when BPSK modulation is selected'
                             })
                     self.frequencyA_Mhz = data.binary_to_freq(self.frequencyA, self.clock*self.multiplier)
                     self.frequencyB_Mhz = data.binary_to_freq(self.frequencyB, self.clock*self.multiplier)
                 def verify_frequencies(self):
                     return True
                 def parms_to_text(self):
                     my_dict = self.parms_to_dict()['configurations']['byId'][str(self.id)]
                     text = data.dict_to_text(my_dict)
                     return text
                 def status_device(self):
                     print("Status ")
                     try:
                         self.device.status = 0
                         payload = self.request('status')
                         if payload['status']=='generating RF':
                             self.device.status = 3
                         elif payload['status']=='no generating RF':
                             self.device.status = 2
                         else:
                             self.device.status = 1
                             self.device.save()
                             self.message = 'DDS REST status: {}'.format(payload['status'])
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         self.device.save()
                         self.message = 'DDS REST status: {}'.format(str(e))
                         return False
                     self.device.save()
                     return True
                 def reset_device(self):
                     try:
                         payload = self.request('reset', 'post')
                         if payload['reset']=='ok':
                             self.message = 'DDS REST restarted OK'
                             self.device.status = 2
                             self.device.save()
                         else:
                             self.message = 'DDS REST restart fail'
                             self.device.status = 4
                             self.device.save()
                     except Exception as e:
                         self.message = 'DDS REST reset: {}'.format(str(e))
                         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',data=json.dumps({'_rf_enable':0}))
                         self.message = 'DDS REST: {}'.format(payload['stop'])
                         if payload['stop']=='ok':
                             self.device.status = 2
                             self.device.save()
                         else:
                             self.device.status = 4
                             self.device.save()
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         self.message = 'DDS REST stop: {}'.format(str(e))
                         self.device.save()
                         return False
                     return True
                 def start_device(self):
                     try:
                         payload = self.request('start', 'post',data=json.dumps({'_rf_enable':1}))
                         self.message = 'DDS REST start: {}'.format(payload['start'])
                         if payload['start']=='ok':
                             self.device.status = 3
                             self.device.save()
                         else:
                             self.device.status = 2
                             self.device.save()
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         self.message = 'DDS REST start: {}'.format(str(e))
                         self.device.save()
                         return False
                     return True
                 def read_device(self):
                     parms = self.request('read')
                     print(parms)
                     if not parms:
                         self.message = "Could not read DDS REST parameters from this device"
                         return parms
                     self.message = ""
                     return parms
                 def arma_control(self,l_clock,l_multiplier,l_modulation):
                     sysclock  = l_clock*l_multiplier
                     pll_range = 0
                     if(sysclock>=200):
                          pll_range = 1
                     l_control = ((l_modulation<<9)+(pll_range<<22)+(l_multiplier<<16)).to_bytes(4,'little')
                     return l_control
                 def conv_phase(self,l_phase):
                     l_phase_2B = int((l_phase*(2**14)/360)).to_bytes(2,'little')
                     return l_phase_2B
                 def arma_data_write(self):
                     #clock = RCClock.objects.get(rc_configuration=self)
                     clock = self.clock
                     print(clock)
                     multiplier = self.multiplier
                     print(multiplier)
                     frequencyA_Mhz = self.frequencyA_Mhz
                     print(frequencyA_Mhz)
                     frequencyA = self.frequencyA
                     print(frequencyA)
                     frequencyB_Mhz = self.frequencyB_Mhz
                     print(frequencyB_Mhz)
                     frequencyB = self.frequencyB
                     print(frequencyB)
                     phaseA_degrees = self.phaseA_degrees or 0
                     print(phaseA_degrees)
                     phaseB_degrees = self.phaseB_degrees or 0
                     print(phaseB_degrees)
                     modulation = self.modulation or 0
                     print(modulation)
                     amplitude_enabled = self.amplitude_enabled or 0
                     print(amplitude_enabled)
                     amplitudeI = self.amplitudeI or 0
                     print(amplitudeI)
                     amplitudeQ = self.amplitudeQ or 0
                     print(amplitudeQ)
                     delta_frequency = self.delta_frequency or 0
                     print(delta_frequency)
                     update_clock = self.update_clock or 0
                     print(update_clock)
                     ramp_rate_clock = self.ramp_rate_clock or 0
                     print(ramp_rate_clock)
                     osrr = 0
                     qdac = 0
                     control = self.arma_control(clock,multiplier,modulation)
                     phase1  = self.conv_phase(phaseA_degrees)
                     phase2  = self.conv_phase(phaseB_degrees)
                     cadena_json = {'clock': (b64encode(pack('<f',clock))).decode("UTF-8"),\
                     'multiplier': (b64encode(pack('<B',multiplier))).decode("UTF-8"),\
                     'frequencyA': (b64encode((frequencyA).to_bytes(6,'little'))).decode("UTF-8"),\
                     'frequencyB': (b64encode((frequencyB).to_bytes(6,'little'))).decode("UTF-8"),\
                     'delta_frequency': (b64encode((delta_frequency).to_bytes(6,'little'))).decode("UTF-8"),\
                     'update_clock': (b64encode((update_clock).to_bytes(4,'little'))).decode("UTF-8"),\
                     'ramp_rate_clock': (b64encode((ramp_rate_clock).to_bytes(3,'little'))).decode("UTF-8"),\
                     'control': (b64encode(control)).decode("UTF-8"),\
                     'amplitudeI': (b64encode((amplitudeI).to_bytes(2,'little'))).decode("UTF-8"),\
                     'amplitudeQ': (b64encode((amplitudeQ).to_bytes(2,'little'))).decode("UTF-8"),\
                     '_phase1': (b64encode((phase1))).decode("UTF-8"),\
                     '_phase2': (b64encode((phase2))).decode("UTF-8"),\
                     'osrr': (b64encode((osrr).to_bytes(1,'little'))).decode("UTF-8"),\
                     'qdac': (b64encode((qdac).to_bytes(2,'little'))).decode("UTF-8")
                     }
                     return cadena_json
                 def write_device(self, raw=False):
                     print("Ingreso a write")
                     try:
                         if not raw:
                             data = self.arma_data_write()
                             print(data)
                             payload = self.request('write', 'post', data=json.dumps(data))
                             print(payload)
                             if payload['write'] == 'ok':
                                 self.device.status = 3
                                 self.device.save()
                                 self.message = 'DDS Rest write configured and started'
                             else:
                                 self.message = payload['programming']
                                 if payload['programming'] == 'fail':
                                     self.message = 'DDS Rest write: error programming DDS chip'
                         if raw:
                             return b64encode(data)
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         self.message = 'DDS Rest write: {}'.format(str(e))
                         self.device.save()
                         return False
                     return True
                 def request(self, cmd, method='get', **kwargs):
                     print("Ingreso a request")
                     req = getattr(requests, method)(self.device.url(cmd), **kwargs)
                     payload = req.json()
                     return payload
                 class Meta:
                     db_table = 'ddsrest_configurations'

apps/jars/models.py +5 0

             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)
                     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/models.py +4 -4

             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("Guardando STATUS: {}".format(self.status))
+                    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("conf->",conf)
-                        print(conf.device)
-                        print(conf.device.status)
                         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/main/templates/base_list.html +1 -1

             {% extends "base.html" %}
             {% load django_bootstrap5 %}
             {% load static %}
             {% load main_tags %}
             {% block extra-head %}
             <link href="{% static 'css/bootstrap-datetimepicker.min.css' %}" media="screen" rel="stylesheet">
             {% endblock %}
             {% block content-title %}{{title}}{% endblock %}
             {% block content-suptitle %}{{suptitle}}{% endblock %}
             {% block content %}
             {% block content-filter %}
             {% if form %}
             <form class="form" method="get">
               {% bootstrap_form form layout='horizontal' size='md' %}
               <div class="pull-right">
                 <br>
               <button type="button" class="btn btn-primary btn-sm" onclick="window.location.replace('?');"><span class="fas fa-sync-alt" aria-hidden="true"></span></button>
               <button type="submit" class="btn btn-primary btn-sm"><span class="fas fa-search" aria-hidden="true"></span></button>
               {% if add_url %}
               <a class="btn btn-sm btn-info" href="{{add_url}}"><span class="fas fa-plus" aria-hidden="true"></span></a>
               {% endif %}
             </div>
             </form>
             {% endif %}
             {% endblock %}
             <div style="clear: both;"></div>
             <br>
             <table class="table table-hover">
               <tr>
                 <th>#</th>
                 {% for key in keys %}
                 {% if key == 'location'%}
                 <th>System</th>
                 {% else %}
                 <th>{{ key|title }}</th>
                 {% endif %}
                 {% endfor%}
               </tr>
               {% for object in objects %}
-                <tr class="clickable-row" data-href="{{object.get_absolute_mqtt_url}}">
+                <tr class="clickable-row" data-href="{{object.get_absolute_url}}">
                   <td>{{ forloop.counter|add:offset }}</td>
                   {% for key in keys %}
                   {% if key == 'actions' %}
                   <td>
                     <a class="btn btn-sm btn-danger" href="{{object.get_absolute_url_delete}}"><span class="fas fa-times" aria-hidden="true"></span></a>
                     <a class="btn btn-sm btn-primary" href="{{object.get_absolute_url_edit}}"><span class="fa fa-pencil" aria-hidden="true"></span></a>
                   </td>
                   {% else %}
                   <td>{{ object|attr:key }}</td>
                   {% endif %}
                   {% endfor %}
                 </tr>
               {% endfor %}
             </table>
             <div class="pagination">
               <span class="step-links">
                 {% if objects.has_previous %}
                 <a href="?page={{ objects.previous_page_number }}&{{q}}"><span class="fas fa-chevron-left" aria-hidden="true"></span></a>
                 {% endif %}
               <span class="current">
                 Page {{ objects.number }} of {{ objects.paginator.num_pages }}.
               </span>
               {% if objects.has_next %}
               <a href="?page={{ objects.next_page_number }}&{{q}}"><span class="fas fa-chevron-right" aria-hidden="true"></span></a>
               {% endif %}
               </span>
             </div>
             {% endblock %}
             {% block extra-js%}
             <script src="{% static 'js/bootstrap-datetimepicker.min.js' %}"></script>
             <script type="text/javascript">
               $('.input-group.date').datetimepicker({
                 format: "YYYY-MM-DD",
                 icons: {
                   time: 'far fa-clock',
                   date: 'far fa-calendar-alt',
                   up: 'fas fa-arrow-up',
                   down: 'fas fa-arrow-down',
                   previous: 'fas fa-chevron-left',
                   next: 'fas fa-chevron-right',
                   today: 'far fa-calendar-check',
                   clear: 'far fa-trash-alt',
                   close: 'fas fa-times'
                 }
               });
               $(".clickable-row").click(function() {
                 document.location = $(this).data("href");
               });
             </script>
             {% endblock %}

apps/main/templates/campaign.html +1 -1

             {% extends "base.html" %}
             {% load django_bootstrap5 %}
             {% load static %}
             {% load main_tags %}
             {% block extra-head %}
             <link href="{% static 'css/bootstrap-datetimepicker.min.css' %}" media="screen" rel="stylesheet">
             {% endblock %}
             {% block content-title %}{{title}}{% endblock %}
             {% block content-suptitle %}{{suptitle}}{% endblock %}
             {% block content %}
             {% block menu-actions %}
             <span class=" dropdown pull-right">
               <a href="#" class="dropdown-toggle" data-toggle="dropdown"><span class="fas fa-bars" aria-hidden="true"></span></a>
               <ul class="dropdown-menu" role="menu">
                 <li><a href="{% url 'url_edit_campaign' campaign.id %}"><span class="fa fa-pencil" aria-hidden="true"></span> Edit</a></li>
                 <li><a href="{% url 'url_delete_campaign' campaign.id %}"><span class="fa fa-times" aria-hidden="true"></span> Delete</a></li>
                 <li><a href="{{ campaign.get_absolute_url_import }}"><span class="fas fa-cloud-download-alt" aria-hidden="true"></span> Import </a></li>
                 <li><a href="{{ campaign.get_absolute_url_export }}"><span class="fas fa-cloud-upload-alt" aria-hidden="true"></span> Export </a></li>
                 {% block extra-menu-actions %}
                 {% endblock %}
                 <li><a>----------------</a></li>
                 <!--<li><a href="{{ dev_conf.get_absolute_url_status }}"><span class="glyphicon glyphicon-refresh" aria-hidden="true"></span> Status</a></li>
                 {% if not no_play %}
                 <li><a href="{{ dev_conf.get_absolute_url_start}}"><span class="glyphicon glyphicon-play" aria-hidden="true"></span> Start</a></li>
                 <li><a href="{{ dev_conf.get_absolute_url_stop }}"><span class="glyphicon glyphicon-stop" aria-hidden="true"></span> Stop</a></li>
                 {% endif %}
                 <li><a href="{{ dev_conf.get_absolute_url_write }}"><span class="glyphicon glyphicon-download" aria-hidden="true"></span> Write</a></li>
                 <li><a href="{{ dev_conf.get_absolute_url_read }}"><span class="glyphicon glyphicon-upload" aria-hidden="true"></span> Read</a></li>-->
               </ul>
             </span>
             {% endblock %}
             	<table class="table table-bordered">
             	{% for key in campaign_keys %}
             		<tr><th>{{key|title}}</th><td>{{campaign|attr:key}}</td></tr>
             	{% endfor %}
             	</table>
             	<!--<button class="btn btn-primary pull-right" style="margin-left: 10px" id="bt_export">Export</button>-->
             	<!--<button class="btn btn-primary pull-right" style="margin-left: 10px" id="bt_edit">Edit</button>-->
             	<br></br>
             	<br></br>
             	<div class="panel-group" id="accordion" role="tablist" aria-multiselectable="true">
             	  <div class="panel panel-default">
             	    <div class="panel-heading" role="tab" id="headingTwo">
             	      <h4 class="panel-title">
             	        <a class="collapsed" role="button" data-toggle="collapse" data-parent="#accordion" href="#collapseTwo" aria-expanded="false" aria-controls="collapseTwo">
             	          Experiment List
             	        </a>
             	      </h4>
             	    </div>
             	    <div id="collapseTwo" class="panel-collapse collapse in" role="tabpanel" aria-labelledby="headingTwo">
             	      <div class="panel-body">
             	      <table class="table table-hover">
             			<tr>
             			  <th>#</th>
             			  {% for header in experiment_keys %}
             			  <th>{{ header|title }}</th>
             			  {% endfor%}
             			</tr>
             			{% for item in experiments %}
-            			<tr class="clickable-row" data-href="{% url 'url_experiment' item.id %}">
+            			<tr class="clickable-row" s data-href="{% url 'url_experiment' item.id %}">
             			  <td>{{ forloop.counter }}</td>
             			  {% for key in experiment_keys %}
             			  <td>{{ item|attr:key }}</td>
             			  {% endfor %}
             			</tr>
             			{% endfor %}
             		  </table>
             	      </div>
             	    </div>
             	  </div>
             	</div>
             	<br>
             	<!--<button class="btn btn-primary pull-right" style="margin-left: 10px" id="bt_mix">Mix Experiments</button>-->
             {% endblock %}
             {% block sidebar%}
                {% include "sidebar_devices.html" %}
             {% endblock %}
             {% block extra-js%}
             <script type="text/javascript">
               $(".clickable-row").click(function() {
             	    document.location = $(this).data("href");
             	  });
             //  $("#bt_edit").click(function() {
             //  	    document.location = "{% url 'url_edit_campaign' campaign.id %}";
             //  	  });
               $("#bt_mix").click(function() {
                   });
             </script>
             {% endblock %}

apps/rc/models.py +4 -1

             import ast
             import json
             import requests
             import numpy as np
             from base64 import b64encode
             from struct import pack
             from django.db import models
             from django.urls import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from apps.main.models import Configuration
             from apps.main.utils import Params
             from devices.rc import api
             from apps.rc.utils import RCFile
             LINE_TYPES = (
                 ('none', 'Not used'),
                 ('tr', 'Transmission/reception selector signal'),
                 ('tx', 'A modulating signal (Transmission pulse)'),
                 ('codes', 'BPSK modulating signal'),
                 ('windows', 'Sample window signal'),
                 ('sync', 'Synchronizing signal'),
                 ('flip', 'IPP related periodic signal'),
                 ('prog_pulses', 'Programmable pulse'),
                 ('mix', 'Mixed line'),
                 )
             SAMPLING_REFS = (
                 ('none', 'No Reference'),
                 ('begin_baud', 'Begin of the first baud'),
                 ('first_baud', 'Middle of the first baud'),
                 ('sub_baud', 'Middle of the sub-baud')
                              )
             DAT_CMDS = {
                     # Pulse Design commands
                     'DISABLE' : 0, # Disables pulse generation
                     'ENABLE' : 24, # Enables pulse generation
                     'DELAY_START' : 40, # Write delay status to memory
                     'FLIP_START' : 48, # Write flip status to memory
                     'SAMPLING_PERIOD' : 64, # Establish Sampling Period
                     'TX_ONE' : 72, # Output '0' in line TX
                     'TX_ZERO' : 88, # Output '0' in line TX
                     'SW_ONE' : 104, # Output '0' in line SW
                     'SW_ZERO' : 112, # Output '1' in line SW
                     'RESTART': 120, # Restarts CR8 Firmware
                     'CONTINUE' : 253, # Function Unknown
                     # Commands available to new controllers
                     # In Pulse Design Executable, the clock divisor code is written as 12 at the start, but it should be written as code 22(below) just before the final enable.
                     'CLOCK_DIVISOR_INIT' : 12, # Specifies Clock Divisor. Legacy command, ignored in the actual .dat conversion
                     'CLOCK_DIVISOR_LAST' : 22, # Specifies Clock Divisor (default 60 if not included) syntax: 255,22 254,N-1.
                     'CLOCK_DIVIDER' : 8,
                         }
             MAX_BITS = 8
             # Rotate left: 0b1001 --> 0b0011
             rol = lambda val, r_bits: \
                 (val << r_bits%MAX_BITS) & (2**MAX_BITS-1) | \
                 ((val & (2**MAX_BITS-1)) >> (MAX_BITS-(r_bits%MAX_BITS)))
             # Rotate right: 0b1001 --> 0b1100
             ror = lambda val, r_bits: \
                 ((val & (2**MAX_BITS-1)) >> r_bits%MAX_BITS) | \
                 (val << (MAX_BITS-(r_bits%MAX_BITS)) & (2**MAX_BITS-1))
             class RCConfiguration(Configuration):
                 ipp = models.FloatField(verbose_name='IPP [Km]', validators=[MinValueValidator(1)], default=300)
                 ntx = models.PositiveIntegerField(verbose_name='Number of TX', validators=[MinValueValidator(1)], default=1)
                 clock_in = models.FloatField(verbose_name='Clock in [MHz]', validators=[MinValueValidator(1), MaxValueValidator(80)], default=1)
                 clock_divider = models.PositiveIntegerField(verbose_name='Clock divider', validators=[MinValueValidator(1), MaxValueValidator(256)], default=1)
                 clock = models.FloatField(verbose_name='Clock Master [MHz]', blank=True, default=1)
                 time_before = models.PositiveIntegerField(verbose_name='Time before [&mu;S]', default=12)
                 time_after = models.PositiveIntegerField(verbose_name='Time after [&mu;S]', default=1)
                 sync = models.PositiveIntegerField(verbose_name='Synchro delay', default=0)
                 sampling_reference = models.CharField(verbose_name='Sampling Reference', choices=SAMPLING_REFS, default='none', max_length=40)
                 control_tx = models.BooleanField(verbose_name='Control Switch TX', default=False)
                 control_sw = models.BooleanField(verbose_name='Control Switch SW', default=False)
                 total_units = models.PositiveIntegerField(default=0)
                 mix = models.BooleanField(default=False)
                 class Meta:
                     db_table = 'rc_configurations'
                 def get_absolute_url_plot(self):
                     return reverse('url_plot_rc_pulses', args=[str(self.id)])
                 @property
                 def ipp_unit(self):
                     return '{} ({})'.format(self.ipp, int(self.ipp*self.km2unit))
                 @property
                 def us2unit(self):
                     return self.clock_in/self.clock_divider
                 @property
                 def km2unit(self):
                     return 20./3*(self.clock_in/self.clock_divider)
                 def clone(self, **kwargs):
                     lines = self.get_lines()
                     self.pk = None
                     self.id = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     for line in lines:
                         line.clone(rc_configuration=self)
                     new_lines = self.get_lines()
                     for line in new_lines:
                         line_params = json.loads(line.params)
                         if 'TX_ref' in line_params and (line_params['TX_ref'] != '0'):
                             ref_line = RCLine.objects.get(pk=line_params['TX_ref'])
                             line_params['TX_ref'] = ['{}'.format(l.pk) for l in new_lines if l.get_name()==ref_line.get_name()][0]
                             line.params = json.dumps(line_params)
                             line.save()
                     return self
                 def get_lines(self, **kwargs):
                     '''
                     Retrieve configuration lines
                     '''
                     return RCLine.objects.filter(rc_configuration=self.pk, **kwargs)
                 def clean_lines(self):
                     '''
                     '''
                     empty_line = RCLineType.objects.get(name='none')
                     for line in self.get_lines():
                         line.line_type = empty_line
                         line.params = '{}'
                         line.save()
                 def dict_to_parms(self, params, id=None):
                     '''
                     '''
                     if id:
                         data = Params(params).get_conf(id_conf=id)
                     else:
                         data = Params(params).get_conf(dtype='rc')
                     #print(data)
                     # self.name = data['name']
                     self.ipp = data['ipp']
                     self.ntx = data['ntx']
                     self.clock_in = data['clock_in']
                     self.clock_divider = data['clock_divider']
                     self.clock = data['clock']
                     self.time_before = data['time_before']
                     self.time_after = data['time_after']
                     self.sync = data['sync']
                     self.sampling_reference = data['sampling_reference']
                     self.total_units = self.ipp*self.ntx*self.km2unit
                     self.save()
                     self.clean_lines()
                     #print(params)
                     positions = {'tx':0, 'tr':0}
                     for i, id in enumerate(data['lines']):
                         line_data = params['lines']['byId'][id]
                         line_type = RCLineType.objects.get(name=line_data['line_type'])
                         if line_type.name == 'codes':
                             code = RCLineCode.objects.get(name=line_data['params']['code'])
                             line_data['params']['code'] = code.pk
                         if line_type.name == 'tx':
                             position = positions['tx']
                             positions['tx'] += 1
                         elif line_type.name == 'tr':
                             position = positions['tr']
                             positions['tr'] += 1
                         else:
                             position = 0
                         line, dum = RCLine.objects.update_or_create(
                             rc_configuration=self,
                             channel=i,
                             position=position,
                             defaults={
                                 'line_type': line_type,
                                 'params': json.dumps(line_data['params'])
                                 }
                             )
                         # print(line,flush=True)
                     for i, line in enumerate(self.get_lines()):
                         line_params = json.loads(line.params)
                         print("accedimos a dict_to5",flush=True)
                         if 'TX_ref' in line_params:
                             if line_params['TX_ref'] in (0, '0'):
                                 line_params['TX_ref'] = '0'
                             else:
                                 ref_id = '{}'.format(line_params['TX_ref'])
                                 ref_line = params['lines']['byId'][ref_id]
                                 line_params['TX_ref'] = RCLine.objects.get(
                                     rc_configuration=self,
                                     params=json.dumps(ref_line['params'])
                                     ).pk
                             line.params = json.dumps(line_params)
                             print(line.params)
                             line.save()
                     print("Fin de dict to param")
                 def get_delays(self):
                     pulses = [line.pulses_as_points() for line in self.get_lines()]
                     points = [tup for tups in pulses for tup in tups]
                     points = set([x for tup in points for x in tup])
                     points = list(points)
                     points.sort()
                     if points[0]!=0:
                         points.insert(0, 0)
                     return [points[i+1]-points[i] for i in range(len(points)-1)]
                 def get_pulses(self, binary=True):
                     pulses = [line.pulses_as_points() for line in self.get_lines()]
                     tuples = [tup for tups in pulses for tup in tups]
                     points = set([x for tup in tuples for x in tup])
                     points = list(points)
                     points.sort()
                     states = []
                     last = [0 for x in pulses]
                     for x in points:
                         dum = []
                         for i, tups in enumerate(pulses):
                             ups = [tup[0] for tup in tups if tup!=(0,0)]
                             dws = [tup[1] for tup in tups if tup!=(0,0)]
                             if x in ups:
                                 dum.append(1)
                             elif x in dws:
                                 dum.append(0)
                             else:
                                 dum.append(last[i])
                         states.append(dum)
                         last = dum
                     if binary:
                         ret = []
                         for flips in states:
                             flips.reverse()
                             ret.append(int(''.join([str(x) for x in flips]), 2))
                         states = ret
                     return states[:-1]
                 def add_cmd(self, cmd):
                     if cmd in DAT_CMDS:
                         return (255, DAT_CMDS[cmd])
                 def add_data(self, value):
                     return (254, value-1)
                 def parms_to_binary(self, dat=True):
                     '''
                     Create "dat" stream to be send to CR
                     '''
                     data = bytearray()
                     # create header
                     data.extend(self.add_cmd('DISABLE'))
                     data.extend(self.add_cmd('CONTINUE'))
                     data.extend(self.add_cmd('RESTART'))
                     if self.control_sw:
                         data.extend(self.add_cmd('SW_ONE'))
                     else:
                         data.extend(self.add_cmd('SW_ZERO'))
                     if self.control_tx:
                         data.extend(self.add_cmd('TX_ONE'))
                     else:
                         data.extend(self.add_cmd('TX_ZERO'))
                     # write divider
                     data.extend(self.add_cmd('CLOCK_DIVIDER'))
                     data.extend(self.add_data(self.clock_divider))
                     # write delays
                     data.extend(self.add_cmd('DELAY_START'))
                     # first delay is always zero
                     data.extend(self.add_data(1))
                     delays = self.get_delays()
                     for delay in delays:
                         while delay>252:
                             data.extend(self.add_data(253))
                             delay -= 253
                         data.extend(self.add_data(int(delay)))
                     # write flips
                     data.extend(self.add_cmd('FLIP_START'))
                     states = self.get_pulses(binary=True)
                     last = 0
                     for flip, delay in zip(states, delays):
                         data.extend(self.add_data((flip^last)+1))
                         last = flip
                         while delay>252:
                             data.extend(self.add_data(1))
                             delay -= 253
                     # write sampling period
                     data.extend(self.add_cmd('SAMPLING_PERIOD'))
                     wins = self.get_lines(line_type__name='windows')
                     if wins:
                         win_params = json.loads(wins[0].params)['params']
                         if win_params:
                             dh = int(win_params[0]['resolution']*self.km2unit)
                         else:
                             dh = 1
                     else:
                         dh = 1
                     data.extend(self.add_data(dh))
                     # write enable
                     data.extend(self.add_cmd('ENABLE'))
                     if not dat:
                         return data
                     return '\n'.join(['{}'.format(x) for x in data])
                 def update_pulses(self):
                     contador = 0
                     for line in self.get_lines():
                         contador=contador+1
                         print(contador)
                         line.update_pulses()
                 def plot_pulses2(self, km=False):
                     import matplotlib
                     matplotlib.use('Agg')
                     import matplotlib.pyplot as plt
                     from bokeh.resources import CDN
                     from bokeh.embed import components
                     from bokeh.mpl import to_bokeh
                     from bokeh.models.tools import WheelZoomTool, ResetTool, PanTool, HoverTool, SaveTool
                     lines = self.get_lines()
                     N = len(lines)
                     npoints = self.total_units/self.km2unit if km else self.total_units
                     fig = plt.figure(figsize=(12, 2+N*0.5))
                     ax = fig.add_subplot(111)
                     labels = ['IPP']
                     for i, line in enumerate(lines):
                         labels.append(line.get_name(channel=True))
                         l = ax.plot((0, npoints),(N-i-1, N-i-1))
                         points = [(tup[0], tup[1]-tup[0]) for tup in line.pulses_as_points(km=km) if tup!=(0,0)]
                         ax.broken_barh(points, (N-i-1, 0.5),
                                        edgecolor=l[0].get_color(), facecolor='none')
                     n = 0
                     f = ((self.ntx+50)/100)*5 if ((self.ntx+50)/100)*10>0 else 2
                     for x in np.arange(0, npoints, self.ipp if km else self.ipp*self.km2unit):
                         if n%f==0:
                             ax.text(x, N, '%s' % n, size=10)
                         n += 1
                     labels.reverse()
                     ax.set_yticks(range(len(labels)))
                     ax.set_yticklabels(labels)
                     ax.set_xlabel = 'Units'
                     plot = to_bokeh(fig, use_pandas=False)
                     plot.tools = [PanTool(dimensions="width"), WheelZoomTool(dimensions="width"), ResetTool(), SaveTool()]
                     plot.toolbar_location="above"
                     return components(plot, CDN)
                 def plot_pulses(self, km=False):
                     from bokeh.plotting import figure
                     from bokeh.resources import CDN
                     from bokeh.embed import components
                     from bokeh.models import FixedTicker, PrintfTickFormatter
                     from bokeh.models.tools import WheelZoomTool, ResetTool, PanTool, HoverTool, SaveTool
                     from bokeh.models.sources import ColumnDataSource
                     lines = self.get_lines().reverse()
                     N = len(lines)
                     npoints = self.total_units/self.km2unit if km else self.total_units
                     ipp = self.ipp if km else self.ipp*self.km2unit
                     hover = HoverTool(tooltips=[("Line", "@name"),
                                                 ("IPP", "@ipp"),
                                                 ("X", "@left")])
                     tools = [PanTool(dimensions="width"),
                              WheelZoomTool(dimensions="width"),
                              hover, SaveTool()]
                     plot = figure(width=1000,
                                   height=40+N*50,
                                   y_range = (0, N),
                                   tools=tools,
                                   toolbar_location='above',
                                   toolbar_sticky=False,)
                     plot.xaxis.axis_label = 'Km' if km else 'Units'
                     plot.xaxis[0].formatter = PrintfTickFormatter(format='%d')
                     plot.yaxis.axis_label = 'Pulses'
                     plot.yaxis[0].ticker=FixedTicker(ticks=list(range(N)))
                     plot.yaxis[0].formatter = PrintfTickFormatter(format='Line %d')
                     for i, line in enumerate(lines):
                         points = [tup for tup in line.pulses_as_points(km=km) if tup!=(0,0)]
                         source = ColumnDataSource(data = dict(
                                                               bottom = [i for tup in points],
                                                               top = [i+0.5 for tup in points],
                                                               left = [tup[0] for tup in points],
                                                               right = [tup[1] for tup in points],
                                                               ipp = [int(tup[0]/ipp) for tup in points],
                                                               name = [line.get_name() for tup in points]
                                                               ))
                         plot.quad(
                                  bottom = 'bottom',
                                  top = 'top',
                                  left = 'left',
                                  right = 'right',
                                  source = source,
                                  fill_alpha = 0,
                                  #line_color = 'blue',
                                  )
                         plot.line([0, npoints], [i, i])#, color='blue')
                     return components(plot, CDN)
                 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:
                         self.device.status = 0
                         payload = self.request('status')
                         if payload['status']=='enable':
                             self.device.status = 3
                         elif payload['status']=='disable':
                             self.device.status = 2
                         else:
                             self.device.status = 1
                             self.device.save()
                             self.message = 'RC status: {}'.format(payload['status'])
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         self.device.save()
                         self.message = 'RC status: {}'.format(str(e))
                         return False
                     self.device.save()
                     return True
                 def reset_device(self):
                     try:
                         payload = self.request('reset', 'post')
                         if payload['reset']=='ok':
                             self.message = 'RC restarted OK'
                             self.device.status = 2
                             self.device.save()
                         else:
                             self.message = 'RC restart fail'
                             self.device.status = 4
                             self.device.save()
                     except Exception as e:
                         self.message = 'RC reset: {}'.format(str(e))
                         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.message = 'RC stop: {}'.format(payload['stop'])
                         if payload['stop']=='ok':
                             self.device.status = 2
                             self.device.save()
                         else:
                             self.device.status = 4
                             self.device.save()
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         self.message = 'RC stop: {}'.format(str(e))
                         self.device.save()
                         return False
                     return True
                 def start_device(self):
                     try:
                         payload = self.request('start', 'post')
                         self.message = 'RC start: {}'.format(payload['start'])
                         if payload['start']=='ok':
                             self.device.status = 3
                             self.device.save()
                         else:
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         self.message = 'RC start: {}'.format(str(e))
                         self.device.save()
                         return False
                     return True
                 def write_device(self, raw=False):
                     print("write device",flush=True)
                     if not raw:
                         clock = RCClock.objects.get(rc_configuration=self)
                         if clock.mode:
                             data = {'default': clock.frequency}
                         else:
                             data = {'manual': [clock.multiplier, clock.divisor, clock.reference]}
                         payload = self.request('setfreq', 'post', data=json.dumps(data))
                         # print(payload)
                         if payload['command'] != 'ok':
                             self.message = 'RC write: {}'.format(payload['command'])
                             # print('RC write: {}'.format(payload['command']))
                         else:
                             self.message = payload['programming']
                             if payload['programming'] == 'fail':
                                 self.message = 'RC write: error programming CGS chip'
                     values = []
                     for pulse, delay in zip(self.get_pulses(), self.get_delays()):
                         while delay > 65536:
                             values.append((pulse, 65535))
                             delay -= 65536
                         values.append((pulse, delay-1))
                     data = bytearray()
                     #reset
                     data.extend((128, 0))
                     #disable
                     data.extend((129, 0))
                     #SW switch
                     if self.control_sw:
                         data.extend((130, 2))
                     else:
                         data.extend((130, 0))
                     #divider
                     data.extend((131, self.clock_divider-1))
                     #enable writing
                     data.extend((139, 62))
                     last = 0
                     for tup in values:
                         vals = pack('<HH', last^tup[0], tup[1])
                         last = tup[0]
                         data.extend((133, vals[1], 132, vals[0], 133, vals[3], 132, vals[2]))
                     #enable
                     data.extend((129, 1))
                     if raw:
                         return b64encode(data)
                     #try:
                     payload = self.request('stop', 'post')
                     payload = self.request('reset', 'post')
                     #payload = self.request('divider', 'post', data={'divider': self.clock_divider-1})
                     #payload = self.request('write', 'post', data=b64encode(bytearray((139, 62))), timeout=20)
                     n = len(data)
                     x = 0
                     #while x < n:
                     payload = self.request('write', 'post', data=b64encode(data))
                     #    x += 1024
                     if payload['write']=='ok':
                         self.device.status = 3
                         self.device.save()
                         self.message = 'RC configured and started'
                         # print('RC configured and started')
                     else:
                         self.device.status = 1
                         self.device.save()
                         self.message = 'RC write: {}'.format(payload['write'])
                         # print('RC write: {}'.format(payload['write']))
                         return False
                         #payload = self.request('start', 'post')
                     #except Exception as e:
                     #    if 'No route to host' not in str(e):
                     #        self.device.status = 4
                     #    else:
                     #        self.device.status = 0
                     #    self.message = 'RC write: {}'.format(str(e))
                     #    self.device.save()
                     #    return False
                     return True
                 def get_absolute_url_import(self):
                     return reverse('url_import_rc_conf', args=[str(self.id)])
             class RCLineCode(models.Model):
                 name = models.CharField(max_length=40)
                 bits_per_code = models.PositiveIntegerField(default=0)
                 number_of_codes = models.PositiveIntegerField(default=0)
                 codes = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'rc_line_codes'
                     ordering = ('name',)
                 def __str__(self):
                     return u'%s' % self.name
             class RCLineType(models.Model):
                 name = models.CharField(choices=LINE_TYPES, max_length=40)
                 description = models.TextField(blank=True, null=True)
                 params = models.TextField(default='[]')
                 class Meta:
                     db_table = 'rc_line_types'
                 def __str__(self):
                     return u'%s - %s' % (self.name.upper(), self.get_name_display())
             class RCLine(models.Model):
                 rc_configuration = models.ForeignKey('RCConfiguration', on_delete=models.CASCADE)
                 line_type = models.ForeignKey('RCLineType',on_delete=models.CASCADE)
                 channel = models.PositiveIntegerField(default=0)
                 position = models.PositiveIntegerField(default=0)
                 params = models.TextField(default='{}')
                 pulses = models.TextField(default='')
                 class Meta:
                     db_table = 'rc_lines'
                     ordering = ['channel']
                 def __str__(self):
                     # print("AAAA: ",self.rc_configuration,flush=True)
                     # ret = u'{}|{} - {}'.format(self.pk, self.get_name(),self.rc_configuration.name)
                     # return ret
                     if self.rc_configuration:
                         return u'{}|{} - {}'.format(self.pk, self.get_name(), self.rc_configuration.name)
                 def jsonify(self):
                     data = {}
                     data['params'] = json.loads(self.params)
                     data['id'] = '{}'.format(self.pk)
                     data['line_type'] = self.line_type.name
                     data['name'] = self.get_name()
                     if data['line_type']=='codes':
                         data['params']['code'] = RCLineCode.objects.get(pk=data['params']['code']).name
                     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 get_name(self, channel=False):
                     chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
                     s = ''
                     if self.line_type.name in ('tx',):
                         s = chars[self.position]
                     elif self.line_type.name in ('codes', 'windows', 'tr'):
                         if 'TX_ref' in json.loads(self.params):
                             pk = json.loads(self.params)['TX_ref']
                             if pk in (0, '0'):
                                 s = ','.join(chars[l.position] for l in self.rc_configuration.get_lines(line_type__name='tx'))
                             else:
                                 ref = RCLine.objects.get(pk=pk)
                                 s = chars[ref.position]
                             s = '({})'.format(s)
                     s = '{}{}'.format(self.line_type.name.upper(), s)
                     if channel:
                         return '{} {}'.format(s, self.channel)
                     else:
                         return s
                 def get_lines(self, **kwargs):
                     return RCLine.objects.filter(rc_configuration=self.rc_configuration, **kwargs)
                 def pulses_as_array(self):
                     y = np.zeros(self.rc_configuration.total_units)
                     for tup in ast.literal_eval(self.pulses):
                         y[tup[0]:tup[1]] = 1
                     return y.astype(np.int8)
                 def pulses_as_points(self, km=False):
                     if km:
                         unit2km = 1/self.rc_configuration.km2unit
                         return [(tup[0]*unit2km, tup[1]*unit2km) for tup in ast.literal_eval(self.pulses)]
                     else:
                         return ast.literal_eval(self.pulses)
                 def get_win_ref(self, params, tx_id, km2unit):
                     ref = self.rc_configuration.sampling_reference
                     codes = [line for line in self.get_lines(line_type__name='codes') if int(json.loads(line.params)['TX_ref'])==int(tx_id)]
                     if codes:
                         tx_width = float(json.loads(RCLine.objects.get(pk=tx_id).params)['pulse_width'])*km2unit/len(json.loads(codes[0].params)['codes'][0])
                     else:
                         tx_width = float(json.loads(RCLine.objects.get(pk=tx_id).params)['pulse_width'])*km2unit
                     if ref=='first_baud':
                         return int(1 + round((tx_width + 1)/2 + params['first_height']*km2unit - params['resolution']*km2unit))
                     elif ref=='sub_baud':
                         return np.ceil(1 + params['first_height']*km2unit - params['resolution']*km2unit/2)
                     else:
                         return 0
                 def update_pulses(self):
                     '''
                     Update pulses field
                     '''
                     km2unit = self.rc_configuration.km2unit
                     us2unit = self.rc_configuration.us2unit
                     ipp = self.rc_configuration.ipp
                     ntx = int(self.rc_configuration.ntx)
                     ipp_u = int(ipp*km2unit)
                     total = ipp_u*ntx if self.rc_configuration.total_units==0 else self.rc_configuration.total_units
                     y = []
                     if self.line_type.name=='tr':
                         tr_params = json.loads(self.params)
                         #print(tr_params)
                         #print(tr_params['TX_ref'])
                         if tr_params['TX_ref'] in ('0', 0):
                             txs = self.get_lines(line_type__name='tx')
                         else:
                             txs = RCLine.objects.filter(pk=tr_params['TX_ref'])
                         for tx in txs:
                             params = json.loads(tx.params)
                             if float(params['pulse_width'])==0:
                                 continue
                             delays = [float(d)*km2unit for d in params['delays'].split(',') if d]
                             width = float(params['pulse_width'])*km2unit+int(self.rc_configuration.time_before*us2unit)
                             before = 0
                             after = int(self.rc_configuration.time_after*us2unit)
                             y_tx = self.points(ntx, ipp_u, width,
                                                delay=delays,
                                                before=before,
                                                after=after,
                                                sync=self.rc_configuration.sync)
                             ranges = params['range'].split(',')
                             if len(ranges)>0 and ranges[0]!='0':
                                 y_tx = self.mask_ranges(y_tx, ranges)
                             tr_ranges = tr_params['range'].split(',')
                             if len(tr_ranges)>0 and tr_ranges[0]!='0':
                                 y_tx = self.mask_ranges(y_tx, tr_ranges)
                             y.extend(y_tx)
                         self.pulses = str(y)
                         y = self.array_to_points(self.pulses_as_array())
                     elif self.line_type.name=='tx':
                         params = json.loads(self.params)
                         delays = [float(d)*km2unit for d in params['delays'].split(',') if d]
                         width = float(params['pulse_width'])*km2unit
                         if width>0:
                             before = int(self.rc_configuration.time_before*us2unit)
                             after = 0
                             y = self.points(ntx, ipp_u, width,
                                             delay=delays,
                                             before=before,
                                             after=after,
                                             sync=self.rc_configuration.sync)
                             ranges = params['range'].split(',')
                             if len(ranges)>0 and ranges[0]!='0':
                                 y = self.mask_ranges(y, ranges)
                     elif self.line_type.name=='flip':
                         n = float(json.loads(self.params)['number_of_flips'])
                         width = n*ipp*km2unit
                         y = self.points(int((ntx+1)/(2*n)), ipp_u*n*2, width)
                     elif self.line_type.name=='codes':
                         params = json.loads(self.params)
                         tx = RCLine.objects.get(pk=params['TX_ref'])
                         tx_params = json.loads(tx.params)
                         delays = [float(d)*km2unit for d in tx_params['delays'].split(',') if d]
                         f = int(float(tx_params['pulse_width'])*km2unit/len(params['codes'][0]))
                         codes = [(np.fromstring(''.join([s*f for s in code]), dtype=np.uint8)-48).astype(np.int8) for code in params['codes']]
                         codes = [self.array_to_points(code) for code in codes]
                         n = len(codes)
                         ranges = tx_params['range'].split(',')
                         if len(ranges)>0 and ranges[0]!='0':
                             dum = self.mask_ranges(tx.pulses_as_points(), ranges)
                         else:
                             dum = tx.pulses_as_points()
                         for i, tup in enumerate(dum):
                             if tup==(0,0): continue
                             code = codes[i%n]
                             y.extend([(c[0]+tup[0], c[1]+tup[0]) for c in code])
                     elif self.line_type.name=='sync':
                         params = json.loads(self.params)
                         n = ipp_u*ntx
                         if params['invert'] in ('1', 1):
                             y = [(n-1, n)]
                         else:
                             y = [(0, 1)]
                     elif self.line_type.name=='prog_pulses':
                         params = json.loads(self.params)
                         if int(params['periodic'])==0:
                             nntx = 1
                             nipp = ipp_u*ntx
                         else:
                             nntx = ntx
                             nipp = ipp_u
                         if 'params' in params and len(params['params'])>0:
                             for p in params['params']:
                                 y_pp = self.points(nntx, nipp,
                                                    p['end']-p['begin'],
                                                    before=p['begin'])
                                 y.extend(y_pp)
                     elif self.line_type.name=='windows':
                         params = json.loads(self.params)
                         if 'params' in params and len(params['params'])>0:
                             tx = RCLine.objects.get(pk=params['TX_ref'])
                             tx_params = json.loads(tx.params)
                             ranges = tx_params['range'].split(',')
                             for p in params['params']:
                                 y_win = self.points(ntx, ipp_u,
                                                     p['resolution']*p['number_of_samples']*km2unit,
                                                     before=int(self.rc_configuration.time_before*us2unit)+p['first_height']*km2unit,
                                                     sync=self.rc_configuration.sync+self.get_win_ref(p, params['TX_ref'], km2unit))
                                 if len(ranges)>0 and ranges[0]!='0':
                                     y_win = self.mask_ranges(y_win, ranges)
                                 y.extend(y_win)
                     elif self.line_type.name=='mix':
                         values = self.rc_configuration.parameters.split('-')
                         confs = [RCConfiguration.objects.get(pk=value.split('|')[0]) for value in values]
                         modes = [value.split('|')[1] for value in values]
                         ops = [value.split('|')[2] for value in values]
                         delays = [value.split('|')[3] for value in values]
                         masks = [value.split('|')[4] for value in values]
                         print("masks")
                         print(masks)
                         print('{:8b}'.format(int(masks[0])))
                         mask = list('{:8b}'.format(int(masks[0])))
                         print("mask")
                         print(mask)
                         mask.reverse()
                         print("mask reverse")
                         print(mask)
                         if mask[self.channel] in ('0', '', ' '):
                             y = np.zeros(confs[0].total_units, dtype=np.int8)
                         else:
                             y = confs[0].get_lines(channel=self.channel)[0].pulses_as_array()
                         for i in range(1, len(values)):
                             mask = list('{:8b}'.format(int(masks[i])))
                             mask.reverse()
                             if mask[self.channel] in ('0', '', ' '):
                                 continue
                             Y = confs[i].get_lines(channel=self.channel)[0].pulses_as_array()
                             delay = float(delays[i])*km2unit
                             if modes[i]=='P':
                                 if delay>0:
                                     if delay<self.rc_configuration.ipp*km2unit and len(Y)==len(y):
                                         y_temp = np.empty_like(Y)
                                         y_temp[:delay] = 0
                                         y_temp[delay:] = Y[:-delay]
                                     elif delay+len(Y)>len(y):
                                         y_new = np.zeros(delay+len(Y), dtype=np.int8)
                                         y_new[:len(y)] = y
                                         y = y_new
                                         y_temp = np.zeros(delay+len(Y), dtype=np.int8)
                                         y_temp[-len(Y):] = Y
                                     elif delay+len(Y)==len(y):
                                         y_temp = np.zeros(delay+len(Y))
                                         y_temp[-len(Y):] = Y
                                     elif delay+len(Y)<len(y):
                                         y_temp = np.zeros(len(y), dtype=np.int8)
                                         y_temp[delay:delay+len(Y)] = Y
                                 else:
                                     y_temp = Y.copy()
                                 if ops[i]=='OR':
                                     y = y | y_temp
                                 elif ops[i]=='XOR':
                                     y = y ^ y_temp
                                 elif ops[i]=='AND':
                                     y = y & y_temp
                                 elif ops[i]=='NAND':
                                     y = y & ~y_temp
                             else:
                                 y = np.concatenate([y, Y])
                         total = len(y)
                         y = self.array_to_points(y)
                     else:
                         y = []
                     if self.rc_configuration.total_units != total:
                         self.rc_configuration.total_units = total
                         self.rc_configuration.save()
                     self.pulses = str(y)
                     self.save()
                 @staticmethod
                 def array_to_points(X):
                     if X.size==0:
                         return []
                     d = X[1:]-X[:-1]
                     up = np.where(d==1)[0]
                     if X[0]==1:
                         up = np.concatenate((np.array([-1]), up))
                     up += 1
                     dw = np.where(d==-1)[0]
                     if X[-1]==1:
                         dw = np.concatenate((dw, np.array([len(X)-1])))
                     dw += 1
                     return [(tup[0], tup[1]) for tup in zip(up, dw)]
                 @staticmethod
                 def mask_ranges(Y, ranges):
                     y = [(0, 0) for __ in Y]
                     for index in ranges:
                         if '-' in index:
                             args = [int(a) for a in index.split('-')]
                             y[args[0]-1:args[1]] = Y[args[0]-1:args[1]]
                         else:
                             y[int(index)-1] = Y[int(index)-1]
                     return y
                 @staticmethod
                 def points(ntx, ipp, width, delay=[0], before=0, after=0, sync=0):
                     delays = len(delay)
                     Y = [(int(ipp*x+before+delay[x%delays]+sync), int(ipp*x+width+before+delay[x%delays]+after+sync)) for x in range(ntx)]
                     return Y
             class RCClock(models.Model):
                 rc_configuration = models.ForeignKey('RCConfiguration', on_delete=models.CASCADE)
                 mode = models.BooleanField(default=True, choices=((True, 'Auto'), (False, 'Manual')))
                 multiplier = models.PositiveIntegerField(default=60)
                 divisor = models.PositiveIntegerField(default=10)
                 reference = models.PositiveSmallIntegerField(default=1, choices=((0, 'Internal (25MHz)'), (1, 'External (10MHz)')))
                 frequency = models.FloatField(default=60.0)

General Comments 0

Write
Preview

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

No TODOs yet

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

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