radarsys_met Commit - r360:46316742ce9f

New experiment views

amorales -

r360:46316742ce9f

parent child

Context file:

r360:46316742ce9f

Collapse all files

usrp-api/code.bin created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

usrp-api/thor.py created 644 +5 0

@@ -0,0 +1,5
	1	import time
	2
	3	while True:
	4	print("Adquiriendo")
	5	time.sleep(3) No newline at end of file

usrp-api/tx.py created 644 +5 0

@@ -0,0 +1,5
	1	import time
	2
	3	while True:
	4	print("Transmitiendo")
	5	time.sleep(3) No newline at end of file

apps/generator/forms.py +3 -3

             import os
             import json
             from django import forms
             from django.utils.safestring import mark_safe
             from apps.main.models import Device
             from apps.main.forms import add_empty_choice
             from .models import GeneratorConfiguration
             def create_choices_from_model(model, conf_id, all_choice=False):
                 instance = globals()[model]
                 choices = instance.objects.all().values_list('pk', 'name')
                 return choices
             class GeneratorConfigurationForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(GeneratorConfigurationForm, self).__init__(*args, **kwargs)
                     instance = getattr(self, 'instance', None)
                     if instance and instance.pk:
                         devices = Device.objects.filter(device_type__name='generator')
-                        if instance.experiment:
+                        #if instance.experiment:
-                            self.fields['experiment'].widget.attrs['read_only'] = True
+                            #self.fields['experiment'].widget.attrs['read_only'] = True
                             #self.fields['experiment'].widget.choices = [(instance.experiment.id, instance.experiment)]
-                        self.fields['device'].widget.choices = [(device.id, device) for device in devices]
+                        #self.fields['device'].widget.choices = [(device.id, device) for device in devices]
                     if 'initial' in kwargs and 'experiment' in kwargs['initial'] and kwargs['initial']['experiment'] not in (0, '0'):
                         self.fields['experiment'].widget.attrs['readonly'] = True
                 class Meta:
                     model = GeneratorConfiguration
                     exclude = ('type', 'parameters', 'status', 'total_units', 'author', 'hash')
                 def clean(self):
                     form_data = super(GeneratorConfigurationForm, self).clean()
                     return form_data
                 def save(self, *args, **kwargs):
                     conf = super(GeneratorConfigurationForm, self).save(*args, **kwargs)
                     conf.save()
                     return conf
             class ExtFileField(forms.FileField):
                 """
                 Same as forms.FileField, but you can specify a file extension whitelist.
                 >>> from django.core.files.uploadedfile import SimpleUploadedFile
                 >>>
                 >>> t = ExtFileField(ext_whitelist=(".pdf", ".txt"))
                 >>>
                 >>> t.clean(SimpleUploadedFile('filename.pdf', 'Some File Content'))
                 >>> t.clean(SimpleUploadedFile('filename.txt', 'Some File Content'))
                 >>>
                 >>> t.clean(SimpleUploadedFile('filename.exe', 'Some File Content'))
                 Traceback (most recent call last):
                 ...
                 ValidationError: [u'Not allowed filetype!']
                 """
                 def __init__(self, *args, **kwargs):
                     extensions = kwargs.pop("extensions")
                     self.extensions = [i.lower() for i in extensions]
                     super(ExtFileField, self).__init__(*args, **kwargs)
                 def clean(self, *args, **kwargs):
                     data = super(ExtFileField, self).clean(*args, **kwargs)
                     filename = data.name
                     ext = os.path.splitext(filename)[1]
                     ext = ext.lower()
                     if ext not in self.extensions:
                         raise forms.ValidationError('Not allowed file type: %s' % ext)
             class GeneratorImportForm(forms.Form):
                 file_name = ExtFileField(extensions=['.racp', '.json', '.dat'])

apps/main/forms.py +18 -1

             from django import forms
             from django.utils.safestring import mark_safe
             from apps.main.models import Device, Experiment, Campaign, Location, Configuration
             from django.template.defaultfilters import default
             FILE_FORMAT = (
                             ('json', 'json'),
                             )
             def add_empty_choice(choices, pos=0, label='-----'):
                 if len(choices)>0:
                     choices = list(choices)
                     choices.insert(0, (0, label))
                     return choices
                 else:
                     return [(0, label)]
             class DatepickerWidget(forms.widgets.TextInput):
                 def render(self, name, value, attrs=None, renderer=None):
                     input_html = super(DatepickerWidget, self).render(name, value, attrs)
                     html = '<div class="input-group date">'+input_html+'<span class="input-group-addon"><i class="far fa-calendar-alt"></i></span></div>'
                     return mark_safe(html)
             class DateRangepickerWidget(forms.widgets.TextInput):
                 def render(self, name, value, attrs=None, renderer=None):
                     start = attrs['start_date']
                     end = attrs['end_date']
                     html = '''<div class="col-md-6 input-group date" style="float:inherit">
                     <input class="form-control" id="id_start_date" name="start_date" placeholder="Start" title="" type="text" value="{}">
                     <span class="input-group-addon"><i class="far fa-calendar-alt"></i></span>
                     </div>
                     <div class="col-md-6 input-group date" style="float:inherit">
                     <input class="form-control" id="id_end_date" name="end_date" placeholder="End" title="" type="text" value="{}">
                     <span class="input-group-addon"><i class="far fa-calendar-alt"></i></span>
                     </div>'''.format(start, end)
                     return mark_safe(html)
             class TimepickerWidget(forms.widgets.TextInput):
                 def render(self, name, value, attrs=None, renderer=None):
                     input_html = super(TimepickerWidget, self).render(name, value, attrs)
                     html = '<div class="input-group time">'+input_html+'<span class="input-group-addon"><i class="far fa-clock"></i></span></div>'
                     return mark_safe(html)
             class CampaignForm(forms.ModelForm):
                 experiments = forms.ModelMultipleChoiceField(widget=forms.CheckboxSelectMultiple(),
                                                              queryset=Experiment.objects.filter(template=True),
                                                              required=False)
                 def __init__(self, *args, **kwargs):
                     super(CampaignForm, self).__init__(*args, **kwargs)
                     self.fields['start_date'].widget = DatepickerWidget(self.fields['start_date'].widget.attrs)
                     self.fields['end_date'].widget   = DatepickerWidget(self.fields['end_date'].widget.attrs)
                     self.fields['description'].widget.attrs = {'rows': 2}
                     if self.instance.pk:
                         self.fields['experiments'].queryset |= self.instance.experiments.all()
                 class Meta:
                     model = Campaign
                     exclude = ['author']
             class ExperimentForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(ExperimentForm, self).__init__(*args, **kwargs)
                     #self.fields['start_time'].widget = TimepickerWidget(self.fields['start_time'].widget.attrs)
                     #self.fields['end_time'].widget   = TimepickerWidget(self.fields['end_time'].widget.attrs)
                 def save(self, *args, **kwargs):
                     exp      = super(ExperimentForm, self).save(*args, **kwargs)
                     exp.name = exp.name.replace(' ', '')
                     exp.save()
                     return exp
                 class Meta:
                     model = Experiment
                     exclude = ['task', 'status', 'author', 'hash']
+            class ExperimentEditionForm(forms.ModelForm):
+                def __init__(self, *args, **kwargs):
+                    super(ExperimentEditionForm, self).__init__(*args, **kwargs)
+                    #self.fields['start_time'].widget = TimepickerWidget(self.fields['start_time'].widget.attrs)
+                    #self.fields['end_time'].widget   = TimepickerWidget(self.fields['end_time'].widget.attrs)
+                def save(self, *args, **kwargs):
+                    exp      = super(ExperimentEditionForm, self).save(*args, **kwargs)
+                    exp.name = exp.name.replace(' ', '')
+                    exp.save()
+                    return exp
+                class Meta:
+                    model = Experiment
+                    exclude = ['pedestal', 'generator', 'task', 'status', 'author', 'hash']
             class LocationForm(forms.ModelForm):
                 class Meta:
                     model = Location
                     exclude = ['']
             class DeviceForm(forms.ModelForm):
                 class Meta:
                     model = Device
                     exclude = ['status']
             class ConfigurationForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(ConfigurationForm, self).__init__(*args, **kwargs)
                     if 'initial' in kwargs and 'experiment' in kwargs['initial'] and kwargs['initial']['experiment'] not in (0, '0'):
                         self.fields['experiment'].widget.attrs['disabled'] = 'disabled'
                 class Meta:
                     model = Configuration
                     exclude = ['type', 'created_date', 'programmed_date', 'parameters', 'author', 'hash']
             class UploadFileForm(forms.Form):
                 file = forms.FileField()
             class DownloadFileForm(forms.Form):
                 format = forms.ChoiceField(choices= ((0, 'json'),) )
                 def __init__(self, device_type, *args, **kwargs):
                     super(DownloadFileForm, self).__init__(*args, **kwargs)
                     self.fields['format'].choices = FILE_FORMAT
             class OperationForm(forms.Form):
                 campaign = forms.ChoiceField(label="Campaign")
                 def __init__(self, *args, **kwargs):
                     campaigns = kwargs.pop('campaigns')
                     super(OperationForm, self).__init__(*args, **kwargs)
                     self.fields['campaign'].label   = 'Current Campaigns'
                     self.fields['campaign'].choices = add_empty_choice(campaigns.values_list('id', 'name'))
             class OperationSearchForm(forms.Form):
                 # -----ALL Campaigns------
                 campaign = forms.ChoiceField(label="Campaign")
                 def __init__(self, *args, **kwargs):
                     super(OperationSearchForm, self).__init__(*args, **kwargs)
                     self.fields['campaign'].choices=Campaign.objects.all().order_by('-start_date').values_list('id', 'name')
             class NewForm(forms.Form):
                 create_from = forms.ChoiceField(choices=((0, '-----'),
                                                          (1, 'Empty (blank)'),
                                                          (2, 'Template')))
                 choose_template = forms.ChoiceField()
                 def __init__(self, *args, **kwargs):
                     template_choices = kwargs.pop('template_choices', [])
                     super(NewForm, self).__init__(*args, **kwargs)
                     self.fields['choose_template'].choices = add_empty_choice(template_choices)
             class FilterForm(forms.Form):
                 def __init__(self, *args, **kwargs):
                     extra_fields = kwargs.pop('extra_fields', [])
                     super(FilterForm, self).__init__(*args, **kwargs)
                     for field in extra_fields:
                         if 'range_date' in field:
                             self.fields[field] = forms.CharField(required=False)
                             self.fields[field].widget = DateRangepickerWidget()
                             if 'initial' in kwargs:
                                 self.fields[field].widget.attrs = {'start_date':kwargs['initial'].get('start_date', ''),
                                                                    'end_date':kwargs['initial'].get('end_date', '')}
                         elif  field in ('template', 'historical') or 'my ' in field:
                             self.fields[field] = forms.BooleanField(required=False)
                         else:
                             self.fields[field] = forms.CharField(required=False)
             class ChangeIpForm(forms.Form):
                 ip_address = forms.GenericIPAddressField()
                 mask       = forms.GenericIPAddressField(initial='255.255.255.0')
                 gateway    = forms.GenericIPAddressField(initial='0.0.0.0')
                 dns        = forms.GenericIPAddressField(initial='0.0.0.0')

apps/main/models.py +51 -28

             import os
             import json
             import requests
             import time
             from datetime import datetime
             try:
                 from polymorphic.models import PolymorphicModel
             except:
                 from polymorphic import PolymorphicModel
             from django.template.base import kwarg_re
             from django.db import models
             from django.urls import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from django.shortcuts import get_object_or_404
             from django.contrib.auth.models import User
             from django.db.models.signals import post_save
             from django.dispatch import receiver
             from apps.main.utils import Params
             DEV_PORTS = {
                             'pedestal'      : 80,
                             'pedestal_dev'  : 80,
                             'generator'     : 80,
                             'usrp_rx'       : 2000,
                             'usrp_tx'       : 2000,
                         }
             RADAR_STATES = (
                              (0, 'No connected'),
                              (1, 'Connected'),
                              (2, 'Configured'),
                              (3, 'Running'),
                              (4, 'Scheduled'),
                          )
             EXPERIMENT_TYPE = (
                                (0, 'RAW_DATA'),
                                (1, 'PDATA'),
                                )
             DECODE_TYPE = (
                          (0, 'None'),
                          (1, 'TimeDomain'),
                          (2, 'FreqDomain'),
                          (3, 'InvFreqDomain'),
                          )
             DEV_STATES = (
                              (0, 'Unknown'),
                              (1, 'Connected'),
                              (2, 'Configured'),
                              (3, 'Running'),
                              (4, 'Offline'),
                          )
             DEV_TYPES = (
                             ('', 'Select a  device type'),
                             ('pedestal', 'Pedestal Controller'),
                             ('pedestal_dev', 'Pedestal Controller Dev Mode'),
                             ('generator', 'Pulse Generator'),
                             ('usrp_rx', 'Universal Software Radio Peripheral Rx'),
                             ('usrp_tx', 'Universal Software Radio Peripheral Tx'),
                         )
             EXP_STATES = (
                              (0,'Error'),                 #RED
                              (1,'Cancelled'),             #YELLOW
                              (2,'Running'),               #GREEN
                              (3,'Scheduled'),             #BLUE
                              (4,'Unknown'),               #WHITE
                          )
             CONF_TYPES = (
                              (0, 'Active'),
                              (1, 'Historical'),
                          )
             class Profile(models.Model):
                 user = models.OneToOneField(User, on_delete=models.CASCADE)
                 theme = models.CharField(max_length=30, default='spacelab')
             @receiver(post_save, sender=User)
             def create_user_profile(sender, instance, created, **kwargs):
                 if created:
                     Profile.objects.create(user=instance)
             @receiver(post_save, sender=User)
             def save_user_profile(sender, instance, **kwargs):
                 instance.profile.save()
             class Location(models.Model):
                 name = models.CharField(max_length = 30)
                 description = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'db_location'
                 def __str__(self):
                     return u'%s' % self.name
                 def get_absolute_url(self):
                     return reverse('url_location', args=[str(self.id)])
             class DeviceType(models.Model):
                 name = models.CharField(max_length = 15, choices = DEV_TYPES, default = 'pedestal')
                 sequence = models.PositiveSmallIntegerField(default=55)
                 description = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'db_device_types'
                 def __str__(self):
                     return u'%s' % self.name.title()
             class Device(models.Model):
                 device_type  = models.ForeignKey('DeviceType', on_delete=models.CASCADE)
                 location     = models.ForeignKey('Location', on_delete=models.CASCADE)
                 ip_address   = models.GenericIPAddressField(verbose_name = 'IP address', protocol='IPv4', default='0.0.0.0')
                 port_address = models.PositiveSmallIntegerField(default=2000)
                 description  = models.TextField(blank=True, null=True)
                 status       = models.PositiveSmallIntegerField(default=4, choices=DEV_STATES)
                 conf_active  = models.PositiveIntegerField(default=0, verbose_name='Current configuration')
                 class Meta:
                     db_table = 'db_devices'
                 def __str__(self):
                     ret = self.device_type
                     #ret = u'{} [{}]'.format(self.device_type.name.upper(), self.location.name)
                     return str(ret)
                 @property
                 def name(self):
                     return str(self)
                 def get_status(self):
                     return self.status
                 @property
                 def status_color(self):
                     color = 'muted'
                     if self.status == 0:
                         color = "danger"
                     elif self.status == 1:
-                        color = "warning"
+                        color = "primary"
                     elif self.status == 2:
                         color = "info"
                     elif self.status == 3:
                         color = "success"
                     return color
                 def url(self, path=None):
                     if path:
                         return 'http://{}:{}/{}/'.format(self.ip_address, self.port_address, path)
                     else:
                         return 'http://{}:{}/'.format(self.ip_address, self.port_address)
                 def get_absolute_url(self):
                     return reverse('url_device', args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_device', args=[str(self.id)])
                 def get_absolute_url_delete(self):
                     return reverse('url_delete_device', args=[str(self.id)])
                 def change_ip(self, ip_address, mask, gateway, dns, **kwargs):
                     if self.device_type.name=='pedestal':
                         headers = {'content-type': "application/json",
                                    'cache-control': "no-cache"}
                         ip      = [int(x) for x in ip_address.split('.')]
                         dns     = [int(x) for x in dns.split('.')]
                         gateway = [int(x) for x in gateway.split('.')]
                         subnet  = [int(x) for x in mask.split('.')]
                         payload = {
                             "ip": ip,
                             "dns": dns,
                             "gateway": gateway,
                             "subnet": subnet
                             }
                         req = requests.post(self.url('changeip'), data=json.dumps(payload), headers=headers)
                         try:
                             answer = req.json()
                             if answer['changeip']=='ok':
                                 self.message    = '25|IP succesfully changed'
                                 self.ip_address = ip_address
                                 self.save()
                             else:
                                 self.message = '30|An error ocuur when changing IP'
                         except Exception as e:
                             self.message = '40|{}'.format(str(e))
                     else:
                         self.message = 'Not implemented'
                         return False
                     return True
             class Campaign(models.Model):
                 template    = models.BooleanField(default=False)
                 name        = models.CharField(max_length=60, unique=True)
                 start_date  = models.DateTimeField(blank=True, null=True)
                 end_date    = models.DateTimeField(blank=True, null=True)
                 tags        = models.CharField(max_length=40, blank=True, null=True)
                 description = models.TextField(blank=True, null=True)
                 experiments = models.ManyToManyField('Experiment', blank=True)
                 author      = models.ForeignKey(User, null=True, blank=True,on_delete=models.CASCADE)
                 class Meta:
                     db_table = 'db_campaigns'
                     ordering = ('name',)
                 def __str__(self):
                     if self.template:
                         return u'{} (template)'.format(self.name)
                     else:
                         return u'{}'.format(self.name)
                 def jsonify(self):
                     data = {}
                     ignored = ('template')
                     for field in self._meta.fields:
                         if field.name in ignored:
                             continue
                         data[field.name] = field.value_from_object(self)
                     data['start_date'] = data['start_date'].strftime('%Y-%m-%d')
                     data['end_date']   = data['end_date'].strftime('%Y-%m-%d')
                     return data
                 def parms_to_dict(self):
                     params = Params({})
                     params.add(self.jsonify(), 'campaigns')
                     for exp in Experiment.objects.filter(campaign = self):
                         params.add(exp.jsonify(), 'experiments')
                         configurations = Configuration.objects.filter(experiment=exp, type=0)
                         for conf in configurations:
                             params.add(conf.jsonify(), 'configurations')
                     return params.data
                 def dict_to_parms(self, parms, CONF_MODELS):
                     experiments = Experiment.objects.filter(campaign = self)
                     if experiments:
                         for experiment in experiments:
                             experiment.delete()
                     for id_exp in parms['experiments']['allIds']:
                         exp_parms = parms['experiments']['byId'][id_exp]
                         dum = (datetime.now() - datetime(1970, 1, 1)).total_seconds()
                         exp = Experiment(name='{}'.format(dum))
                         exp.save()
                         exp.dict_to_parms(parms, CONF_MODELS, id_exp=id_exp)
                         self.experiments.add(exp)
                     camp_parms = parms['campaigns']['byId'][parms['campaigns']['allIds'][0]]
                     self.name       = '{}-{}'.format(camp_parms['name'], datetime.now().strftime('%y%m%d'))
                     self.start_date = camp_parms['start_date']
                     self.end_date   = camp_parms['end_date']
                     self.tags       = camp_parms['tags']
                     self.save()
                     return self
                 def get_experiments_by_radar(self, radar=None):
                     ret = []
                     if radar:
                         locations = Location.objects.filter(pk=radar)
                     else:
                         locations = set([e.location for e in self.experiments.all()])
                     for loc in locations:
                         dum = {}
                         dum['name']        = loc.name
                         dum['id']          = loc.pk
                         dum['experiments'] = [e for e in self.experiments.all() if e.location==loc]
                         ret.append(dum)
                     return ret
                 def get_absolute_url(self):
                     return reverse('url_campaign', args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_campaign', args=[str(self.id)])
                 def get_absolute_url_delete(self):
                     return reverse('url_delete_campaign', args=[str(self.id)])
                 def get_absolute_url_export(self):
                     return reverse('url_export_campaign', args=[str(self.id)])
                 def get_absolute_url_import(self):
                     return reverse('url_import_campaign', args=[str(self.id)])
             class RunningExperiment(models.Model):
                 radar              = models.OneToOneField('Location', on_delete=models.CASCADE)
                 running_experiment = models.ManyToManyField('Experiment', blank = True)
                 status             = models.PositiveSmallIntegerField(default=0, choices=RADAR_STATES)
-            class Experiment(models.Model):
+            class Experiment(PolymorphicModel):
                 template   = models.BooleanField(default=False)
                 name       = models.CharField(max_length=40, default='', unique=True)
                 location   = models.ForeignKey('Location', null=False, blank=False, on_delete=models.CASCADE, default=None)
                 #freq       = models.FloatField(verbose_name='Operating Freq. (MHz)', validators=[MinValueValidator(1), MaxValueValidator(10000)], default=49.9200)
                 #start_time = models.TimeField(default='00:00:00')
                 #end_time   = models.TimeField(default='23:59:59')
-                pedestal   = models.ForeignKey('pedestal.PedestalConfiguration', null=False, blank=False, on_delete=models.CASCADE, default=None, related_name = "pedestal_conf")
+                pedestal   = models.ForeignKey('pedestal.PedestalConfiguration', null=False, blank=False, on_delete=models.PROTECT, default=None, related_name = "pedestal_conf")
+                generator = models.ForeignKey('Device', null=False, blank=False, on_delete=models.PROTECT, default=None, limit_choices_to={'device_type__name': 'generator'}, related_name = "generator_conf")
+                reception_rx    = models.ForeignKey('usrp_rx.USRPRXConfiguration', null=False, blank=False, on_delete=models.PROTECT, default=None, related_name = "usrp_rx_CONF")
+                transmission_tx = models.ForeignKey('usrp_tx.USRPTXConfiguration', null=False, blank=False, on_delete=models.PROTECT, default=None, related_name = "usrp_tx")
                 task       = models.CharField(max_length=36, default='', blank=True, null=True)
                 status     = models.PositiveSmallIntegerField(default=4, choices=EXP_STATES)
-                author     = models.ForeignKey(User, null=True, blank=True,on_delete=models.CASCADE)
+                author     = models.ForeignKey(User, null=True, blank=True, on_delete=models.CASCADE)
                 hash       = models.CharField(default='', max_length=64, null=True, blank=True)
                 class Meta:
                     db_table = 'db_experiments'
                     ordering = ('template', 'name')
                 def __str__(self):
                     if self.template:
                         return u'%s (template)' % (self.name)
                     else:
                         return u'%s' % (self.name)
                 def jsonify(self):
                     data = {}
                     ignored = ('template')
                     for field in self._meta.fields:
                         if field.name in ignored:
                             continue
                         data[field.name] = field.value_from_object(self)
                     data['start_time'] = data['start_time'].strftime('%H:%M:%S')
                     data['end_time']   = data['end_time'].strftime('%H:%M:%S')
                     data['location']   = self.location.name
                     data['configurations'] = ['{}'.format(conf.pk) for
                         conf in Configuration.objects.filter(experiment=self, type=0)]
                     return data
                 @property
                 def radar_system(self):
                     return self.location
                 def clone(self, **kwargs):
                     confs = Configuration.objects.filter(experiment=self, type=0)
                     self.pk = None
                     self.name = '{}_{:%y%m%d}'.format(self.name, datetime.now())
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     for conf in confs:
                         conf.clone(experiment=self, template=False)
                     return self
                 def start(self):
                     '''
                     Configure and start experiments's devices
                     '''
+                    #confs = []
-                    confs = []
+                    #allconfs = Configuration.objects.filter(experiment=self, type = 0).order_by('-device__device_type__sequence')
-                    allconfs = Configuration.objects.filter(experiment=self, type = 0).order_by('-device__device_type__sequence')
+                    #confs = allconfs
-                    confs = allconfs
+                    experiment = get_object_or_404(Experiment, pk=self.id)
+                    id_p = experiment.pedestal_id
+                    id_rx = experiment.reception_rx_id
+                    id_tx = experiment.transmission_tx_id
+                    generator_periode = 1 /experiment.transmission_tx.frequency
+                    generator_delay = experiment.transmission_tx.delay_1
+                    generator_width = int((experiment.transmission_tx.ipp * 2 / 300000) * 1000000) * experiment.transmission_tx.pulse_1 / 100
+                    print(generator_width)
+                    generator_selector = 1
                     try:
-                        for conf in confs:
+                        print("Hola")
-                            conf.stop_device()
+                        #Configuration.objects.get(id = id_rx).start_device()
-                            print("OK")
+                        #Configuration.objects.get(id = id_p).start_device()
-                            #conf.write_device()
+                        #Configuration.objects.get(id = id_tx).start_device()
-                            conf.device.conf_active = conf.pk
+                        # for conf in confs:
-                            conf.device.save()
+                        #     conf.stop_device()
-                            conf.start_device()
+                        #     print("OK")
-                            print("OK")
+                        #     #conf.write_device()
-                            time.sleep(1)
+                        #     conf.device.conf_active = conf.pk
+                        #     conf.device.save()
+                        #     conf.start_device()
+                        #     print("OK")
+                        #     time.sleep(1)
                     except:
                         return 0
                     return 2
                 def stop(self):
                     '''
                     Stop experiments's devices
                     PEDESTAL, PULSE GENERATOR & USRP's
                     '''
-                    confs = Configuration.objects.filter(experiment=self, type = 0).order_by('device__device_type__sequence')
+                    #confs = Configuration.objects.filter(experiment=self, type = 0).order_by('device__device_type__sequence')
+                    experiment = get_object_or_404(Experiment, pk=self.id)
+                    id_p = experiment.pedestal_id
+                    id_rx = experiment.reception_rx_id
+                    id_tx = experiment.transmission_tx_id
                     try:
-                        for conf in confs:
+                        Configuration.objects.get(id = id_rx).stop_device()
-                            conf.stop_device()
+                        Configuration.objects.get(id = id_p).stop_device()
+                        Configuration.objects.get(id = id_tx).stop_device()
+                    #   for conf in confs:
+                    #       conf.stop_device()
                     except:
                         return 0
                     return 1
                 def get_status(self):
                     if self.status == 3:
                         return
                     confs =  Configuration.objects.filter(experiment=self, type=0)
                     for conf in confs:
                         conf.status_device()
                     total = confs.aggregate(models.Sum('device__status'))['device__status__sum']
                     if total==2*confs.count():
                         status = 1
                     elif total == 3*confs.count():
                         status = 2
                     else:
                         status = 0
                     self.status = status
                     self.save()
                 def status_color(self):
                     color = 'muted'
                     if self.status == 0:
                         color = "danger"
                     elif self.status == 1:
                         color = "warning"
                     elif self.status == 2:
                         color = "success"
                     elif self.status == 3:
                         color = "info"
                     return color
                 def parms_to_dict(self):
                     params = Params({})
                     params.add(self.jsonify(), 'experiments')
                     configurations = Configuration.objects.filter(experiment=self, type=0)
                     for conf in configurations:
                         params.add(conf.jsonify(), 'configurations')
                     return params.data
                 def dict_to_parms(self, parms, CONF_MODELS, id_exp=None):
                     configurations = Configuration.objects.filter(experiment=self)
                     if id_exp is not None:
                         exp_parms = parms['experiments']['byId'][id_exp]
                     else:
                         exp_parms = parms['experiments']['byId'][parms['experiments']['allIds'][0]]
                     if configurations:
                         for configuration in configurations:
                             configuration.delete()
                     for id_conf in exp_parms['configurations']:
                         conf_parms = parms['configurations']['byId'][id_conf]
                         device     = Device.objects.filter(device_type__name=conf_parms['device_type'])[0]
                         model      = CONF_MODELS[conf_parms['device_type']]
                         conf = model(
                             experiment = self,
                             device = device,
                             )
                         conf.dict_to_parms(parms, id=id_conf)
                     location, created = Location.objects.get_or_create(name=exp_parms['location'])
                     self.name = '{}-{}'.format(exp_parms['name'], datetime.now().strftime('%y%m%d'))
                     self.location   = location
                     self.start_time = exp_parms['start_time']
                     self.end_time   = exp_parms['end_time']
                     self.save()
                     return self
                 def get_absolute_url(self):
                     return reverse('url_experiment', args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_experiment', args=[str(self.id)])
                 def get_absolute_url_delete(self):
                     return reverse('url_delete_experiment', args=[str(self.id)])
                 def get_absolute_url_import(self):
                     return reverse('url_import_experiment', args=[str(self.id)])
                 def get_absolute_url_export(self):
                     return reverse('url_export_experiment', args=[str(self.id)])
                 def get_absolute_url_start(self):
                     return reverse('url_start_experiment', args=[str(self.id)])
                 def get_absolute_url_stop(self):
                     return reverse('url_stop_experiment', args=[str(self.id)])
             class Configuration(PolymorphicModel):
                 id = models.AutoField(primary_key=True)
                 template        = models.BooleanField(default=False)
                 # name          = models.CharField(verbose_name="Configuration Name", max_length=40, default='')
                 device          = models.ForeignKey('Device', verbose_name='Device', null=True, on_delete=models.CASCADE)
                 label           = models.CharField(verbose_name="Label", max_length=40, default='', blank=False, null=False)
-                experiment      = models.ForeignKey('Experiment', verbose_name='Experiment', null=True, blank=True, on_delete=models.CASCADE)
                 type            = models.PositiveSmallIntegerField(default=0, choices=CONF_TYPES)
                 created_date    = models.DateTimeField(auto_now_add=True)
                 programmed_date = models.DateTimeField(auto_now=True)
                 parameters      = models.TextField(default='{}')
                 author          = models.ForeignKey(User, null=True, blank=True,on_delete=models.CASCADE)
                 hash            = models.CharField(default='', max_length=64, null=True, blank=True)
                 message = ""
                 class Meta:
                     db_table = 'db_configurations'
                     ordering = ('device__device_type__name',)
                 def __str__(self):
                     ret = u'{} '.format(self.device.device_type.name.upper())
                     if 'mix' in [f.name for f in self._meta.get_fields()]:
                         if self.mix:
                             ret = '{} MIX '.format(self.device.device_type.name.upper())
                     if 'label' in [f.name for f in self._meta.get_fields()]:
                         ret += '{}'.format(self.label)
                     if self.template:
                         ret += ' (template)'
                     return ret
                 @property
                 def name(self):
                     return str(self)
                 def jsonify(self):
                     data = {}
                     ignored = ('type', 'polymorphic_ctype', 'configuration_ptr',
                                'created_date', 'programmed_date', 'template', 'device',
-                               'experiment')
+                               'experiment', 'author')
                     for field in self._meta.fields:
                         if field.name in ignored:
                             continue
                         data[field.name] = field.value_from_object(self)
                     data['device_type'] = self.device.device_type.name
                     return data
                 def clone(self, **kwargs):
                     self.pk = None
                     self.id = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     return self
                 def parms_to_dict(self):
                     params = Params({})
                     params.add(self.jsonify(), 'configurations')
                     return params.data
                 def parms_to_text(self):
                     raise NotImplementedError("This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper())
                 def parms_to_binary(self):
                     raise NotImplementedError("This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper())
                 def dict_to_parms(self, parameters, id=None):
                     params = Params(parameters)
                     if id:
                         data = params.get_conf(id_conf=id)
                     else:
                         data = params.get_conf(dtype=self.device.device_type.name)
                     for key, value in data.items():
                         if key not in ('id', 'device_type'):
                             setattr(self, key, value)
                     self.save()
                 def export_to_file(self, format="json"):
                     content_type = ''
                     if format == 'racp':
                         content_type = 'text/plain'
                         filename = '%s_%s.%s' %(self.device.device_type.name, self.name, 'racp')
                         content = self.parms_to_text(file_format = 'racp')
                     if format == 'text':
                         content_type = 'text/plain'
                         filename = '%s_%s.%s' %(self.device.device_type.name, self.name, self.device.device_type.name)
                         content = self.parms_to_text()
                     if format == 'binary':
                         content_type = 'application/octet-stream'
                         filename = '%s_%s.bin' %(self.device.device_type.name, self.name)
                         content = self.parms_to_binary()
                     if not content_type:
                         content_type = 'application/json'
                         filename = '%s_%s.json' %(self.device.device_type.name, self.name)
                         content = json.dumps(self.parms_to_dict(), indent=2)
+                        print(content)
                     fields = {'content_type':content_type,
                               'filename':filename,
                               'content':content
                               }
                     return fields
                 def import_from_file(self, fp):
                     parms = {}
                     path, ext = os.path.splitext(fp.name)
                     if ext == '.json':
                         parms = json.load(fp)
                     return parms
                 def status_device(self):
-                    self.message = 'Function not implemented'
+                    self.message = 'Function not supported'
                     return False
                 def stop_device(self):
-                    self.message = 'Function not implemented'
+                    self.message = 'Function not supported'
                     return False
                 def start_device(self):
-                    self.message = 'Function not implemented'
+                    self.message = 'Function not supported'
                     return False
                 def write_device(self):
-                    self.message = 'Function not implemented'
+                    self.message = 'Function not supported'
                     return False
                 def read_device(self):
-                    self.message = 'Function not implemented'
+                    self.message = 'Function not supported'
                     return False
                 def get_absolute_url(self):
                     return reverse('url_%s_conf' % self.device.device_type.name, args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_%s_conf' % self.device.device_type.name, args=[str(self.id)])
                 def get_absolute_url_delete(self):
                     return reverse('url_delete_dev_conf', args=[str(self.id)])
                 def get_absolute_url_import(self):
                     return reverse('url_import_dev_conf', args=[str(self.id)])
                 def get_absolute_url_export(self):
                     return reverse('url_export_dev_conf', args=[str(self.id)])
                 def get_absolute_url_write(self):
                     return reverse('url_write_dev_conf', args=[str(self.id)])
                 def get_absolute_url_read(self):
                     return reverse('url_read_dev_conf', args=[str(self.id)])
                 def get_absolute_url_start(self):
                     return reverse('url_start_dev_conf', args=[str(self.id)])
                 def get_absolute_url_stop(self):
                     return reverse('url_stop_dev_conf', args=[str(self.id)])
                 def get_absolute_url_status(self):
                     return reverse('url_status_dev_conf', args=[str(self.id)])

apps/main/templates/base.html +1 0

             <!DOCTYPE html>
             {% 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/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"-->
                 <!-- 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">
                     .logo {padding-top: 5px; height: 50px}
                     .clickable-row {cursor: pointer;}
                     .col-no-padding { padding-left:0;}
                     .gi-2x{font-size: 2em;}
                     .gi-3x{font-size: 3em;}
                     .gi-4x{font-size: 4em;}
                     .gi-5x{font-size: 5em;}
               </style>
               <script src="{% static 'js/jquery.min.js' %}"></script>
               {% block extra-head %}{% endblock %}
             </head>
             <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>
+                    <br>
                     </div>
                     {% block messages %}
                       {% if messages %}
                         {% for message in 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">
                           <button type="button" class="close" data-dismiss="alert" aria-label="Close"><span aria-hidden="true">&times;</span></button>
                           <strong>{{message.tags|title}}!</strong> {{ message }}
                         </div>
                         {% endfor %}
                       {% endif %}
                     {% endblock %}
                    {% block content %}
                    {% endblock %}
                   </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 +14 0

             {% 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 %}
               {% if device_dds == 'dds_rest' %}
                 {% block dds_rest%}
                 {% endblock %}
               {% else %}
                 {% bootstrap_form form layout='horizontal' size='medium' %}
+                  {% if form_pedestal %}
+                    <br>
+                    <h1>Pedestal</h1>
+                    <br>
+                    {% bootstrap_form form_pedestal layout='horizontal' size='medium' %}
+                    <br>
+                    <h1>RX</h1>
+                    <br>
+                    {% bootstrap_form form_rx layout='horizontal' size='medium' %}
+                    <br>
+                    <h1>TX</h1>
+                    <br>
+                    {% bootstrap_form form_tx layout='horizontal' size='medium' %}
+                  {% endif %}
               {% 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>
             {% endblock %}
             {% block sidebar%}
                {% include "sidebar_devices.html" %}
             {% endblock %}

apps/main/templates/experiment_edit.html +1 0

             {% extends "base_edit.html" %}
             {% load bootstrap4 %}
             {% load static %}
             {% load main_tags %}
             {% block extra-head %}
             <link href="{% static 'css/bootstrap-datetimepicker.min.css' %}" media="screen" rel="stylesheet">
             {% endblock %}
             {% block extra-js%}
             <script src="{% static 'js/bootstrap-datetimepicker.min.js' %}"></script>
             <script type="text/javascript">
               $('.input-group.time').datetimepicker({
                 format: 'HH:mm:ss',
                 icons: {
                   time: 'far fa-clock',
                   date: 'far fa-calendar-alt',
                   up: 'fas fa-arrow-up',
                   down: 'fas fa-arrow-down',
                   previous: 'fas fa-chevron-left',
                   next: 'fas fa-chevron-right',
                   today: 'far fa-calendar-check',
                   clear: 'far fa-trash-alt',
                   close: 'fas fa-times'
                 }
               });
               $('#id_create_from').change(function() {
                 var url = "{% url 'url_add_experiment' %}";
                 if ($(this).val()=="2"){
                   document.location = url+"?template=0";
                 }else if ($(this).val()=="1"){
                   document.location = url+"?blank=0";
                 }else{
                   document.location = url;
                 }
               });
               $('#id_choose_template').change(function() {
                 var url = "{% url 'url_add_experiment' %}";
                 document.location = url+"?template="+$(this).val();
               });
             </script>
             {% endblock %}

apps/main/views.py +48 -26

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

apps/pedestal/forms.py +35 -4

             import os
             import json
             from django import forms
             from django.utils.safestring import mark_safe
             from apps.main.models import Device
             from apps.main.forms import add_empty_choice
             from .models import PedestalConfiguration
             def create_choices_from_model(model, conf_id, all_choice=False):
                 instance = globals()[model]
                 choices = instance.objects.all().values_list('pk', 'name')
                 return choices
             class PedestalConfigurationForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(PedestalConfigurationForm, self).__init__(*args, **kwargs)
                     instance = getattr(self, 'instance', None)
                     if instance and instance.pk:
                         devices = Device.objects.filter(device_type__name='pedestal')
-                        if instance.experiment:
+                        #if instance.experiment:
-                            self.fields['experiment'].widget.attrs['read_only'] = True
+                            #self.fields['experiment'].widget.attrs['read_only'] = True
                             #self.fields['experiment'].widget.choices = [(instance.experiment.id, instance.experiment)]
-                        self.fields['device'].widget.choices = [(device.id, device) for device in devices]
+                        #self.fields['device'].widget.choices = [(device.id, device) for device in devices]
                     if 'initial' in kwargs and 'experiment' in kwargs['initial'] and kwargs['initial']['experiment'] not in (0, '0'):
                         self.fields['experiment'].widget.attrs['readonly'] = True
                 class Meta:
                     model = PedestalConfiguration
-                    exclude = ('type', 'parameters', 'status', 'total_units', 'author', 'hash')
+                    exclude = ('template', 'type', 'parameters', 'status', 'total_units', 'author', 'hash')
                 def clean(self):
                     form_data = super(PedestalConfigurationForm, self).clean()
                     return form_data
                 def save(self, *args, **kwargs):
                     conf = super(PedestalConfigurationForm, self).save(*args, **kwargs)
                     conf.save()
                     return conf
+            class PedestalEditionForm(forms.ModelForm):
+                def __init__(self, *args, **kwargs):
+                    super(PedestalEditionForm, self).__init__(*args, **kwargs)
+                    instance = getattr(self, 'instance', None)
+                    if instance and instance.pk:
+                        devices = Device.objects.filter(device_type__name='pedestal')
+                        #if instance.experiment:
+                            #self.fields['experiment'].widget.attrs['read_only'] = True
+                            #self.fields['experiment'].widget.choices = [(instance.experiment.id, instance.experiment)]
+                        #self.fields['device'].widget.choices = [(device.id, device) for device in devices]
+                    if 'initial' in kwargs and 'experiment' in kwargs['initial'] and kwargs['initial']['experiment'] not in (0, '0'):
+                        self.fields['experiment'].widget.attrs['readonly'] = True
+                class Meta:
+                    model = PedestalConfiguration
+                    exclude = ('device', 'label', 'template', 'type', 'parameters', 'status', 'total_units', 'author', 'hash')
+                def clean(self):
+                    form_data = super(PedestalEditionForm, self).clean()
+                    return form_data
+                def save(self, *args, **kwargs):
+                    conf = super(PedestalEditionForm, self).save(*args, **kwargs)
+                    conf.save()
+                    return conf
             class ExtFileField(forms.FileField):
                 """
                 Same as forms.FileField, but you can specify a file extension whitelist.
                 >>> from django.core.files.uploadedfile import SimpleUploadedFile
                 >>>
                 >>> t = ExtFileField(ext_whitelist=(".pdf", ".txt"))
                 >>>
                 >>> t.clean(SimpleUploadedFile('filename.pdf', 'Some File Content'))
                 >>> t.clean(SimpleUploadedFile('filename.txt', 'Some File Content'))
                 >>>
                 >>> t.clean(SimpleUploadedFile('filename.exe', 'Some File Content'))
                 Traceback (most recent call last):
                 ...
                 ValidationError: [u'Not allowed filetype!']
                 """
                 def __init__(self, *args, **kwargs):
                     extensions = kwargs.pop("extensions")
                     self.extensions = [i.lower() for i in extensions]
                     super(ExtFileField, self).__init__(*args, **kwargs)
                 def clean(self, *args, **kwargs):
                     data = super(ExtFileField, self).clean(*args, **kwargs)
                     filename = data.name
                     ext = os.path.splitext(filename)[1]
                     ext = ext.lower()
                     if ext not in self.extensions:
                         raise forms.ValidationError('Not allowed file type: %s' % ext)
             class PedestalImportForm(forms.Form):
                 file_name = ExtFileField(extensions=['.racp', '.json', '.dat'])

apps/pedestal/models.py +7 -7

             import ast
             import json
             import requests
             import base64
             import struct
             from struct import pack
             import time
             from django.contrib import messages
             from django.db import models
             from django.urls import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from apps.main.models import Configuration
             AXIS_VALUE = (
-                    ('AZI', 'azimuth'),
+                    ('azimuth', 'PPI'),
-                    ('ELE', 'elevation')
+                    ('elevation', 'RHI')
                 )
             class PedestalConfiguration(Configuration):
                 axis = models.CharField(
                     verbose_name='Axis',
-                    max_length=3,
+                    max_length=10,
                     choices=AXIS_VALUE,
                     null=False,
                     blank=False
                 )
                 speed = models.FloatField(
                     verbose_name='Speed',
                     validators=[MinValueValidator(-20), MaxValueValidator(20)],
                     blank=False,
                     null=False
                 )
                 table = models.CharField(
                     verbose_name="Table",
                     max_length=100,
                     default='',
                     blank=False,
                     null=False,
                     help_text="Please separate the values with commas"
                 )
                 class Meta:
                     db_table = 'pedestal_configurations'
                 def __str__(self):
                     return str(self.label)
                 def get_absolute_url_plot(self):
                     return reverse('url_plot_pedestal_pulses', args=[str(self.id)])
                 def request(self, cmd, method='get', **kwargs):
                     req = getattr(requests, method)(self.device.url(cmd), **kwargs)
                     payload = req.json()
                     return payload
                 def status_device(self):
                     try:
                         #self.device.status = 0
                         #payload = self.request('status')
                         payload = requests.get(self.device.url())
                         print(payload)
                         if payload:
                             self.device.status = 1
                         elif payload['status']=='disable':
                             self.device.status = 2
                         else:
                             self.device.status = 1
                             self.device.save()
                             self.message = 'Pedestal 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 = 'Pedestal status: {}'.format(str(e))
                         return False
                     self.device.save()
                     return True
                 def reset_device(self):
                     try:
                         payload = self.request('reset', 'post')
                         if payload['reset']=='ok':
                             self.message = 'Pedestal restarted OK'
                             self.device.status = 2
                             self.device.save()
                         else:
                             self.message = 'Pedestal restart fail'
                             self.device.status = 4
                             self.device.save()
                     except Exception as e:
                         self.message = 'Pedestal reset: {}'.format(str(e))
                         return False
                     return True
                 def stop_device(self):
                     try:
                         command = self.device.url() + "stop"
                         r = requests.get(command)
                         if r:
                             self.device.status = 4
                             self.device.save()
                             self.message = 'Pedestal stopped'
                         else:
                             self.device.status = 4
                             self.device.save()
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         #self.message = 'Pedestal stop: {}'.format(str(e))
                         self.message = "Pedestal can't start, please check network/device connection or IP address/port configuration"
                         self.device.save()
                         return False
                     return True
                 def start_device(self):
                     try:
                         pedestal = PedestalConfiguration.objects.get(pk=self)
                         print(pedestal)
-                        pedestal_axis = pedestal.get_axis_display()
+                        #pedestal_axis = pedestal.get_axis_display()
                         print(pedestal)
-                        print(pedestal_axis)
+                        #print(pedestal_axis)
                         table = pedestal.table
                         print(table)
                         li = list(table.split(","))
                         print(li)
                         list_of_floats = []
                         for item in li:
                             list_of_floats.append(float(item))
                         print(list_of_floats)
                         byte_table = []
                         for x in list_of_floats:
                             temp = bytearray(struct.pack("f", x))
                             byte_table.append(temp[3])
                             byte_table.append(temp[2])
                             byte_table.append(temp[1])
                             byte_table.append(temp[0])
                         print(byte_table)
                         coded_table = base64.standard_b64encode(bytes(byte_table))
                         coded_table_ascii = coded_table.decode('ascii')
                         print(coded_table_ascii)
-                        data = {'axis': pedestal_axis, 'speed': pedestal.speed, 'table': coded_table_ascii}
+                        data = {'axis': pedestal.axis, 'speed': pedestal.speed, 'table': coded_table_ascii}
                         print(data)
                         json_data = json.dumps(data)
                         print(json_data)
                         first_position = table[0]
-                        if pedestal.axis=='azimuth':
+                        if pedestal.axis=='PPI':
                             json_az = json.dumps({"axis": 'azimuth', "position": 0.0})
                             json_el = json.dumps({"axis": 'elevation', "position": first_position})
                         else:
                             json_az = json.dumps({"axis": 'azimuth', "position": first_position})
                             json_el = json.dumps({"axis": 'elevation', "position": 0.0})
                         base64_table = base64.standard_b64encode(json_data.encode('ascii'))
                         base64_az = base64.standard_b64encode(json_az.encode('ascii'))
                         base64_el = base64.standard_b64encode(json_el.encode('ascii'))
                         table_url = self.device.url() + "table?params="
                         az_url = self.device.url() + "position?params="
                         el_url = self.device.url() + "position?params="
                         complete_url = table_url + base64_table.decode('ascii')
                         az_url = az_url + base64_az.decode('ascii')
                         el_url = el_url + base64_el.decode('ascii')
                         print(complete_url)
                         print(az_url)
                         print(el_url)
                         r = requests.get(az_url)
                         r = requests.get(el_url)
                         #time.sleep(10)
                         r = requests.get(complete_url)
                         if r:
                             self.device.status = 3
                             self.device.save()
                             self.message = 'Pedestal configured and started'
                         else:
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         #self.message = 'Pedestal start: {}'.format(str(e))
                         self.message = "Pedestal can't start, please check network/device connection or IP address/port configuration"
                         self.device.save()
                         return False
                     return True
                 #def write_device(self, raw=False):
                     if not raw:
                         clock = RCClock.objects.get(rc_configuration=self)
                         print(clock)
                         if clock.mode:
                             data = {'default': clock.frequency}
                         else:
                             data = {'manual': [clock.multiplier, clock.divisor, clock.reference]}
                         payload = self.request('setfreq', 'post', data=json.dumps(data))
                         print(payload)
                         if payload['command'] != 'ok':
                             self.message = 'Pedestal write: {}'.format(payload['command'])
                         else:
                             self.message = payload['programming']
                             if payload['programming'] == 'fail':
                                 self.message = 'Pedestal write: error programming CGS chip'
                     values = []
                     for pulse, delay in zip(self.get_pulses(), self.get_delays()):
                         while delay>65536:
                             values.append((pulse, 65535))
                             delay -= 65536
                         values.append((pulse, delay-1))
                     data = bytearray()
                     #reset
                     data.extend((128, 0))
                     #disable
                     data.extend((129, 0))
                     #SW switch
                     if self.control_sw:
                         data.extend((130, 2))
                     else:
                         data.extend((130, 0))
                     #divider
                     data.extend((131, self.clock_divider-1))
                     #enable writing
                     data.extend((139, 62))
                     last = 0
                     for tup in values:
                         vals = pack('<HH', last^tup[0], tup[1])
                         last = tup[0]
                         data.extend((133, vals[1], 132, vals[0], 133, vals[3], 132, vals[2]))
                     #enable
                     data.extend((129, 1))
                     if raw:
                         return b64encode(data)
                     try:
                         payload = self.request('stop', 'post')
                         payload = self.request('reset', 'post')
                         #payload = self.request('divider', 'post', data={'divider': self.clock_divider-1})
                         #payload = self.request('write', 'post', data=b64encode(bytearray((139, 62))), timeout=20)
                         n = len(data)
                         x = 0
                         #while x < n:
                         payload = self.request('write', 'post', data=b64encode(data))
                         #    x += 1024
                         if payload['write']=='ok':
                             self.device.status = 3
                             self.device.save()
                             self.message = 'Pedestal configured and started'
                         else:
                             self.device.status = 1
                             self.device.save()
                             self.message = 'Pedestal write: {}'.format(payload['write'])
                             return False
                         #payload = self.request('start', 'post')
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         self.message = 'Pedestal write: {}'.format(str(e))
                         self.device.save()
                         return False
                     return True
                 def get_absolute_url_import(self):
                     return reverse('url_import_pedestal_conf', args=[str(self.id)])

apps/pedestal/templates/pedestal_conf_edit.html 0 -1

             {% extends "dev_conf_edit.html" %}
             {% load bootstrap4 %}
             {% load static %}
             {% block extra-head %}
             <style type="text/css">
                 /* show the move cursor as the user moves the mouse over the panel header.*/
                 .panel-default { cursor: move; }
             </style>
             <script src="{% static 'js/jquery-ui.min.js' %}"></script>
             {% endblock %}
             {% block content %}
             <form class="form" method="post">
               {% csrf_token %}
-              <h2>Pedestal</h2>
               {% bootstrap_form form layout='horizontal' size='medium' %}
               <div style="clear: both;"></div>
               <br>
               <div class="pull-right">
               <button type="button" class="btn btn-primary" onclick="{% if previous %}window.location.replace('{{ previous }}');{% else %}history.go(-1);{% endif %}">Cancel</button>
               <button type="submit" class="btn btn-primary">{{button}}</button>
               </div>
             </form>
             {% endblock %}
   No newline at end of file

apps/pedestal/views.py +1 -1

             import json
             from django.contrib import messages
             from django.utils.safestring import mark_safe
             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from django.contrib.auth.decorators import login_required
             from apps.main.models import Experiment, Device
             from apps.main.views import sidebar
             from .models import PedestalConfiguration
             from .forms import PedestalConfigurationForm, PedestalImportForm
             def conf(request, conf_id):
                 conf = get_object_or_404(PedestalConfiguration, pk=conf_id)
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 kwargs['dev_conf_keys'] = ['axis', 'speed', 'table']
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'Detail'
                 kwargs['button'] = 'Edit Configuration'
                 conf.status_device()
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'pedestal_conf.html', kwargs)
             @login_required
             def conf_edit(request, conf_id):
                 conf = get_object_or_404(PedestalConfiguration, pk=conf_id)
                 print(conf)
                 #print("fin de carga de params")
                 if request.method=='GET':
                     print("GET case")
                     form = PedestalConfigurationForm(instance=conf)
                     print(form)
                 elif request.method=='POST':
                     #print("ingreso a post conf edit")
                     line_data = {}
                     conf_data = {}
                     clock_data = {}
                     extras = []
                     print("Inicio impresion POST#####")
                     print(request.POST.items)
                     print("Fin impresion de POST items#####")
                     #classified post fields
                     for label,value in request.POST.items():
                         if label=='csrfmiddlewaretoken':
                             continue
                         if label.count('|')==0:
                             if label in ('mode', 'multiplier', 'divisor', 'reference', 'frequency'):
                                 clock_data[label] = value
                             else:
                                 conf_data[label] = value
                             continue
                         elif label.split('|')[0]!='-1':
                             extras.append(label)
                             continue
                         #print(label)
                         x, pk, name = label.split('|')
                         if name=='codes':
                             value = [s for s in value.split('\r\n') if s]
                         if pk in line_data:
                             line_data[pk][name] = value
                         else:
                             line_data[pk] = {name:value}
                         #print(line_data[pk])
                     #update conf
                     form = PedestalConfigurationForm(conf_data, instance=conf)
                     #print(request.POST.items())
                     if form.is_valid():
                         form.save()
                         messages.success(request, 'Pedestal configuration successfully updated')
                         return redirect(conf.get_absolute_url())
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 kwargs['form'] = form
                 kwargs['edit'] = True
                 kwargs['title'] = 'Pedestal Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 print(kwargs)
                 print(form)
                 return render(request, 'pedestal_conf_edit.html', kwargs)
             def import_file(request, conf_id):
                 conf = get_object_or_404(PedestalConfiguration, pk=conf_id)
                 if request.method=='POST':
                     form = PedestalImportForm(request.POST, request.FILES)
                     if form.is_valid():
                         try:
                             data = conf.import_from_file(request.FILES['file_name'])
                             conf.dict_to_parms(data)
                             messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name'])
                             return redirect(conf.get_absolute_url_edit())
                         except Exception as e:
                             messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], repr(e)))
                 else:
                     messages.warning(request, 'Your current configuration will be replaced')
                     form = PedestalImportForm()
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Pedestal Configuration'
                 kwargs['suptitle'] = 'Import file'
                 kwargs['button'] = 'Upload'
                 kwargs['previous'] = conf.get_absolute_url()
                 return render(request, 'pedestal_import.html', kwargs)
             def conf_raw(request, conf_id):
                 conf = get_object_or_404(PedestalConfiguration, pk=conf_id)
                 raw = conf.write_device(raw=True)
                 return HttpResponse(raw, content_type='application/json')

apps/usrp_rx/forms.py +34 -3

             import os
             import json
             from django import forms
             from django.utils.safestring import mark_safe
             from apps.main.models import Device
             from apps.main.forms import add_empty_choice
             from .models import USRPRXConfiguration
             def create_choices_from_model(model, conf_id, all_choice=False):
                 instance = globals()[model]
                 choices = instance.objects.all().values_list('pk', 'name')
                 return choices
             class USRPRXConfigurationForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(USRPRXConfigurationForm, self).__init__(*args, **kwargs)
                     instance = getattr(self, 'instance', None)
                     if instance and instance.pk:
                         devices = Device.objects.filter(device_type__name='usrp_rx')
-                        if instance.experiment:
+                        #if instance.experiment:
-                            self.fields['experiment'].widget.attrs['read_only'] = True
+                            #self.fields['experiment'].widget.attrs['read_only'] = True
                             #self.fields['experiment'].widget.choices = [(instance.experiment.id, instance.experiment)]
-                        self.fields['device'].widget.choices = [(device.id, device) for device in devices]
+                        #self.fields['device'].widget.choices = [(device.id, device) for device in devices]
                     if 'initial' in kwargs and 'experiment' in kwargs['initial'] and kwargs['initial']['experiment'] not in (0, '0'):
                         self.fields['experiment'].widget.attrs['readonly'] = True
                 class Meta:
                     model = USRPRXConfiguration
                     exclude = ('type', 'parameters', 'status', 'total_units', 'author', 'hash')
                 def clean(self):
                     form_data = super(USRPRXConfigurationForm, self).clean()
                     return form_data
                 def save(self, *args, **kwargs):
                     conf = super(USRPRXConfigurationForm, self).save(*args, **kwargs)
                     conf.save()
                     return conf
+            class USRPRXEditionForm(forms.ModelForm):
+                def __init__(self, *args, **kwargs):
+                    super(USRPRXEditionForm, self).__init__(*args, **kwargs)
+                    instance = getattr(self, 'instance', None)
+                    if instance and instance.pk:
+                        devices = Device.objects.filter(device_type__name='usrp_rx')
+                        #if instance.experiment:
+                            #self.fields['experiment'].widget.attrs['read_only'] = True
+                            #self.fields['experiment'].widget.choices = [(instance.experiment.id, instance.experiment)]
+                        #self.fields['device'].widget.choices = [(device.id, device) for device in devices]
+                    if 'initial' in kwargs and 'experiment' in kwargs['initial'] and kwargs['initial']['experiment'] not in (0, '0'):
+                        self.fields['experiment'].widget.attrs['readonly'] = True
+                class Meta:
+                    model = USRPRXConfiguration
+                    exclude = ('template', 'device', 'label', 'ip_address', 'daughterboard', 'antenna', 'type', 'parameters', 'status', 'total_units', 'author', 'hash')
+                def clean(self):
+                    form_data = super(USRPRXEditionForm, self).clean()
+                    return form_data
+                def save(self, *args, **kwargs):
+                    conf = super(USRPRXEditionForm, self).save(*args, **kwargs)
+                    conf.save()
+                    return conf
             class ExtFileField(forms.FileField):
                 """
                 Same as forms.FileField, but you can specify a file extension whitelist.
                 >>> from django.core.files.uploadedfile import SimpleUploadedFile
                 >>>
                 >>> t = ExtFileField(ext_whitelist=(".pdf", ".txt"))
                 >>>
                 >>> t.clean(SimpleUploadedFile('filename.pdf', 'Some File Content'))
                 >>> t.clean(SimpleUploadedFile('filename.txt', 'Some File Content'))
                 >>>
                 >>> t.clean(SimpleUploadedFile('filename.exe', 'Some File Content'))
                 Traceback (most recent call last):
                 ...
                 ValidationError: [u'Not allowed filetype!']
                 """
                 def __init__(self, *args, **kwargs):
                     extensions = kwargs.pop("extensions")
                     self.extensions = [i.lower() for i in extensions]
                     super(ExtFileField, self).__init__(*args, **kwargs)
                 def clean(self, *args, **kwargs):
                     data = super(ExtFileField, self).clean(*args, **kwargs)
                     filename = data.name
                     ext = os.path.splitext(filename)[1]
                     ext = ext.lower()
                     if ext not in self.extensions:
                         raise forms.ValidationError('Not allowed file type: %s' % ext)
             class USRPRXImportForm(forms.Form):
                 file_name = ExtFileField(extensions=['.racp', '.json', '.dat'])

apps/usrp_rx/models.py +1 -1

             import ast
             import json
             import requests
             import base64
             from struct import pack
             from django.db import models
             from django.urls import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from apps.main.models import Configuration
             BOARD_VALUE = (
                     ('1', 'A:AB'),
                     ('2', 'AB'),
                     ('3', 'A:A A:B'),
                 )
             ANT_VALUE = (
                     ('1', 'RX'),
                     ('2', 'TX')
                 )
             CLK_VALUE = (
                     ('1', 'internal'),
                     ('2', 'external')
                 )
             TIME_VALUE = (
                     ('1', 'internal'),
                     ('2', 'external')
                 )
             class USRPRXConfiguration(Configuration):
                 ip_address = models.GenericIPAddressField(
                     verbose_name = 'IP address',
                     protocol='IPv4',
                     default='0.0.0.0')
                 daughterboard = models.CharField(
                     verbose_name='Daughterboard',
                     max_length=3,
                     choices=BOARD_VALUE,
                     null=False,
                     blank=False
                 )
                 antenna = models.CharField(
                     verbose_name='Antenna',
                     max_length=3,
                     choices=ANT_VALUE,
                     null=False,
                     blank=False
                 )
                 samplerate = models.FloatField(
                     verbose_name='Sample Rate',
                     blank=False,
                     null=False,
                     help_text='Introduce the value in MHz (10^6)'
                 )
                 frequency = models.FloatField(
                     verbose_name='Frequency',
                     blank=False,
                     null=False,
                     help_text='Introduce the value in MHz (10^6)'
                 )
                 datadir = models.CharField(
                     verbose_name="Data Directory",
                     max_length=100,
                     default='',
                     blank=False,
                     null=False,
                     help_text='Fill with a directory. Example: /media/soporte/DATA'
                 )
                 clocksource = models.CharField(
                     verbose_name='Clock Source',
                     max_length=3,
                     choices=CLK_VALUE,
                     null=False,
                     blank=False
                 )
                 timesource = models.CharField(
                     verbose_name='Time Source',
                     max_length=3,
                     choices=TIME_VALUE,
                     null=False,
                     blank=False
                 )
                 clockrate = models.FloatField(
                     verbose_name='Clock Rate',
                     blank=False,
                     null=False,
                     help_text='Introduce the value in MHz (10^6)'
                 )
                 class Meta:
                     db_table = 'usrp_rx_configurations'
                 def __str__(self):
                     return str(self.label)
                 def get_absolute_url_plot(self):
                     return reverse('url_plot_usrp_rx_pulses', args=[str(self.id)])
                 def request(self, cmd, method='get', **kwargs):
                     req = getattr(requests, method)(self.device.url(cmd), **kwargs)
                     payload = req.json()
                     return payload
                 def status_device(self):
                     try:
                         #self.device.status = 0
                         #payload = self.request('status')
                         payload = requests.get(self.device.url())
                         print(payload)
                         if payload:
                             self.device.status = 1
                         elif payload['status']=='disable':
                             self.device.status = 2
                         else:
                             self.device.status = 1
                             self.device.save()
                             self.message = 'USRP Rx Dev 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 = 'USRP Rx status: {}'.format(str(e))
                         return False
                     self.device.save()
                     return True
                 def reset_device(self):
                     try:
                         payload = self.request('reset', 'post')
                         if payload['reset']=='ok':
                             self.message = 'USRP Rx restarted OK'
                             self.device.status = 2
                             self.device.save()
                         else:
                             self.message = 'USRP Rx restart fail'
                             self.device.status = 4
                             self.device.save()
                     except Exception as e:
                         self.message = 'USRP Rx reset: {}'.format(str(e))
                         return False
                     return True
                 def stop_device(self):
                     try:
-                        command = self.device.url() + "stop"
+                        command = self.device.url() + "stoprx"
                         r = requests.get(command)
                         if r:
                             self.device.status = 4
                             self.device.save()
                             self.message = 'USRP stopped'
                         else:
                             self.device.status = 4
                             self.device.save()
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         #self.message = 'USRP Rx stop: {}'.format(str(e))
                         self.message = "USRP Rx can't start, please check network/device connection or IP address/port configuration"
                         self.device.save()
                         return False
                     return True
                 def start_device(self):
                     try:
                         usrp = USRPRXConfiguration.objects.get(pk=self)
                         usrp_daughterboard = usrp.get_daughterboard_display()
                         usrp_antenna = usrp.get_antenna_display()
                         usrp_clocksource = usrp.get_clocksource_display()
                         usrp_timesource = usrp.get_timesource_display()
                         print(usrp)
                         payload = {'ip_address': usrp.ip_address, 'daughterboard': usrp_daughterboard, 'antenna': usrp_antenna, 'sample_rate': usrp.samplerate, 'frequency': usrp.frequency,
                                 'datadir': usrp.datadir, 'clock_source': usrp_clocksource, 'time_source': usrp_timesource, 'clock_rate':usrp.clockrate}
                         print(payload)
                         r = requests.post(self.device.url("usrprx"), json=payload)
                         print(r.text)
                         #payload = self.request('usrp', 'post', data=json.dumps(data))
                         #print(payload)
                         if r:
                             self.device.status = 3
                             self.device.save()
                             self.message = 'USRP Rx configured and started'
                         else:
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         #self.message = 'USRP Rx start: {}'.format(str(e))
                         self.message = "USRP Rx can't start, please check network/device connection or IP address/port configuration"
                         self.device.save()
                         return False
                     return True
                 #def write_device(self, raw=False):
                     if not raw:
                         clock = RCClock.objects.get(rc_configuration=self)
                         print(clock)
                         if clock.mode:
                             data = {'default': clock.frequency}
                         else:
                             data = {'manual': [clock.multiplier, clock.divisor, clock.reference]}
                         payload = self.request('setfreq', 'post', data=json.dumps(data))
                         print(payload)
                         if payload['command'] != 'ok':
                             self.message = 'USRP Rx write: {}'.format(payload['command'])
                         else:
                             self.message = payload['programming']
                             if payload['programming'] == 'fail':
                                 self.message = 'USRP Rx write: error programming CGS chip'
                     values = []
                     for pulse, delay in zip(self.get_pulses(), self.get_delays()):
                         while delay>65536:
                             values.append((pulse, 65535))
                             delay -= 65536
                         values.append((pulse, delay-1))
                     data = bytearray()
                     #reset
                     data.extend((128, 0))
                     #disable
                     data.extend((129, 0))
                     #SW switch
                     if self.control_sw:
                         data.extend((130, 2))
                     else:
                         data.extend((130, 0))
                     #divider
                     data.extend((131, self.clock_divider-1))
                     #enable writing
                     data.extend((139, 62))
                     last = 0
                     for tup in values:
                         vals = pack('<HH', last^tup[0], tup[1])
                         last = tup[0]
                         data.extend((133, vals[1], 132, vals[0], 133, vals[3], 132, vals[2]))
                     #enable
                     data.extend((129, 1))
                     if raw:
                         return b64encode(data)
                     try:
                         payload = self.request('stop', 'post')
                         payload = self.request('reset', 'post')
                         #payload = self.request('divider', 'post', data={'divider': self.clock_divider-1})
                         #payload = self.request('write', 'post', data=b64encode(bytearray((139, 62))), timeout=20)
                         n = len(data)
                         x = 0
                         #while x < n:
                         payload = self.request('write', 'post', data=b64encode(data))
                         #    x += 1024
                         if payload['write']=='ok':
                             self.device.status = 3
                             self.device.save()
                             self.message = 'USRP Rx configured and started'
                         else:
                             self.device.status = 1
                             self.device.save()
                             self.message = 'USRP Rx write: {}'.format(payload['write'])
                             return False
                         #payload = self.request('start', 'post')
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         self.message = 'USRP Rx write: {}'.format(str(e))
                         self.device.save()
                         return False
                     return True
                 def get_absolute_url_import(self):
                     return reverse('url_import_usrp_rx_conf', args=[str(self.id)])

apps/usrp_tx/forms.py +34 -3

             import os
             import json
             from django import forms
             from django.utils.safestring import mark_safe
             from apps.main.models import Device
             from apps.main.forms import add_empty_choice
             from .models import USRPTXConfiguration
             def create_choices_from_model(model, conf_id, all_choice=False):
                 instance = globals()[model]
                 choices = instance.objects.all().values_list('pk', 'name')
                 return choices
             class USRPTXConfigurationForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(USRPTXConfigurationForm, self).__init__(*args, **kwargs)
                     instance = getattr(self, 'instance', None)
                     if instance and instance.pk:
                         devices = Device.objects.filter(device_type__name='usrp_tx')
-                        if instance.experiment:
+                        #if instance.experiment:
-                            self.fields['experiment'].widget.attrs['read_only'] = True
+                            #self.fields['experiment'].widget.attrs['read_only'] = True
                             #self.fields['experiment'].widget.choices = [(instance.experiment.id, instance.experiment)]
-                        self.fields['device'].widget.choices = [(device.id, device) for device in devices]
+                        #self.fields['device'].widget.choices = [(device.id, device) for device in devices]
                     if 'initial' in kwargs and 'experiment' in kwargs['initial'] and kwargs['initial']['experiment'] not in (0, '0'):
                         self.fields['experiment'].widget.attrs['readonly'] = True
                 class Meta:
                     model = USRPTXConfiguration
                     exclude = ('type', 'parameters', 'status', 'total_units', 'author', 'hash')
                 def clean(self):
                     form_data = super(USRPTXConfigurationForm, self).clean()
                     return form_data
                 def save(self, *args, **kwargs):
                     conf = super(USRPTXConfigurationForm, self).save(*args, **kwargs)
                     conf.save()
                     return conf
+            class USRPTXEditionForm(forms.ModelForm):
+                def __init__(self, *args, **kwargs):
+                    super(USRPTXEditionForm, self).__init__(*args, **kwargs)
+                    instance = getattr(self, 'instance', None)
+                    if instance and instance.pk:
+                        devices = Device.objects.filter(device_type__name='usrp_tx')
+                        #if instance.experiment:
+                            #self.fields['experiment'].widget.attrs['read_only'] = True
+                            #self.fields['experiment'].widget.choices = [(instance.experiment.id, instance.experiment)]
+                        #self.fields['device'].widget.choices = [(device.id, device) for device in devices]
+                    if 'initial' in kwargs and 'experiment' in kwargs['initial'] and kwargs['initial']['experiment'] not in (0, '0'):
+                        self.fields['experiment'].widget.attrs['readonly'] = True
+                class Meta:
+                    model = USRPTXConfiguration
+                    exclude = ('template', 'device', 'label', 'ip_address', 'daughterboard', 'antenna', 'type', 'parameters', 'status', 'total_units', 'author', 'hash')
+                def clean(self):
+                    form_data = super(USRPTXEditionForm, self).clean()
+                    return form_data
+                def save(self, *args, **kwargs):
+                    conf = super(USRPTXEditionForm, self).save(*args, **kwargs)
+                    conf.save()
+                    return conf
             class ExtFileField(forms.FileField):
                 """
                 Same as forms.FileField, but you can specify a file extension whitelist.
                 >>> from django.core.files.uploadedfile import SimpleUploadedFile
                 >>>
                 >>> t = ExtFileField(ext_whitelist=(".pdf", ".txt"))
                 >>>
                 >>> t.clean(SimpleUploadedFile('filename.pdf', 'Some File Content'))
                 >>> t.clean(SimpleUploadedFile('filename.txt', 'Some File Content'))
                 >>>
                 >>> t.clean(SimpleUploadedFile('filename.exe', 'Some File Content'))
                 Traceback (most recent call last):
                 ...
                 ValidationError: [u'Not allowed filetype!']
                 """
                 def __init__(self, *args, **kwargs):
                     extensions = kwargs.pop("extensions")
                     self.extensions = [i.lower() for i in extensions]
                     super(ExtFileField, self).__init__(*args, **kwargs)
                 def clean(self, *args, **kwargs):
                     data = super(ExtFileField, self).clean(*args, **kwargs)
                     filename = data.name
                     ext = os.path.splitext(filename)[1]
                     ext = ext.lower()
                     if ext not in self.extensions:
                         raise forms.ValidationError('Not allowed file type: %s' % ext)
             class USRPTXImportForm(forms.Form):
                 file_name = ExtFileField(extensions=['.racp', '.json', '.dat'])

apps/usrp_tx/models.py +2 -1

             import ast
             import json
             import requests
             import base64
             from struct import pack
             from django.db import models
             from django.urls import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from apps.main.models import Configuration
             BOARD_VALUE = (
                     ('1', 'A:AB'),
                     ('2', 'AB')
                 )
             ANT_VALUE = (
                     ('1', 'RX'),
                     ('2', 'TX'),
                     ('3', 'TX/RX')
                 )
             TYPE_VALUE = (
                     ('0', 'None'),
                     ('1', 'User define'),
                     ('2', 'Barker 2'),
                     ('3', 'Barker 3'),
                     ('4', 'Barker 4'),
                     ('5', 'Barker 5'),
                     ('7', 'Barker 7'),
                     ('11', 'Barker 11'),
                     ('13', 'Barker 13')
                 )
             class USRPTXConfiguration(Configuration):
                 ip_address = models.GenericIPAddressField(
                     verbose_name = 'IP address',
                     protocol='IPv4',
                     default='0.0.0.0')
                 daughterboard = models.CharField(
                     verbose_name='Daughterboard',
                     max_length=3,
                     choices=BOARD_VALUE,
                     null=False,
                     blank=False
                 )
                 antenna = models.CharField(
                     verbose_name='Antenna',
                     max_length=3,
                     choices=ANT_VALUE,
                     null=False,
                     blank=False
                 )
                 frequency = models.FloatField(
                     verbose_name='Frequency',
                     blank=False,
                     null=False,
                     help_text='Introduce the value in MHz (10^6)'
                 )
                 samplerate = models.FloatField(
                     verbose_name='Sample rate',
                     blank=False,
                     null=False,
                     help_text='Introduce the value in MHz (10^6)'
                 )
                 ipp = models.FloatField(
                     verbose_name='IPP',
                     blank=False,
                     null=False,
                     help_text='Introduce the value in km'
                 )
                 enable_1 = models.BooleanField(
                     verbose_name='Pulse 1',
                     default=True,
                     blank=False,
                     null=False
                 )
                 pulse_1 = models.FloatField(
                     verbose_name='Width (Pulse 1)',
                     blank=False,
                     null=False,
                     help_text='Introduce the value in %'
                 )
                 delay_1 = models.IntegerField(
                     verbose_name='Delay (Pulse 1)',
                     default=0,
                     blank=True,
                     null=False,
                     help_text='Introduce the value in µs'
                 )
                 type_1 = models.CharField(
                     verbose_name='Type (Pulse 1)',
                     default = 0,
                     max_length=3,
                     choices=TYPE_VALUE,
                     blank=False,
                     null=False
                 )
                 code_1 = models.IntegerField(
                     verbose_name="Code (Pulse 1)",
                     blank=True,
                     null=True,
                     help_text="Introduce the binary code"
                 )
                 repetitions_1 = models.IntegerField(
                     verbose_name='N° of repetitions (Pulse 1)',
                     default=1,
                     blank=True,
                     null=True
                 )
                 enable_2 = models.BooleanField(
                     verbose_name='Pulse 2',
                     blank=False,
                     null=False
                 )
                 pulse_2 = models.FloatField(
                     verbose_name='Width (Pulse 2)',
+                    default=1,
                     blank=True,
                     null=True,
                     help_text='Introduce the value in %'
                 )
                 delay_2 = models.IntegerField(
                     verbose_name='Delay (Pulse 2)',
                     default=0,
                     blank=True,
                     null=True,
                     help_text='Introduce the value in µs'
                 )
                 type_2 = models.CharField(
                     verbose_name='Type (Pulse 2)',
                     default = 0,
                     max_length=3,
                     choices=TYPE_VALUE,
                     blank=True,
                     null=False
                 )
                 code_2 = models.IntegerField(
                     verbose_name="Code (Pulse 2)",
                     blank=True,
                     null=True,
                     help_text="Introduce the binary code"
                 )
                 repetitions_2 = models.IntegerField(
                     verbose_name='N° of repetitions (Pulse 2)',
                     default=1,
                     blank=True,
                     null=True
                 )
                 class Meta:
                     db_table = 'usrp_tx_configurations'
                 def __str__(self):
                     return str(self.label)
                 def get_absolute_url_plot(self):
                     return reverse('url_plot_usrp_tx_pulses', args=[str(self.id)])
                 def request(self, cmd, method='get', **kwargs):
                     req = getattr(requests, method)(self.device.url(cmd), **kwargs)
                     payload = req.json()
                     return payload
                 def status_device(self):
                     try:
                         #self.device.status = 0
                         #payload = self.request('status')
                         payload = requests.get(self.device.url())
                         print(payload)
                         if payload:
                             self.device.status = 1
                         elif payload['status']=='disable':
                             self.device.status = 2
                         else:
                             self.device.status = 1
                             self.device.save()
                             self.message = 'USRP Tx 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 = 'USRP Tx status: {}'.format(str(e))
                         return False
                     self.device.save()
                     return True
                 def reset_device(self):
                     try:
                         payload = self.request('reset', 'post')
                         if payload['reset']=='ok':
                             self.message = 'USRP Tx restarted OK'
                             self.device.status = 2
                             self.device.save()
                         else:
                             self.message = 'USRP Tx restart fail'
                             self.device.status = 4
                             self.device.save()
                     except Exception as e:
                         self.message = 'USRP Tx reset: {}'.format(str(e))
                         return False
                     return True
                 def stop_device(self):
                     try:
-                        command = self.device.url() + "stop"
+                        command = self.device.url() + "stoptx"
                         r = requests.get(command)
                         if r:
                             self.device.status = 4
                             self.device.save()
                             self.message = 'USRP stopped'
                         else:
                             self.device.status = 4
                             self.device.save()
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         #self.message = 'USRP Tx stop: {}'.format(str(e))
                         self.message = "USRP Tx can't start, please check network/device connection or IP address/port configuration"
                         self.device.save()
                         return False
                     return True
                 def start_device(self):
                     print("Entró al start")
                     try:
                         usrp = USRPTXConfiguration.objects.get(pk=self)
                         usrp_daughterboard = usrp.get_daughterboard_display()
                         usrp_antenna = usrp.get_antenna_display()
                         print(usrp)
                         payload = {'ip_address': usrp.ip_address, 'daughterboard': usrp_daughterboard, 'antenna': usrp_antenna,
                         'frequency': usrp.frequency, 'sample_rate': usrp.samplerate, 'ipp': usrp.ipp, 'enable_1': usrp.enable_1,
                         'pulse_1': usrp.pulse_1, 'delay_1': usrp.delay_1, 'type_1': usrp.type_1, 'code_1': usrp.code_1,
                         'repetitions_1': usrp.repetitions_1, 'enable_2': usrp.enable_2, 'pulse_2': usrp.pulse_2, 'delay_2': usrp.delay_2,
                         'type_2': usrp.type_2, 'code_2': usrp.code_2, 'repetitions_2': usrp.repetitions_2}
                         print(payload)
                         r = requests.post(self.device.url("usrptx"), json=payload)
                         print(r.text)
                         #payload = self.request('usrp', 'post', data=json.dumps(data))
                         #print(payload)
                         if r:
                             self.device.status = 3
                             self.device.save()
                             self.message = 'USRP Tx configured and started'
                         else:
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         #self.message = 'USRP Tx start: {}'.format(str(e))
                         self.message = "USRP Tx can't start, please check network/device connection or IP address/port configuration"
                         self.device.save()
                         return False
                     return True
                 #def write_device(self, raw=False):
                     if not raw:
                         clock = RCClock.objects.get(rc_configuration=self)
                         print(clock)
                         if clock.mode:
                             data = {'default': clock.frequency}
                         else:
                             data = {'manual': [clock.multiplier, clock.divisor, clock.reference]}
                         payload = self.request('setfreq', 'post', data=json.dumps(data))
                         print(payload)
                         if payload['command'] != 'ok':
                             self.message = 'USRP Tx write: {}'.format(payload['command'])
                         else:
                             self.message = payload['programming']
                             if payload['programming'] == 'fail':
                                 self.message = 'USRP Tx write: error programming CGS chip'
                     values = []
                     for pulse, delay in zip(self.get_pulses(), self.get_delays()):
                         while delay>65536:
                             values.append((pulse, 65535))
                             delay -= 65536
                         values.append((pulse, delay-1))
                     data = bytearray()
                     #reset
                     data.extend((128, 0))
                     #disable
                     data.extend((129, 0))
                     #SW switch
                     if self.control_sw:
                         data.extend((130, 2))
                     else:
                         data.extend((130, 0))
                     #divider
                     data.extend((131, self.clock_divider-1))
                     #enable writing
                     data.extend((139, 62))
                     last = 0
                     for tup in values:
                         vals = pack('<HH', last^tup[0], tup[1])
                         last = tup[0]
                         data.extend((133, vals[1], 132, vals[0], 133, vals[3], 132, vals[2]))
                     #enable
                     data.extend((129, 1))
                     if raw:
                         return b64encode(data)
                     try:
                         payload = self.request('stop', 'post')
                         payload = self.request('reset', 'post')
                         #payload = self.request('divider', 'post', data={'divider': self.clock_divider-1})
                         #payload = self.request('write', 'post', data=b64encode(bytearray((139, 62))), timeout=20)
                         n = len(data)
                         x = 0
                         #while x < n:
                         payload = self.request('write', 'post', data=b64encode(data))
                         #    x += 1024
                         if payload['write']=='ok':
                             self.device.status = 3
                             self.device.save()
                             self.message = 'USRP Tx configured and started'
                         else:
                             self.device.status = 1
                             self.device.save()
                             self.message = 'USRP Tx write: {}'.format(payload['write'])
                             return False
                         #payload = self.request('start', 'post')
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         self.message = 'USRP Tx write: {}'.format(str(e))
                         self.device.save()
                         return False
                     return True
                 def get_absolute_url_import(self):
                     return reverse('url_import_usrp_tx_conf', args=[str(self.id)])

apps/usrp_tx/views.py +1 -1

             import json
             from django.contrib import messages
             from django.utils.safestring import mark_safe
             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from django.contrib.auth.decorators import login_required
             from apps.main.models import Experiment, Device
             from apps.main.views import sidebar
             from .models import USRPTXConfiguration
             from .forms import USRPTXConfigurationForm, USRPTXImportForm
             def conf(request, conf_id):
                 conf = get_object_or_404(USRPTXConfiguration, pk=conf_id)
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 kwargs['dev_conf_keys'] = ['ip_address', 'daughterboard', 'antenna', 'frequency', 'samplerate', 'ipp', 'enable_1', 'pulse_1',
                                             'delay_1', 'type_1', 'code_1', 'repetitions_1', 'enable_2', 'pulse_2', 'delay_2', 'type_2', 'code_2',
                                             'repetitions_2']
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'Detail'
                 kwargs['button'] = 'Edit Configuration'
                 conf.status_device()
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'usrp_tx_conf.html', kwargs)
             @login_required
             def conf_edit(request, conf_id):
                 print(conf_id)
                 conf = get_object_or_404(USRPTXConfiguration, pk=conf_id)
                 print(conf)
                 #print("fin de carga de params")
                 if request.method=='GET':
                     print("GET case")
                     form = USRPTXConfigurationForm(instance=conf)
                     print(form)
                 elif request.method=='POST':
                     print("ingreso a post conf edit")
                     line_data = {}
                     conf_data = {}
                     clock_data = {}
                     extras = []
                     print("Inicio impresion POST#####")
                     print(request.POST.items)
                     print("Fin impresion de POST items#####")
                     #classified post fields
                     for label,value in request.POST.items():
                         if label=='csrfmiddlewaretoken':
                             continue
                         if label.count('|')==0:
                             if label in ('mode', 'multiplier', 'divisor', 'reference'):
                                 clock_data[label] = value
                             else:
                                 conf_data[label] = value
                             continue
                         elif label.split('|')[0]!='-1':
                             extras.append(label)
                             continue
                         #print(label)
                         x, pk, name = label.split('|')
                         if name=='codes':
                             value = [s for s in value.split('\r\n') if s]
                         if pk in line_data:
                             line_data[pk][name] = value
                         else:
                             line_data[pk] = {name:value}
                         #print(line_data[pk])
                     #update conf
                     form = USRPTXConfigurationForm(conf_data, instance=conf)
                     #print(request.POST.items())
                     if form.is_valid():
                         form.save()
                         messages.success(request, 'USRP Tx configuration successfully updated')
                         return redirect(conf.get_absolute_url())
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 kwargs['form'] = form
                 kwargs['edit'] = True
                 kwargs['title'] = 'USRP Tx Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 print(kwargs)
                 print(form)
                 return render(request, 'usrp_tx_conf_edit.html', kwargs)
             def import_file(request, conf_id):
                 conf = get_object_or_404(USRPTXConfiguration, pk=conf_id)
                 if request.method=='POST':
                     form = USRPTXImportForm(request.POST, request.FILES)
                     if form.is_valid():
                         try:
                             data = conf.import_from_file(request.FILES['file_name'])
                             conf.dict_to_parms(data)
-                            conf.update_pulses()
+                            #conf.update_pulses()
                             messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name'])
                             return redirect(conf.get_absolute_url_edit())
                         except Exception as e:
                             messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], repr(e)))
                 else:
                     messages.warning(request, 'Your current configuration will be replaced')
                     form = USRPTXImportForm()
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'USRP Tx Configuration'
                 kwargs['suptitle'] = 'Import file'
                 kwargs['button'] = 'Upload'
                 kwargs['previous'] = conf.get_absolute_url()
                 return render(request, 'usrp_tx_import.html', kwargs)
             def conf_raw(request, conf_id):
                 conf = get_object_or_404(USRPTXConfiguration, pk=conf_id)
                 raw = conf.write_device(raw=True)
                 return HttpResponse(raw, content_type='application/json')

usrp-api/api_server.py +20 -12

             from __future__ import (absolute_import, division, print_function,
                                     unicode_literals)
             import numpy as np
             import os
             import subprocess
             from flask import Flask, request
             BARKER_DICT = {
                         "BARKER_2_SEQUENCE" : np.array([1, 1]),
                         "BARKER_3_SEQUENCE" : np.array([1, 1, 0]),
                         "BARKER_4_SEQUENCE" : np.array([1, 1, 0, 1]),
                         "BARKER_5_SEQUENCE" : np.array([1, 1, 1, 0, 1]),
                         "BARKER_7_SEQUENCE" : np.array([1, 1, 1, 0, 0, 0, 1, 0]),
                         "BARKER_11_SEQUENCE" : np.array([1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0]),
                         "BARKER_13_SEQUENCE" : np.array([1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1]),
                     }
             app = Flask(__name__)
             @app.route('/')
             def archivo():
                 stream = os.popen('echo Returned output')
                 output = stream.read()
                 print(output)
                 return 'Se ejecuto el comando'
             @app.route('/usrprx/', methods=['POST'])
             def usrprx_start():
                 request_data = request.get_json()
                 print(request_data)
                 ip_address = request_data['ip_address']
                 daughterboard = request_data['daughterboard']
                 antenna = request_data['antenna']
                 sample_rate = request_data['sample_rate']
                 frequency = request_data['frequency']
                 datadir = request_data['datadir']
                 clock_source = request_data['clock_source']
                 time_source = request_data['time_source']
                 clock_rate = request_data['clock_rate']
-                command_usrp_rx = subprocess.Popen(["python2.7", "/home/developer/HaystackOP/thor.py", "-m", ip_address, "-d", daughterboard,
+                #command_usrp_rx = subprocess.Popen(["python2.7", "/home/developer/HaystackOP/thor.py", "-m", ip_address, "-d", daughterboard,
-                                                    "-c ch0,ch1", "-y", antenna, "-r", str(sample_rate) + "e6", "-f", str(frequency) + "e6",
+                #                                    "-c ch0,ch1", "-y", antenna, "-r", str(sample_rate) + "e6", "-f", str(frequency) + "e6",
-                                                    "-datadir", datadir, "--clock_source", clock_source, "--time_source", time_source,
+                #                                    "-datadir", datadir, "--clock_source", clock_source, "--time_source", time_source,
-                                                    "--clock_rate", str(clock_rate) + "e6"], stdout=subprocess.PIPE)
+                #                                    "--clock_rate", str(clock_rate) + "e6"], stdout=subprocess.PIPE)
-                command_usrp_rx_out = command_usrp_rx.communicate()[0]
+                command_usrp_rx = subprocess.Popen(["python", "thor.py"], stdout=subprocess.PIPE)
-                print(command_usrp_rx_out)
+                #command_usrp_rx_out = command_usrp_rx.communicate()[0]
+                #print(command_usrp_rx_out)
                 return "USRP Rx configured"
+            @app.route('/stoprx/', methods=['GET'])
+            def usrprx_stop():
+                #stop_usrp_rx = subprocess.Popen(["pkill", "-f", "thor.py"], stdout=subprocess.PIPE)
+                return 'USRP stopped'
             @app.route('/usrptx/', methods=['POST'])
             def usrptx_start():
                 request_data = request.get_json()
                 print(request_data)
                 ip_address = request_data['ip_address']
                 daughterboard = request_data['daughterboard']
                 antenna = request_data['antenna']
                 frequency = request_data['frequency']
                 sample_rate = request_data['sample_rate']
                 ipp = request_data['ipp']
                 enable_1 = request_data['enable_1']
                 pulse_1 = request_data['pulse_1']
                 delay_1 = request_data['delay_1']
                 type_1 = int(request_data['type_1'])
                 code_1 = request_data['code_1']
                 repetitions_1 = request_data['repetitions_1']
                 enable_2 = request_data['enable_2']
                 pulse_2 = request_data['pulse_2']
                 delay_2 = request_data['delay_2']
                 type_2 = int(request_data['type_2'])
                 code_2 = request_data['code_2']
                 repetitions_2 = request_data['repetitions_2']
                 if enable_1 == True and enable_2 == False:
                     clen = int((ipp * 2 / 300000) * 1000000)
                     if type_1 == 0:
                         z   = np.zeros(clen)
                         o   = 1*np.ones(clen)
                         cod = np.zeros([clen])
                         N   = z.shape[0]
                         for ri in np.arange(N):
                             if ri < (pulse_1/100.0)*clen:
                                 cod[ri]=o[ri]
                             else:
                                 cod[ri]=0
                         cod = np.roll(cod, delay_1)
                         cod = np.tile(cod, repetitions_1)
                     if type_1 == 1:
                         code_1 = np.array([int(x) for x in str(code_1)])
                         units_1 = ((pulse_1/100.0)*clen)/len(code_1)
                         seq_1 = np.repeat(code_1, units_1)
                         cod = np.concatenate([seq_1, np.zeros(clen-len(seq_1))])
                         cod = np.roll(cod, delay_1)
                         cod = np.tile(cod, repetitions_1)
                     if type_1 > 1:
                         units_1 = ((pulse_1/100.0)*clen)/type_1
                         seq_1 = np.repeat(BARKER_DICT["BARKER_" + str(type_1) + "_SEQUENCE"], units_1)
                         cod = np.concatenate([seq_1, np.zeros(clen-len(seq_1))])
                         cod = np.roll(cod, delay_1)
                         cod = np.tile(cod, repetitions_1)
                 if enable_1 == True and enable_2 == True:
                     clen = int((ipp * 2 / 300000) * 1000000)
                     if type_1 == 0:
                         z = np.zeros(clen)
                         o = 1*np.ones(clen)
                         cod_1 = np.zeros([clen])
                         N   = z.shape[0]
                         for ri in np.arange(N):
                             if ri < (pulse_1/100.0)*clen:
                                 cod_1[ri]=o[ri]
                             else:
                                 cod_1[ri]=0
                         cod_1 = np.roll(cod_1, delay_1)
                         cod_1 = np.tile(cod_1, repetitions_1)
                     if type_1 == 1:
                         code_1 = np.array([int(x) for x in str(code_1)])
                         units_1 = ((pulse_1/100.0)*clen)/len(code_1)
                         seq_1 = np.repeat(code_1, units_1)
                         cod_1 = np.concatenate([seq_1, np.zeros(clen-len(seq_1))])
                         cod_1 = np.roll(cod_1, delay_1)
                         cod_1 = np.tile(cod_1, repetitions_1)
                     if type_1 > 1:
                         units_1 = ((pulse_1/100.0)*clen)/type_1
                         seq_1 = np.repeat(BARKER_DICT["BARKER_" + str(type_1) + "_SEQUENCE"], units_1)
                         cod_1 = np.concatenate([seq_1, np.zeros(clen-len(seq_1))])
                         cod_1 = np.roll(cod_1, delay_1)
                         cod_1 = np.tile(cod_1, repetitions_1)
                     if type_2 == 0:
                         z = np.zeros(clen)
                         o = 1*np.ones(clen)
                         cod_2 = np.zeros([clen])
                         N   = z.shape[0]
                         for ri in np.arange(N):
                             if ri < (pulse_2/100.0)*clen:
                                 cod_2[ri]=o[ri]
                             else:
                                 cod_2[ri]=0
                         cod_2 = np.roll(cod_2, delay_2)
                         cod_2 = np.tile(cod_2, repetitions_2)
                     if type_2 == 1:
                         code_2 = np.array([int(x) for x in str(code_2)])
                         print(code_2)
                         units_2 = ((pulse_2/100.0)*clen)/len(code_2)
                         seq_2 = np.repeat(code_2, units_2)
                         cod_2 = np.concatenate([seq_2, np.zeros(clen-len(seq_2))])
                         cod_2 = np.roll(cod_2, delay_2)
                         cod_2 = np.tile(cod_2, repetitions_2)
                     if type_2 > 1:
                         units_2 = ((pulse_2/100.0)*clen)/type_2
                         seq_2 = np.repeat(BARKER_DICT["BARKER_" + str(type_2) + "_SEQUENCE"], units_2)
                         cod_2 = np.concatenate([seq_2, np.zeros(clen-len(seq_2))])
                         cod_2 = np.roll(cod_2, delay_2)
                         cod_2 = np.tile(cod_2, repetitions_2)
                     print(cod_1)
                     print(len(cod_1))
                     print(cod_2)
                     print(len(cod_2))
                     cod = np.concatenate([cod_1, cod_2])
                 print(cod)
                 name = 'code.bin'
                 print(name)
                 cod.tofile(name)
-                command_usrp_tx = subprocess.Popen(["python", "tx.py", "-m", ip_address, "-d", daughterboard, "-y", antenna, "-f", str(frequency) + "e6",
+                #command_usrp_tx = subprocess.Popen(["python", "tx.py", "-m", ip_address, "-d", daughterboard, "-y", antenna, "-f", str(frequency) + "e6",
-                                                    "-r", str(sample_rate) + "e6", "code.bin"], stdout=subprocess.PIPE)
+                #                                    "-r", str(sample_rate) + "e6", "code.bin"], stdout=subprocess.PIPE)
-                command_usrp_tx_out = command_usrp_tx.communicate()[0]
+                command_usrp_tx = subprocess.Popen(["python", "tx.py"], stdout=subprocess.PIPE)
-                print(command_usrp_tx_out)
+                #command_usrp_tx_out = command_usrp_tx.communicate()[1]
+                #print(command_usrp_tx_out)
                 return "USRP Tx configured"
-            @app.route('/stop/', methods=['GET'])
+            @app.route('/stoptx/', methods=['GET'])
-            def usrp_stop():
+            def usrptx_stop():
+                #stop_usrp_tx = subprocess.Popen(["pkill", "-f", "tx.py"], stdout=subprocess.PIPE)
                 return 'USRP stopped'
             if __name__ =='__main__':
                 app.run(debug=True, port=4000)

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