radarsys_met Commit - r337:0cdf785c9933

Actualizacion campos y correccion app abs 1sem Sep

gonzalesluisfrancisco -

r337:0cdf785c9933

parent child

Context file:

r337:0cdf785c9933

Collapse all files

apps/abs/admin.py +2 -1

             from django.contrib import admin
-            from .models import ABSConfiguration, ABSBeam
+            from .models import ABSConfiguration, ABSBeam, ABSActive
             # Register your models here.
             admin.site.register(ABSConfiguration)
             admin.site.register(ABSBeam)
+            admin.site.register(ABSActive)
  No newline at end of file

apps/abs/models.py +10 -1

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

apps/dds/static/js/dds_conversion.js +8 -1

             function freq2Binary(mclock, frequency) {
                 var freq_bin = parseInt(frequency * (Math.pow(2,48)/mclock));
                 return freq_bin;
             }
             function binary2Freq(mclock, binary) {
                 var frequency = (1.0*binary) / (Math.pow(2,48)/mclock);
                 return frequency;
             }
             function binary2FreqDelta(mclock, binary) {
                 var frequency = (1.0*binary) / (Math.pow(2,48)/mclock);
                 return frequency;
             }
             function freqDelta2Binary(mclock, frequency) {
                 var freq_bin = parseInt(frequency * (Math.pow(2,48)/mclock));
                 return freq_bin;
             }
             function binary2Ramp(mclock, binary) {
                 var frequency = (1.0*mclock) / (binary+1);
                 return frequency;
             }
             function freqRamp2Binary(mclock, frequency) {
                 var freq_bin = parseInt(mclock/frequency-1);
                 return freq_bin;
-            }    
  No newline at end of file
+            function us2Ramp(step_us) {
+                //periodo_delpaso = sysclockperiod x (N+1)
+                // freqsys/(N+1)=freq_ddelpaso=1/step
+                var freq = (1.0/(step_us));
+                return freq;
+            }       
  No newline at end of file

apps/dds_rest/models.py +36 -17

             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)
+                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)
+                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)
+                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)
+                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)
+                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)
+                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):
                     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):
                     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 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
+                    phaseA_degrees = self.phaseA_degrees or 0
                     print(phaseA_degrees)
-                    phaseB_degrees = self.phaseB_degrees
+                    phaseB_degrees = self.phaseB_degrees or 0
                     print(phaseB_degrees)
-                    modulation = self.modulation
+                    modulation = self.modulation or 0
                     print(modulation)
-                    amplitude_enabled = self.amplitude_enabled
+                    amplitude_enabled = self.amplitude_enabled or 0
                     print(amplitude_enabled)
-                    amplitudeI = self.amplitudeI
+                    amplitudeI = self.amplitudeI or 0
                     print(amplitudeI)
-                    amplitudeQ = self.amplitudeQ
+                    amplitudeQ = self.amplitudeQ or 0
                     print(amplitudeQ)
-                    delta_frequency = self.delta_frequency
+                    delta_frequency = self.delta_frequency or 0
                     print(delta_frequency)
-                    update_clock = self.update_clock
+                    update_clock = self.update_clock or 0
                     print(update_clock)
-                    ramp_rate_clock = self.ramp_rate_clock
+                    ramp_rate_clock = self.ramp_rate_clock or 0
                     print(ramp_rate_clock)
+                    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((ramp_rate_clock).to_bytes(4,'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(3,'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")
                     }
                     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/dds_rest/static/js/dds_conversion.js +13 0

                 function freq2Binary(mclock, frequency) {
                 	var freq_bin = parseInt(frequency * (Math.pow(2,48)/mclock));
                 	return freq_bin;
                 }
                 function binary2Freq(mclock, binary) {
                 	var frequency = (1.0*binary) / (Math.pow(2,48)/mclock);
                 	return frequency;
                 }
                 function binary2FreqDelta(mclock, binary) {
                 	var frequency = (1.0*binary) / (Math.pow(2,48)/mclock);
                 	return frequency;
                 }
                 function freqDelta2Binary(mclock, frequency) {
                 	var freq_bin = parseInt(frequency * (Math.pow(2,48)/mclock));
                 	return freq_bin;
                 }
                 function binary2Ramp(mclock, binary) {
                 	var frequency = (1.0*mclock) / (binary+1);
                 	return frequency;
                 }
                 function freqRamp2Binary(mclock, frequency) {
                 	var freq_bin = parseInt(mclock/frequency-1);
                 	return freq_bin;
+                }
+                function us2Ramp(step_us) {
+                    //periodo_delpaso = sysclockperiod x (N+1)
+                    // freqsys/(N+1)=freq_ddelpaso=1/step
+                	var freq = (1.0/(step_us));
+                	return freq;
+                }
+                function phase2Binary(phase) {
+                	var phase_bin = parseInt(phase*(Math.pow(2,48))/360);
+                	return phase_bin;
                 }

apps/dds_rest/templates/dds_rest_conf_edit.html +319 -14

@@ -1,158 +1,463
1	{% extends "dev_conf_edit.html" %}	1	{% extends "dev_conf_edit.html" %}
2	{% load bootstrap4 %}	2	{% load bootstrap4 %}
3	{% load static %}	3	{% load static %}
4	{% load main_tags %}	4	{% load main_tags %}
5		5
		6	{% block dds_rest%}
		7
		8	{% bootstrap_field form.template layout='horizontal' size='medium' %}
		9	{% bootstrap_field form.device layout='horizontal' size='medium' %}
		10	{% bootstrap_field form.label layout='horizontal' size='medium' %}
		11	{% bootstrap_field form.experiment layout='horizontal' size='medium' %}
		12
		13	{% bootstrap_field form.clock layout='horizontal' size='medium' %}
		14	{% bootstrap_field form.multiplier layout='horizontal' size='medium' %}
		15
		16	<div style="display: flex; justify-content: flex-end">
		17	<div class="form-check">
		18	<label class="form-check-label" ><input type="checkbox" class="form-check-input" id="id_chkbin_fA" value="" >Mostrar Decimal</label>
		19	</div>
		20	</div>
		21	{% bootstrap_field form.frequencyA_Mhz layout='horizontal' size='medium' %}
		22	<div id='id_row_fAbin'>
		23	{% bootstrap_field form.frequencyA layout='horizontal' size='medium' %}
		24	<div style="display: flex; justify-content: flex-end">
		25	<small type="text" id="id_aux_fAbin" class="form-text text-muted">1000 0000 </small>
		26	</div>
		27	<br>
		28	</div>
		29
		30	<div style="display: flex; justify-content: flex-end">
		31	<div class="form-check">
		32	<label class="form-check-label" ><input type="checkbox" class="form-check-input" id="id_chkbin_fB" value="" >Mostrar Decimal</label>
		33	</div>
		34	</div>
		35	{% bootstrap_field form.frequencyB_Mhz layout='horizontal' size='medium' %}
		36	<div id='id_row_fBbin'>
		37	{% bootstrap_field form.frequencyB layout='horizontal' size='medium' %}
		38	<div style="display: flex; justify-content: flex-end">
		39	<small type="text" id="id_aux_fBbin" class="form-text text-muted">1000 0000 </small>
		40	</div>
		41	<br>
		42	</div>
		43
		44	<div style="display: flex; justify-content: flex-end">
		45	<div class="form-check">
		46	<label class="form-check-label" ><input type="checkbox" class="form-check-input" id="id_chkbin_df" value="" >Mostrar Decimal</label>
		47	</div>
		48	</div>
		49	{% bootstrap_field form.delta_frequency_Mhz layout='horizontal' size='medium' %}
		50	<div id='id_row_dfbin'>
		51	{% bootstrap_field form.delta_frequency layout='horizontal' size='medium' %}
		52	<div style="display: flex; justify-content: flex-end">
		53	<small type="text" id="id_aux_deltabin" class="form-text text-muted">1000 0000 </small>
		54	</div>
		55	<br>
		56	</div>
		57
		58	<div style="display: flex; justify-content: flex-end">
		59	<div class="form-check">
		60	<label class="form-check-label" ><input type="checkbox" class="form-check-input" id="id_chkbin_ramp" value="" >Mostrar Decimal</label>
		61	</div>
		62	</div>
		63	<div class="form-group row">
		64	<label class="col-md-3 col-form-label" for="id_ramp_rate_clock_us">Ramp rate clock(us)</label>
		65	<div class="col-md-9">
		66	<input type="number" name="ramp_rate_clock_us" step="1e-16" class="form-control" placeHolder="Ramp rate clock(us)" title id="id_ramp_rate_clock_us">
		67	</div>
		68	</div>
		69	<div id='id_row_rampbin'>
		70	{% bootstrap_field form.ramp_rate_clock_Mhz layout='horizontal' size='medium' %}
		71	{% bootstrap_field form.ramp_rate_clock layout='horizontal' size='medium' %}
		72	<div style="display: flex; justify-content: flex-end">
		73	<small type="text" id="id_aux_rampbin" class="form-text text-muted">1000 0000 </small>
		74	</div>
		75	<br>
		76	</div>
		77
		78	<div style="display: flex; justify-content: flex-end">
		79	<div class="form-check">
		80	<label class="form-check-label" ><input type="checkbox" class="form-check-input" id="id_chkbin_phaseA" value="" >Mostrar Decimal</label>
		81	</div>
		82	</div>
		83	{% bootstrap_field form.phaseA_degrees layout='horizontal' size='medium' %}
		84	<div id='id_row_phaseA'>
		85	<div style="display: flex; justify-content: flex-end">
		86	<small type="text" id="id_aux_phaseAdec" class="form-text text-muted">9282 </small>
		87	</div>
		88	<div style="display: flex; justify-content: flex-end">
		89	<small type="text" id="id_aux_phaseAbin" class="form-text text-muted">1000 0000 </small>
		90	</div>
		91	<br>
		92	</div>
		93
		94	<div style="display: flex; justify-content: flex-end">
		95	<div class="form-check">
		96	<label class="form-check-label" ><input type="checkbox" class="form-check-input" id="id_chkbin_phaseB" value="" >Mostrar Decimal</label>
		97	</div>
		98	</div>
		99	{% bootstrap_field form.phaseB_degrees layout='horizontal' size='medium' %}
		100	<div id='id_row_phaseB'>
		101	<div style="display: flex; justify-content: flex-end">
		102	<small type="text" id="id_aux_phaseBdec" class="form-text text-muted">9876 </small>
		103	</div>
		104	<div style="display: flex; justify-content: flex-end">
		105	<small type="text" id="id_aux_phaseBbin" class="form-text text-muted">1000 0000 </small>
		106	</div>
		107	<br>
		108	</div>
		109
		110	{% bootstrap_field form.modulation layout='horizontal' size='medium' %}
		111	{% bootstrap_field form.amplitude_enabled layout='horizontal' size='medium' %}
		112
		113	{% bootstrap_field form.amplitudeI layout='horizontal' size='medium' %}
		114	{% bootstrap_field form.amplitudeQ layout='horizontal' size='medium' %}
		115
		116
		117	{% endblock %}
		118
6	{% block extra-js%}	119	{% block extra-js%}
7	<script src="{% static 'js/dds_conversion.js' %}"></script>	120	<script src="{% static 'js/dds_conversion.js' %}"></script>
8	<script type="text/javascript">	121	<script type="text/javascript">
		122	$("#id_row_fAbin").hide();
		123	$("#id_chkbin_fA").on('change', function() {
		124	hidefA();
		125	});
		126
		127	$("#id_row_fBbin").hide();
		128	$("#id_chkbin_fB").on('change', function() {
		129	hidefB();
		130	});
		131
		132	$("#id_row_dfbin").hide();
		133	$("#id_chkbin_df").on('change', function() {
		134	hidedf();
		135	});
		136
		137	$("#id_row_rampbin").hide();
		138	$("#id_chkbin_ramp").on('change', function() {
		139	hideramp();
		140	});
9		141
		142	$("#id_row_phaseA").hide();
		143	$("#id_chkbin_phaseA").on('change', function() {
		144	hidephaseA();
		145	});
		146
		147	$("#id_row_phaseB").hide();
		148	$("#id_chkbin_phaseB").on('change', function() {
		149	hidephaseB();
		150	});
		151
10	$("#id_clock").on('change', function() {	152	$("#id_clock").on('change', function() {
11	updateFrequencies();	153	updateFrequencies();
12	});	154	});
13		155
14	$("#id_multiplier").on('change', function() {	156	$("#id_multiplier").on('change', function() {
15	updateFrequencies();	157	updateFrequencies();
16	});	158	});
17		159
18	$("#id_frequencyA_Mhz").on('change', function() {	160	$("#id_frequencyA_Mhz").on('change', function() {
19	updateBinaryFrequencies();	161	updateBinaryFrequencies();
20	});	162	});
21		163
22	$("#id_frequencyA").on('change', function() {	164	$("#id_frequencyA").on('change', function() {
23	updateFrequencies();	165	updateFrequencies();
24	});	166	});
25		167
26	$("#id_frequencyB_Mhz").on('change', function() {	168	$("#id_frequencyB_Mhz").on('change', function() {
27	updateBinaryFrequencies();	169	updateBinaryFrequencies();
28	});	170	});
29		171
30	$("#id_frequencyB").on('change', function() {	172	$("#id_frequencyB").on('change', function() {
31	updateFrequencies();	173	updateFrequencies();
32	});	174	});
33		175
34	$("#id_delta_frequency").on('change', function() {	176	$("#id_delta_frequency").on('change', function() {
35	updateFrequencyDelta();	177	updateFrequencyDelta();
36	});	178	});
37		179
38	$("#id_delta_frequency_Mhz").on('change', function() {	180	$("#id_delta_frequency_Mhz").on('change', function() {
39	updateBinaryFrequencyDelta();	181	updateBinaryFrequencyDelta();
40	});	182	});
41		183
42	$("#id_ramp_rate_clock").on('change', function() {	184	$("#id_ramp_rate_clock").on('change', function() {
43	updateFrequencyRamp();	185	updateFrequencyRamp();
44	});	186	});
45		187
		188	$("#id_ramp_rate_clock_us").on('change', function() {
		189	updateFrequencyMhzRamp();
		190	});
		191
46	$("#id_ramp_rate_clock_Mhz").on('change', function() {	192	$("#id_ramp_rate_clock_Mhz").on('change', function() {
47	updateBinaryFrequencyRamp();	193	updateBinaryFrequencyRamp();
48	});	194	});
49		195
		196	$("#id_phaseA_degrees").on('change', function() {
		197	updatephaseAbindec();
		198	});
		199
		200	$("#id_phaseB_degrees").on('change', function() {
		201	updatephaseBbindec();
		202	});
		203
50	function updateBinaryFrequencies() {	204	function updateBinaryFrequencies() {
51		205
52	var clock = $("#id_clock").val();	206	var clock = $("#id_clock").val();
53	var multiplier = $("#id_multiplier").val();	207	var multiplier = $("#id_multiplier").val();
54	var freq = $("#id_frequencyA_Mhz").val();	208	var freq = $("#id_frequencyA_Mhz").val();
55	var freq_mod = $("#id_frequencyB_Mhz").val();	209	var freq_mod = $("#id_frequencyB_Mhz").val();
56	//var freq_delta = $("#id_delta_frequency_Mhz").val();
57	//var freq_ramp = $("#id_ramp_rate_clock_Mhz").val();
58		210
59	var mclock = clock*multiplier;	211	var mclock = clock*multiplier;
60		212
61	var freq_bin = freq2Binary(mclock, freq);	213	var freq_bin = freq2Binary(mclock, freq);
62	var freq_mod_bin = freq2Binary(mclock, freq_mod);	214	var freq_mod_bin = freq2Binary(mclock, freq_mod);
63	//var freqdelta_bin = freqDelta2Binary(mclock, freq_delta);
64	//var freqramp_bin = freqRamp2Binary(mclock, freq_ramp);
65		215
66	$("#id_frequencyA").val(freq_bin);	216	$("#id_frequencyA").val(freq_bin);
67	$("#id_frequencyB").val(freq_mod_bin);	217	$("#id_frequencyB").val(freq_mod_bin);
68	//$("#id_delta_frequency").val(freqdelta_bin);
69	//$("#id_ramp_rate_clock").val(freqramp_bin);
70		218
71	freq = binary2Freq(mclock, freq_bin);	219	freq = binary2Freq(mclock, freq_bin);
72	freq_mod = binary2Freq(mclock, freq_mod_bin);	220	freq_mod = binary2Freq(mclock, freq_mod_bin);
73	//freqdelta = binary2FreqDelta(mclock, freqdelta_bin);
74	//freq_ramp = binary2Ramp(mclock, freqramp_bin);
75		221
76	$("#id_frequencyA_Mhz").val(freq);	222	$("#id_frequencyA_Mhz").val(freq);
77	$("#id_frequencyB_Mhz").val(freq_mod);	223	$("#id_frequencyB_Mhz").val(freq_mod);
78	//$("#id_delta_frequency_Mhz").val(freqdelta);
79	//$("#id_ramp_rate_clock_Mhz").val(freq_ramp);
80		224
81	}	225	}
82		226
83	function updateFrequencies() {	227	function updateFrequencies() {
84	console.log("Ingreso a updateFrequencies");	228	console.log("Ingreso a updateFrequencies");
85	var clock = $("#id_clock").val();	229	var clock = $("#id_clock").val();
86	var multiplier = $("#id_multiplier").val();	230	var multiplier = $("#id_multiplier").val();
87	var freq_bin = $("#id_frequencyA").val();	231	var freq_bin = $("#id_frequencyA").val();
88	var freq_mod_bin = $("#id_frequencyB").val();	232	var freq_mod_bin = $("#id_frequencyB").val();
89	var freqdelta_bin = $("#id_delta_frequency").val();	233	var freqdelta_bin = $("#id_delta_frequency").val();
90	var freqramp_bin = $("#id_ramp_rate_clock").val();	234	var freqramp_bin = $("#id_ramp_rate_clock").val();
91		235
92	var mclock = clock*multiplier;	236	var mclock = clock*multiplier;
93		237
94	var freq = binary2Freq(mclock, freq_bin);	238	var freq = binary2Freq(mclock, freq_bin);
95	var freq_mod = binary2Freq(mclock, freq_mod_bin);	239	var freq_mod = binary2Freq(mclock, freq_mod_bin);
96	var freqdelta = binary2FreqDelta(mclock, freqdelta_bin);	240	var freqdelta = binary2FreqDelta(mclock, freqdelta_bin);
97	var freq_ramp = binary2Ramp(mclock, freqramp_bin);	241	var freq_ramp = binary2Ramp(mclock, freqramp_bin);
98		242
99	$("#id_frequencyA_Mhz").val(freq);	243	$("#id_frequencyA_Mhz").val(freq);
100	$("#id_frequencyB_Mhz").val(freq_mod);	244	$("#id_frequencyB_Mhz").val(freq_mod);
101	$("#id_delta_frequency_Mhz").val(freqdelta);	245	$("#id_delta_frequency_Mhz").val(freqdelta);
102	$("#id_ramp_rate_clock_Mhz").val(freq_ramp);	246	$("#id_ramp_rate_clock_Mhz").val(freq_ramp);
103	}	247	}
104		248
105	function updateFrequencyDelta() {	249	function updateFrequencyDelta() {
106	console.log("Ingreso a updateFrequencyDelta");	250	console.log("Ingreso a updateFrequencyDelta");
107	var clock = $("#id_clock").val();	251	var clock = $("#id_clock").val();
108	var multiplier = $("#id_multiplier").val();	252	var multiplier = $("#id_multiplier").val();
109	var freq_bin = $("#id_delta_frequency").val();	253	var freq_bin = $("#id_delta_frequency").val();
110		254
111	var mclock = clock*multiplier;	255	var mclock = clock*multiplier;
112		256
113	var freq = binary2FreqDelta(mclock, freq_bin);	257	var freq = binary2FreqDelta(mclock, freq_bin);
114	console.log(freq);	258	console.log(freq);
115	$("#id_delta_frequency_Mhz").val(freq);	259	$("#id_delta_frequency_Mhz").val(freq);
116	}	260	}
117		261
118	function updateBinaryFrequencyDelta() {	262	function updateBinaryFrequencyDelta() {
119	console.log("Ingreso a updateBInaryFrequencyDelta");	263	console.log("Ingreso a updateBInaryFrequencyDelta");
120	var clock = $("#id_clock").val();	264	var clock = $("#id_clock").val();
121	var multiplier = $("#id_multiplier").val();	265	var multiplier = $("#id_multiplier").val();
122	var freq = $("#id_delta_frequency_MHz").val();	266	var freq = $("#id_delta_frequency_Mhz").val();
		267	console.log(clock);
		268	console.log(multiplier);
		269	console.log(freq);
123		270
124	var mclock = clock*multiplier;	271	var mclock = clock*multiplier;
125		272	console.log(mclock);
		273
126	var freq_bin = freqDelta2Binary(mclock, freq);	274	var freq_bin = freqDelta2Binary(mclock, freq);
		275
127	console.log(freq_bin);	276	console.log(freq_bin);
128	$("#id_delta_frequency").val(freq_bin);	277	$("#id_delta_frequency").val(freq_bin);
		278
		279	document.getElementById("id_aux_deltabin").innerHTML = numToString(parseInt(freq_bin, 10), 2, 48).match(/.{1,4}/g).join(' ');
129	}	280	}
130		281
131	function updateFrequencyRamp() {	282	function updateFrequencyRamp() {
132	console.log("Ingreso a updateFrequencyRamp");	283	console.log("Ingreso a updateFrequencyRamp");
133	var clock = $("#id_clock").val();	284	var clock = $("#id_clock").val();
134	var multiplier = $("#id_multiplier").val();	285	var multiplier = $("#id_multiplier").val();
135	var freq_bin = $("#id_ramp_rate_clock").val();	286	var freq_bin = $("#id_ramp_rate_clock").val();
136		287
137	var mclock = clock*multiplier;	288	var mclock = clock*multiplier;
138		289
139	var freq = binary2Ramp(mclock, freq_bin);	290	var freq = binary2Ramp(mclock, freq_bin);
140	console.log(freq);	291	console.log(freq);
141	$("#id_ramp_rate_clock_Mhz").val(freq);	292	$("#id_ramp_rate_clock_Mhz").val(freq);
142	}	293	}
143		294
144	function updateBinaryFrequencyRamp() {	295	function updateBinaryFrequencyRamp() {
145	console.log("Ingreso a updateBInaryFrequencyRamp");	296	console.log("Ingreso a updateBInaryFrequencyRamp");
146	var clock = $("#id_clock").val();	297	var clock = $("#id_clock").val();
147	var multiplier = $("#id_multiplier").val();	298	var multiplier = $("#id_multiplier").val();
148	var freq = $("#id_ramp_rate_clock_MHz").val();	299	var freq = $("#id_ramp_rate_clock_Mhz").val();
149		300
150	var mclock = clock*multiplier;	301	var mclock = clock*multiplier;
151		302
152	var freq_bin = freqRamp2Binary(mclock, freq);	303	var freq_bin = freqRamp2Binary(mclock, freq);
153	console.log(freq_bin);	304	console.log(freq_bin);
154	$("#id_ramp_rate_clock").val(freq_bin);	305	$("#id_ramp_rate_clock").val(freq_bin);
155	}	306	}
156		307
		308	function updateFrequencyMhzRamp() {
		309	console.log("Ingreso a updateFrequencyMhzRamp");
		310	var step_us = $("#id_ramp_rate_clock_us").val();
		311
		312	var freq = us2Ramp(step_us);
		313	console.log(freq);
		314	$("#id_ramp_rate_clock_Mhz").val(freq);
		315	updateBinaryFrequencyRamp();
		316	}
		317
		318	function hidefA() {
		319	var checkbox = $("#id_chkbin_fA");
		320	var freq_bin = $("#id_row_fAbin");
		321	var val_freq = $("#id_frequencyA");
		322
		323	console.log("Ingreso a hidefA");
		324	if (checkbox.is(':checked')) {
		325	freq_bin.show();
		326	console.log(val_freq.val());
		327	document.getElementById("id_aux_fAbin").innerHTML = numToString(parseInt(val_freq.val(), 10), 2, 48).match(/.{1,4}/g).join(' ');
		328	}
		329	else{
		330	freq_bin.hide();
		331	}
		332	}
		333
		334	function hidefB() {
		335	var checkbox = $("#id_chkbin_fB");
		336	var freq_bin = $("#id_row_fBbin");
		337	var val_freq = $("#id_frequencyB");
		338
		339	console.log("Ingreso a hidefB");
		340	if (checkbox.is(':checked')) {
		341	freq_bin.show();
		342	console.log(val_freq.val());
		343	document.getElementById("id_aux_fBbin").innerHTML = numToString(parseInt(val_freq.val(), 10), 2, 48).match(/.{1,4}/g).join(' ');
		344	}
		345	else{
		346	freq_bin.hide();
		347	}
		348	}
		349
		350	function hidedf() {
		351	var checkbox = $("#id_chkbin_df");
		352	var freq_bin = $("#id_row_dfbin");
		353	var val_freq = $("#id_delta_frequency");
		354
		355	console.log("Ingreso a hidedf");
		356	if (checkbox.is(':checked')) {
		357	freq_bin.show();
		358	console.log(val_freq.val());
		359	document.getElementById("id_aux_deltabin").innerHTML = numToString(parseInt(val_freq.val(), 10), 2, 48).match(/.{1,4}/g).join(' ');
		360	}
		361	else{
		362	freq_bin.hide();
		363	}
		364	}
		365
		366	function hideramp() {
		367	var checkbox = $("#id_chkbin_ramp");
		368	var freq_bin = $("#id_row_rampbin");
		369	var val_freq = $("#id_ramp_rate_clock");
		370
		371	console.log("Ingreso a hideramp");
		372	if (checkbox.is(':checked')) {
		373	freq_bin.show();
		374	console.log(val_freq.val());
		375	document.getElementById("id_aux_rampbin").innerHTML = numToString(parseInt(val_freq.val(), 10), 2, 20).match(/.{1,4}/g).join(' ');
		376	}
		377	else{
		378	freq_bin.hide();
		379	}
		380	}
		381
		382	function hidephaseA() {
		383	var checkbox = $("#id_chkbin_phaseA");
		384	var freq_bin = $("#id_row_phaseA");
		385	var phase_degree = $("#id_phaseA_degrees");
		386
		387	console.log("Ingreso a hidephaseA");
		388	if (checkbox.is(':checked')) {
		389	freq_bin.show();
		390	console.log(phase_degree.val());
		391	var phase_degree_dec = parseInt(phase_degree.val()((2*14)/360.0),10);
		392	console.log(phase_degree_dec);
		393	document.getElementById("id_aux_phaseAdec").innerHTML = numToString(phase_degree_dec, 10, 5).match(/.{1,4}/g).join(' ');
		394	document.getElementById("id_aux_phaseAbin").innerHTML = numToString(parseInt(phase_degree_dec, 10), 2, 14).match(/.{1,4}/g).join(' ');
		395
		396	}
		397	else{
		398	freq_bin.hide();
		399	}
		400	}
		401
		402	function hidephaseB() {
		403	var checkbox = $("#id_chkbin_phaseB");
		404	var freq_bin = $("#id_row_phaseB");
		405	var phase_degree = $("#id_phaseB_degrees");
		406
		407	console.log("Ingreso a hidephaseB");
		408	if (checkbox.is(':checked')) {
		409	freq_bin.show();
		410	console.log(phase_degree.val());
		411	var phase_degree_dec = parseInt(phase_degree.val()((2*14)/360.0),10);
		412	console.log(phase_degree_dec);
		413	document.getElementById("id_aux_phaseBdec").innerHTML = numToString(phase_degree_dec, 10, 5).match(/.{1,4}/g).join(' ');
		414	document.getElementById("id_aux_phaseBbin").innerHTML = numToString(parseInt(phase_degree_dec, 10), 2, 14).match(/.{1,4}/g).join(' ');
		415
		416	}
		417	else{
		418	freq_bin.hide();
		419	}
		420	}
		421
		422	function updatephaseAbindec() {
		423	var freq_bin = $("#id_row_phaseA");
		424	var phase_degree = $("#id_phaseA_degrees");
		425
		426	console.log("Ingreso a cupdatephaseAbindec");
		427	console.log(phase_degree.val());
		428	var phase_degree_dec = parseInt(phase_degree.val()((2*14)/360.0),10);
		429	console.log(phase_degree_dec);
		430	document.getElementById("id_aux_phaseAdec").innerHTML = numToString(phase_degree_dec, 10, 5).match(/.{1,4}/g).join(' ');
		431	document.getElementById("id_aux_phaseAbin").innerHTML = numToString(parseInt(phase_degree_dec, 10), 2, 14).match(/.{1,4}/g).join(' ');
		432
		433	}
		434
		435	function updatephaseBbindec() {
		436	var freq_bin = $("#id_row_phaseB");
		437	var phase_degree = $("#id_phaseB_degrees");
		438
		439	console.log("Ingreso a cupdatephaseBbindec");
		440	console.log(phase_degree.val());
		441	var phase_degree_dec = parseInt(phase_degree.val()((2*14)/360.0),10);
		442	console.log(phase_degree_dec);
		443	document.getElementById("id_aux_phaseBdec").innerHTML = numToString(phase_degree_dec, 10, 5).match(/.{1,4}/g).join(' ');
		444	document.getElementById("id_aux_phaseBbin").innerHTML = numToString(parseInt(phase_degree_dec, 10), 2, 14).match(/.{1,4}/g).join(' ');
		445
		446	}
		447
		448	function padStart(string, length, char) {
		449	return length > 0 ?
		450	padStart(char + string, --length, char) :
		451	string;
		452	}
		453
		454	function numToString(num, radix, length = num.length) {
		455	const numString = num.toString(radix);
		456	return numString.length === length ?
		457	numString :
		458	padStart(numString, length - numString.length, "0")
		459	}
		460
		461	console.log(numToString(parseInt("37529996894754", 10), 2, 48));
157	</script>	462	</script>
158	{% endblock %} No newline at end of file	463	{% endblock %}

apps/dds_rest/views.py +8 -8

             # Create your views here.
             from django.shortcuts import redirect, render, get_object_or_404
             # from apps.main.models import Experiment, Configuration
             from apps.main.views import sidebar
             from .models import DDSRestConfiguration
             from .forms import DDSRestConfigurationForm
             # Create your views here.
             def dds_rest_conf(request, id_conf):
                 conf = get_object_or_404(DDSRestConfiguration, pk=id_conf)
                 kwargs = {}
                 kwargs['status'] = conf.device.get_status_display()
             #     if not kwargs['connected']:
             #         messages.error(request, message=answer)
                 kwargs['dev_conf'] = conf
                 kwargs['dev_conf_keys'] = [
-                                           'clock',
+                                            'clock',
-                                           'multiplier',
+                                            'multiplier',
-                                           'frequencyA_Mhz',
+                                            'frequencyA_Mhz',
                                             'frequencyA',
                                             'frequencyB_Mhz',
                                             'frequencyB',
                                             'delta_frequency_Mhz',
                                             'delta_frequency',
                                             'update_clock_Mhz',
                                             'update_clock',
                                             'ramp_rate_clock_Mhz',
                                             'ramp_rate_clock',
                                             'phaseA_degrees',
                                             'phaseB_degrees',
                                             'modulation',
                                             'amplitude_enabled',
                                             'amplitudeI',
                                             'amplitudeQ']
                 kwargs['title'] = 'DDS Rest Configuration'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Edit Configuration'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'dds_rest_conf.html', kwargs)
             def dds_rest_conf_edit(request, id_conf):
                 conf = get_object_or_404(DDSRestConfiguration, pk=id_conf)
                 if request.method=='GET':
                     form = DDSRestConfigurationForm(instance=conf)
                 if request.method=='POST':
                     form = DDSRestConfigurationForm(request.POST, instance=conf)
                     if form.is_valid():
                         conf = form.save(commit=False)
                         if conf.verify_frequencies():
                             conf.save()
                             return redirect('url_dds_rest_conf', id_conf=conf.id)
                         ##ERRORS
                 kwargs = {}
-                kwargs['id_dev'] = conf.id
+                kwargs['id_dev']   = conf.id
-                kwargs['form'] = form
+                kwargs['form']     = form
-                kwargs['title'] = 'Device Configuration'
+                kwargs['title']    = 'Device Configuration'
                 kwargs['suptitle'] = 'Edit'
-                kwargs['button'] = 'Save'
+                kwargs['button']   = 'Save'
+                kwargs['device_dds']   = 'dds_rest'
                 return render(request, 'dds_rest_conf_edit.html', kwargs)

apps/main/templates/base.html +30 -30

             <!DOCTYPE html>
-            {% load static %}{% load bootstrap4 %}
+            {% load static %}
+            {% load bootstrap4 %}
             <html lang="en">
             <head>
                 <meta charset="utf-8">
                 <title>{% block title %}Jicamarca Integrated Radar System:::::{% endblock %}</title>
                 <meta name="description" content="">
                 <meta name="author" content="">
                 <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
                 {# bootstrap_css #}
                 <link href="{% static 'css/fontawesome.css' %}" rel="stylesheet">
                 <link href="{% static 'css/bootstrap.min.css' %}" rel="stylesheet">
                 <link href="{% static 'css/style.css' %}" rel="stylesheet">
                 <link href="{% static 'css/header.css' %}" rel="stylesheet">
                 <link href="{% static 'css/footer.css' %}" rel="stylesheet">
                 <link rel="shortcut icon" href="{% static 'images/favicon.ico' %}" />
                 <!--link href="{% static '' %}css/bootstrap-{{theme}}.min.css" media="all" rel="stylesheet"-->
-               <!-- <link href="{% static 'css/bootcards-desktop.min.css' %}" media="all" rel="stylesheet"> -->
+                <!-- <link href="{% static 'css/bootcards-desktop.min.css' %}" media="all" rel="stylesheet"> -->
                 <link href="{% static 'css/font-awesome.min.css' %}" media="all" rel="stylesheet"-->
                 <!--link href="//maxcdn.bootstrapcdn.com/bootstrap/3.3.4/css/bootstrap.min.css" rel="stylesheet"-->
                 <!-- Bootcards CSS for iOS: >
-                <link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/bootcards/1.0.0/css/bootcards-ios.min.css">
+                <link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/bootcards/1.0.0/css/bootcards-ios.min.css"-->
                 <!-- Bootcards CSS for Android: >
                 <link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/bootcards/1.0.0/css/bootcards-android.min.css"-->
                 <!-- Bootcards CSS for desktop: >
                 <link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/bootcards/1.0.0/css/bootcards-desktop.min.css"-->
-            <style type="text/css">
+              <style type="text/css">
-                  .logo {padding-top: 5px; height: 50px}
+                    .logo {padding-top: 5px; height: 50px}
-                  .clickable-row {cursor: pointer;}
+                    .clickable-row {cursor: pointer;}
-                  .col-no-padding { padding-left:0;}
+                    .col-no-padding { padding-left:0;}
-                  .gi-2x{font-size: 2em;}
+                    .gi-2x{font-size: 2em;}
-                  .gi-3x{font-size: 3em;}
+                    .gi-3x{font-size: 3em;}
-                  .gi-4x{font-size: 4em;}
+                    .gi-4x{font-size: 4em;}
-                  .gi-5x{font-size: 5em;}
+                    .gi-5x{font-size: 5em;}
-            </style>
+              </style>
-                {% block extra-head %}{% endblock %}
+              {% block extra-head %}{% endblock %}
             </head>
-            <body>
+            <body>
               {% include "header_igp.html" %}
               <div style="clear: both;"></div>
               <div class="container">
                   <div id="page" class="row" style="min-height:600px">
                   {% if no_sidebar %}
                   <div class="col-md-0 hidden-xs hidden-sm" role="complementary"></div>
                   {% else %}
                    <div class="col-md-3 hidden-xs hidden-sm" role="complementary">
                      <br><br>
                          <div id="sidebar">
                          {% block sidebar%}
                              {% include "sidebar_devices.html" %}
                         {% endblock %}
                          </div>
                      </div>
                   {% endif %}
                   {% if no_sidebar %}
                    <div class="col-md-12 col-xs-12" role="main">
                   {% else %}
                    <div class="col-md-9 col-xs-12" role="main">
                   {% endif %}
-                   <div class="page-header">
-                      <h1>{% block content-title %}{% endblock %} <small>{% block content-suptitle %}{% endblock %}</small></h1>
+                  <div class="page-header">
-                     </div>
+                    <h1>{% block content-title %}{% endblock %} <small>{% block content-suptitle %}{% endblock %}</small></h1>
-                     {% block messages %}
+                    </div>
-                       {% if messages %}
+                    {% block messages %}
-                         {% for message in messages %}
+                      {% if messages %}
-                         <div class="alert alert-{% if message.tags %}{% if 'error' in message.tags %}danger{% else %}{{ message.tags }}{% endif %}{% else %}info{% endif %} alert-dismissible" role="alert">
+                        {% for message in messages %}
-                           <button type="button" class="close" data-dismiss="alert" aria-label="Close"><span aria-hidden="true">&times;</span></button>
+                        <div class="alert alert-{% if message.tags %}{% if 'error' in message.tags %}danger{% else %}{{ message.tags }}{% endif %}{% else %}info{% endif %} alert-dismissible" role="alert">
-                           <strong>{{message.tags|title}}!</strong> {{ message }}
+                          <button type="button" class="close" data-dismiss="alert" aria-label="Close"><span aria-hidden="true">&times;</span></button>
-                         </div>
+                          <strong>{{message.tags|title}}!</strong> {{ message }}
-                         {% endfor %}
+                        </div>
-                       {% endif %}
+                        {% endfor %}
-                     {% endblock %}
+                      {% endif %}
+                    {% endblock %}
                    {% block content %}
                    {% endblock %}
-                   </div>
+                  </div>
                 </div><!--/row-->
               </div> <!-- container -->
             {% include "footer_igp.html" %}
              <!-- This part put block modal which is used to change parameters of my plot -->
              {% block modal %}{% endblock modal %}
              {% block debug %}<div class="row">{{debug}}</div>{% endblock debug %}
              <!-- Optional JavaScript -->
              <!-- jQuery first, then Popper.js, then Bootstrap JS -->
              {# % bootstrap_javascript jquery='slim' % #}
              <script src="{% static 'js/jquery-3.3.1.slim.min.js' %}"></script>
              <script src="{% static 'js/popper.min.js' %}"></script>
              <script src="{% static 'js/moment.min.js' %}"></script>
              <script src="{% static 'js/bootstrap.min.js' %}"></script>
              <script src="{% static 'js/plotly-latest.min.js' %}"></script>
              <!-- Here we put the script from the type of plot that we recibe -->
              <script>
                $("#menu-toggle").click(function (e) {
                  e.preventDefault();
                  $("#wrapper").toggleClass("toggled");
                });
              </script>
              {% block extra-js %}
              {% endblock%}
             </body>
             </html>

apps/main/templates/base_edit.html +9 -2

             {% extends "base.html" %}
             {% load bootstrap4 %}
             {% load static %}
             {% load main_tags %}
             {% block content-title %}{{title}}{% endblock %}
             {% block content-suptitle %}{{suptitle}}{% endblock %}
             {% block content %}
               {% if form.is_multipart %}
               <form class="form" enctype="multipart/form-data" method="post" action="{{action}}">
               {% else %}
               <form class="form" method="post" action="{{action}}">
               {% endif %}
               {% csrf_token %}
-              {% bootstrap_form form layout='horizontal' size='medium' %}
+              {% if device_dds == 'dds_rest' %}
+                {% block dds_rest%}
+                {% endblock %}
+              {% else %}
+                {% bootstrap_form form layout='horizontal' size='medium' %}
+              {% endif %}
               <div style="clear: both;"></div>
               <br>
               {% if extra_button %}
               <div class="pull-left">
               <button type="button" class="btn btn-primary" id="bt_{{extra_button}}">{{extra_button}}</button>
               </div>
               {% endif %}
               {% if button %}
               <div class="pull-right">
               <button type="button" class="btn btn-primary" onclick="{% if previous %}window.location.replace('{{ previous }}');{% else %}history.go(-1);{% endif %}">{% if cancel %}{{cancel}}{% else %}Cancel{% endif %}</button>
               <button type="submit" class="btn btn-primary">{{button}}</button>
               </div>
               {% endif %}
-            </form>
+              </form>
             {% endblock %}
             {% block sidebar%}
                {% include "sidebar_devices.html" %}
             {% endblock %}

static/js/dds_conversion.js +8 -1

             function freq2Binary(mclock, frequency) {
                 var freq_bin = parseInt(frequency * (Math.pow(2,48)/mclock));
                 return freq_bin;
             }
             function binary2Freq(mclock, binary) {
                 var frequency = (1.0*binary) / (Math.pow(2,48)/mclock);
                 return frequency;
             }
             function binary2FreqDelta(mclock, binary) {
                 var frequency = (1.0*binary) / (Math.pow(2,48)/mclock);
                 return frequency;
             }
             function freqDelta2Binary(mclock, frequency) {
                 var freq_bin = parseInt(frequency * (Math.pow(2,48)/mclock));
                 return freq_bin;
             }
             function binary2Ramp(mclock, binary) {
                 var frequency = (1.0*mclock) / (binary+1);
                 return frequency;
             }
             function freqRamp2Binary(mclock, frequency) {
                 var freq_bin = parseInt(mclock/frequency-1);
                 return freq_bin;
-            }    
  No newline at end of file
+            function us2Ramp(step_us) {
+                //periodo_delpaso = sysclockperiod x (N+1)
+                // freqsys/(N+1)=freq_ddelpaso=1/step
+                var freq = (1.0/(step_us));
+                return freq;
+            }       
  No newline at end of file

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