radarsys_met Commit - r311:6467cbbb1e89

Fix mix experiment and scheduler

jespinoza -

r311:6467cbbb1e89

parent child

Context file:

r311:6467cbbb1e89

Collapse all files

.env +1 -1

             REDIS_HOST=radarsys-redis
             REDIS_PORT=6379
             POSTGRES_DB_NAME=radarsys
             POSTGRES_PORT_5432_TCP_ADDR=radarsys-postgres
             POSTGRES_PORT_5432_TCP_PORT=5432
             POSTGRES_USER=docker
             POSTGRES_PASSWORD=docker
             PGDATA=/var/lib/postgresql/data
             LC_ALL=C.UTF-8
             TZ=America/Lima
-            DOCKER_DATA=/Volumes/dockers/radarsys/
+            DOCKER_DATA=/data/dockers/radarsys/
             LOCAL_IP=192.168.1.128

.gitignore +1 0

             migrations/
+            *.sqlite
             .vscode/
             *.pyc
             .env

apps/jars/models.py +1 -9

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

apps/main/forms.py +1 -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'),
                             )
             DDS_FILE_FORMAT = (
                             ('json', 'json'),
                             ('text', 'dds')
                             )
             RC_FILE_FORMAT = (
                             ('json', 'json'),
                             ('text', 'racp'),
                             ('binary', 'dat'),
                             )
             JARS_FILE_FORMAT = (
                             ('json', 'json'),
                             ('racp', 'racp'),
                             ('text', 'jars'),
                             )
             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):
                     input_html = super(DatepickerWidget, self).render(name, value, attrs)
                     html = '<div class="input-group date">'+input_html+'<span class="input-group-addon"><i class="glyphicon glyphicon-calendar"></i></span></div>'
                     return mark_safe(html)
             class DateRangepickerWidget(forms.widgets.TextInput):
                 def render(self, name, value, attrs=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="glyphicon glyphicon-calendar"></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="glyphicon glyphicon-calendar"></i></span>
                     </div>'''.format(start, end)
                     return mark_safe(html)
             class TimepickerWidget(forms.widgets.TextInput):
                 def render(self, name, value, attrs=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="glyphicon glyphicon-time"></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 = ['']
             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):
                     exp = super(ExperimentForm, self).save()
                     exp.name = exp.name.replace(' ', '')
                     exp.save()
                     return exp
                 class Meta:
                     model = Experiment
-                    exclude = ['status']
+                    exclude = ['task', 'status']
             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']
             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
                     if device_type == 'dds':
                         self.fields['format'].choices = DDS_FILE_FORMAT
                     if device_type == 'rc':
                         self.fields['format'].choices = RC_FILE_FORMAT
                     if device_type == 'jars':
                         self.fields['format'].choices = JARS_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'):
                             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 +17 -15

             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.core.urlresolvers import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from django.shortcuts import get_object_or_404
             from apps.main.utils import Params
             from apps.rc.utils import RCFile
             from apps.jars.utils import RacpFile
             from devices.dds import api as dds_api
             from devices.dds import data as dds_data
             DEV_PORTS = {
                             'rc'    : 2000,
                             'dds'   : 2000,
                             'jars'  : 2000,
                             'usrp'  : 2000,
                             'cgs'   : 8080,
                             'abs'   : 8080
                         }
             RADAR_STATES = (
                              (0, 'No connected'),
                              (1, 'Connected'),
                              (2, 'Configured'),
                              (3, 'Running'),
                              (4, 'Scheduled'),
                          )
             EXPERIMENT_TYPE = (
                                (0, 'RAW_DATA'),
                                (1, 'PDATA'),
                                )
             DECODE_TYPE = (
                          (0, 'None'),
                          (1, 'TimeDomain'),
                          (2, 'FreqDomain'),
                          (3, 'InvFreqDomain'),
                          )
             DEV_STATES = (
                              (0, 'No connected'),
                              (1, 'Connected'),
                              (2, 'Configured'),
                              (3, 'Running'),
                              (4, 'Unknown'),
                          )
             DEV_TYPES = (
                             ('', 'Select a device type'),
                             ('rc', 'Radar Controller'),
                             ('dds', 'Direct Digital Synthesizer'),
                             ('jars', 'Jicamarca Radar Acquisition System'),
                             ('usrp', 'Universal Software Radio Peripheral'),
                             ('cgs', 'Clock Generator System'),
                             ('abs', 'Automatic Beam Switching'),
                         )
             EXP_STATES = (
                              (0,'Error'),                 #RED
                              (1,'Configured'),            #BLUE
                              (2,'Running'),               #GREEN
                              (3,'Scheduled'),             #YELLOW
                              (4,'Not Configured'),        #WHITE
                          )
             CONF_TYPES = (
                              (0, 'Active'),
                              (1, 'Historical'),
                          )
             class Location(models.Model):
                 name = models.CharField(max_length = 30)
                 description = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'db_location'
                 def __str__(self):
                     return u'%s' % self.name
                 def get_absolute_url(self):
                     return reverse('url_location', args=[str(self.id)])
             class DeviceType(models.Model):
                 name = models.CharField(max_length = 10, choices = DEV_TYPES, default = 'rc')
                 sequence = models.PositiveSmallIntegerField(default=1000)
                 description = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'db_device_types'
                 def __str__(self):
                     return u'%s' % self.get_name_display()
             class Device(models.Model):
                 device_type = models.ForeignKey(DeviceType, on_delete=models.CASCADE)
                 location = models.ForeignKey(Location, on_delete=models.CASCADE)
                 name = models.CharField(max_length=40, default='')
                 ip_address = models.GenericIPAddressField(protocol='IPv4', default='0.0.0.0')
                 port_address = models.PositiveSmallIntegerField(default=2000)
                 description = models.TextField(blank=True, null=True)
                 status = models.PositiveSmallIntegerField(default=0, choices=DEV_STATES)
                 class Meta:
                     db_table = 'db_devices'
                 def __str__(self):
                     return u'[{}]: {}'.format(self.device_type.name.upper(),
                                                 self.name)
                 def get_status(self):
                     return self.status
                 @property
                 def status_color(self):
                     color = 'muted'
                     if self.status == 0:
                         color = "danger"
                     elif self.status == 1:
                         color = "warning"
                     elif self.status == 2:
                         color = "info"
                     elif self.status == 3:
                         color = "success"
                     return color
                 def url(self, path=None):
                     if path:
                         return 'http://{}:{}/{}/'.format(self.ip_address, self.port_address, path)
                     else:
                         return 'http://{}:{}/'.format(self.ip_address, self.port_address)
                 def get_absolute_url(self):
                     return reverse('url_device', args=[str(self.id)])
                 def change_ip(self, ip_address, mask, gateway, dns, **kwargs):
                     if self.device_type.name=='dds':
                         try:
                             answer = dds_api.change_ip(ip = self.ip_address,
                                                        port = self.port_address,
                                                        new_ip = ip_address,
                                                        mask = mask,
                                                        gateway = gateway)
                             if answer[0]=='1':
                                 self.message = '25|DDS - {}'.format(answer)
                                 self.ip_address = ip_address
                                 self.save()
                             else:
                                 self.message = '30|DDS - {}'.format(answer)
                                 return False
                         except Exception as e:
                             self.message = '40|{}'.format(str(e))
                             return False
                     elif self.device_type.name=='rc':
                         headers = {'content-type': "application/json",
                                    'cache-control': "no-cache"}
                         ip = [int(x) for x in ip_address.split('.')]
                         dns = [int(x) for x in dns.split('.')]
                         gateway = [int(x) for x in gateway.split('.')]
                         subnet = [int(x) for x in mask.split('.')]
                         payload = {
                             "ip": ip,
                             "dns": dns,
                             "gateway": gateway,
                             "subnet": subnet
                             }
                         req = requests.post(self.url('changeip'), data=json.dumps(payload), headers=headers)
                         try:
                             answer = req.json()
                             if answer['changeip']=='ok':
                                 self.message = '25|IP succesfully changed'
                                 self.ip_address = ip_address
                                 self.save()
                             else:
                                 self.message = '30|An error ocuur when changing IP'
                         except Exception as e:
                             self.message = '40|{}'.format(str(e))
                     else:
                         self.message = 'Not implemented'
                         return False
                     return True
             class Campaign(models.Model):
                 template = models.BooleanField(default=False)
                 name = models.CharField(max_length=60, unique=True)
                 start_date = models.DateTimeField(blank=True, null=True)
                 end_date = models.DateTimeField(blank=True, null=True)
                 tags = models.CharField(max_length=40)
                 description = models.TextField(blank=True, null=True)
                 experiments = models.ManyToManyField('Experiment', blank=True)
                 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 = Params({})
                     params.add(self.jsonify(), 'campaigns')
                     for exp in Experiment.objects.filter(campaign = self):
                         params.add(exp.jsonify(), 'experiments')
                         configurations = Configuration.objects.filter(experiment=exp, type=0)
                         for conf in configurations:
                             params.add(conf.jsonify(), 'configurations')
                             if conf.device.device_type.name=='rc':
                                 for line in conf.get_lines():
                                     params.add(line.jsonify(), 'lines')
                     return params.data
                 def dict_to_parms(self, parms, CONF_MODELS):
                     experiments = Experiment.objects.filter(campaign = self)
                     if experiments:
                         for experiment in experiments:
                             experiment.delete()
                     for id_exp in parms['experiments']['allIds']:
                         exp_parms = parms['experiments']['byId'][id_exp]
                         dum = (datetime.now() - datetime(1970, 1, 1)).total_seconds()
                         exp = Experiment(name='{}'.format(dum))
                         exp.save()
                         exp.dict_to_parms(parms, CONF_MODELS, id_exp=id_exp)
                         self.experiments.add(exp)
                     camp_parms = parms['campaigns']['byId'][parms['campaigns']['allIds'][0]]
                     self.name = '{}-{}'.format(camp_parms['name'], datetime.now().strftime('%y%m%d'))
                     self.start_date = camp_parms['start_date']
                     self.end_date = camp_parms['end_date']
                     self.tags = camp_parms['tags']
                     self.save()
                     return self
                 def get_experiments_by_radar(self, radar=None):
                     ret = []
                     if radar:
                         locations = Location.objects.filter(pk=radar)
                     else:
                         locations = set([e.location for e in self.experiments.all()])
                     for loc in locations:
                         dum = {}
                         dum['name'] = loc.name
                         dum['id'] = loc.pk
                         dum['experiments'] = [e for e in self.experiments.all() if e.location==loc]
                         ret.append(dum)
                     return ret
                 def get_absolute_url(self):
                     return reverse('url_campaign', args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_campaign', args=[str(self.id)])
                 def get_absolute_url_export(self):
                     return reverse('url_export_campaign', args=[str(self.id)])
                 def get_absolute_url_import(self):
                     return reverse('url_import_campaign', args=[str(self.id)])
             class RunningExperiment(models.Model):
                 radar = models.OneToOneField('Location', on_delete=models.CASCADE)
                 running_experiment = models.ManyToManyField('Experiment', blank = True)
                 status = models.PositiveSmallIntegerField(default=0, choices=RADAR_STATES)
             class Experiment(models.Model):
                 template = models.BooleanField(default=False)
                 name = models.CharField(max_length=40, default='', unique=True)
                 location = models.ForeignKey('Location', null=True, blank=True, on_delete=models.CASCADE)
                 freq = models.FloatField(verbose_name='Operating Freq. (MHz)', validators=[MinValueValidator(1), MaxValueValidator(10000)], default=49.9200)
                 start_time = models.TimeField(default='00:00:00')
                 end_time = models.TimeField(default='23:59:59')
+                task = models.CharField(max_length=36, default='', blank=True, null=True)
                 status = models.PositiveSmallIntegerField(default=4, choices=EXP_STATES)
                 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())
+                    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
                     ABS-CGS-DDS-RC-JARS
                     '''
                     result = 2
+                    confs = []
-                    confs = 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')
+                    rc_mix = [conf for conf in allconfs if conf.device.device_type.name=='rc' and conf.mix]
+                    if rc_mix:
+                        for conf in allconfs:
+                            if conf.device.device_type.name == 'rc' and  not conf.mix:
+                                continue
+                            confs.append(conf)
+                    else:
+                        confs = allconfs
                     #Only Configured Devices.
                     for conf in confs:
                         if conf.device.status in (0, 4):
                             result = 0
                             return result
                     for conf in confs:
                         conf.stop_device()
-                        #conf.write_device()
+                        conf.write_device()
                         conf.start_device()
-                        print conf.device.name+' has started...'
+                        time.sleep(1)
                     return result
                 def stop(self):
                     '''
                     Stop experiments's devices
                     DDS-JARS-RC-CGS-ABS
                     '''
                     result = 1
                     confs = Configuration.objects.filter(experiment=self, type = 0).order_by('device__device_type__sequence')
                     confs=confs.exclude(device__device_type__name='cgs')
                     for conf in confs:
                         if conf.device.status in (0, 4):
                             result = 0
                             continue
                         conf.stop_device()
-                        print conf.device.name+' has stopped...'
                     return result
                 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 = "info"
                     elif self.status == 2:
                         color = "success"
                     elif self.status == 3:
                         color = "warning"
                     return color
                 def parms_to_dict(self):
-                    params = Params()
+                    params = Params({})
                     params.add(self.jsonify(), 'experiments')
                     configurations = Configuration.objects.filter(experiment=self, type=0)
                     for conf in configurations:
                         params.add(conf.jsonify(), 'configurations')
                         if conf.device.device_type.name=='rc':
                             for line in conf.get_lines():
                                 params.add(line.jsonify(), 'lines')
                     return params.data
                 def dict_to_parms(self, parms, CONF_MODELS, id_exp=None):
                     configurations = Configuration.objects.filter(experiment=self)
                     if id_exp is not None:
                         exp_parms = parms['experiments']['byId'][id_exp]
                     else:
                         exp_parms = parms['experiments']['byId'][parms['experiments']['allIds'][0]]
                     if configurations:
                         for configuration in configurations:
                             configuration.delete()
                     for id_conf in exp_parms['configurations']:
                         conf_parms = parms['configurations']['byId'][id_conf]
                         device = Device.objects.filter(device_type__name=conf_parms['device_type'])[0]
                         model = CONF_MODELS[conf_parms['device_type']]
                         conf = model(
                             experiment = self,
                             device = device,
                             )
                         conf.dict_to_parms(parms, id=id_conf)
                     location, created = Location.objects.get_or_create(name=exp_parms['location'])
                     self.name = '{}-{}'.format(exp_parms['name'], datetime.now().strftime('%y%m%d'))
                     self.location = location
                     self.start_time = exp_parms['start_time']
                     self.end_time = exp_parms['end_time']
                     self.save()
                     return self
                 def get_absolute_url(self):
                     return reverse('url_experiment', args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_experiment', args=[str(self.id)])
                 def get_absolute_url_import(self):
                     return reverse('url_import_experiment', args=[str(self.id)])
                 def get_absolute_url_export(self):
                     return reverse('url_export_experiment', args=[str(self.id)])
                 def get_absolute_url_start(self):
                     return reverse('url_start_experiment', args=[str(self.id)])
                 def get_absolute_url_stop(self):
                     return reverse('url_stop_experiment', args=[str(self.id)])
             class Configuration(PolymorphicModel):
                 template = models.BooleanField(default=False)
                 name = models.CharField(verbose_name="Configuration Name", max_length=40, default='')
                 experiment = models.ForeignKey('Experiment', verbose_name='Experiment', null=True, blank=True, on_delete=models.CASCADE)
                 device = models.ForeignKey('Device', verbose_name='Device', null=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='{}')
                 message = ""
                 class Meta:
                     db_table = 'db_configurations'
                 def __str__(self):
                     device = '{}:'.format(self.device.device_type.name.upper())
                     if 'mix' in [f.name for f in self._meta.get_fields()]:
                         if self.mix:
                             device = '{} MIXED:'.format(self.device.device_type.name.upper())
                     if self.template:
                         return u'{} {} (template)'.format(device, self.name)
                     else:
                         return u'{} {}'.format(device, self.name)
                 def jsonify(self):
                     data = {}
                     ignored = ('type', 'polymorphic_ctype', 'configuration_ptr',
                                'created_date', 'programmed_date', 'template', 'device',
                                'experiment')
                     for field in self._meta.fields:
                         if field.name in ignored:
                             continue
                         data[field.name] = field.value_from_object(self)
                     data['device_type'] = self.device.device_type.name
                     if self.device.device_type.name == 'rc':
                         data['lines'] = ['{}'.format(line.pk) for line in self.get_lines()]
                         data['delays'] = self.get_delays()
                         data['pulses'] = self.get_pulses()
                     elif self.device.device_type.name == 'jars':
                         data['decode_type'] = DECODE_TYPE[self.decode_data][1]
                     elif self.device.device_type.name == 'dds':
                         data['frequencyA_Mhz'] = float(data['frequencyA_Mhz'])
                         data['frequencyB_Mhz'] = float(data['frequencyB_Mhz'])
                         data['phaseA'] = dds_data.phase_to_binary(data['phaseA_degrees'])
                         data['phaseB'] = dds_data.phase_to_binary(data['phaseB_degrees'])
                     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 = Params({})
                     params.add(self.jsonify(), 'configurations')
                     if self.device.device_type.name=='rc':
                         for line in self.get_lines():
                             params.add(line.jsonify(), 'lines')
                     return params.data
                 def parms_to_text(self):
                     raise NotImplementedError("This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper())
                 def parms_to_binary(self):
                     raise NotImplementedError("This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper())
                 def dict_to_parms(self, parameters, id=None):
                     params = Params(parameters)
                     if id:
                         data = params.get_conf(id_conf=id)
                     else:
                         data = params.get_conf(dtype=self.device.device_type.name)
                     if data['device_type']=='rc':
                         self.clean_lines()
                         lines = data.pop('lines', None)
                         for line_id in lines:
                             pass
                     for key, value in data.items():
                         if key not in ('id', 'device_type'):
                             setattr(self, key, value)
                     self.save()
                 def export_to_file(self, format="json"):
                     content_type = ''
                     if format == 'racp':
                         content_type = 'text/plain'
                         filename = '%s_%s.%s' %(self.device.device_type.name, self.name, 'racp')
                         content = self.parms_to_text(file_format = 'racp')
                     if format == 'text':
                         content_type = 'text/plain'
                         filename = '%s_%s.%s' %(self.device.device_type.name, self.name, self.device.device_type.name)
                         content = self.parms_to_text()
                     if format == 'binary':
                         content_type = 'application/octet-stream'
                         filename = '%s_%s.bin' %(self.device.device_type.name, self.name)
                         content = self.parms_to_binary()
                     if not content_type:
                         content_type = 'application/json'
                         filename = '%s_%s.json' %(self.device.device_type.name, self.name)
                         content = json.dumps(self.parms_to_dict(), indent=2)
                     fields = {'content_type':content_type,
                               'filename':filename,
                               'content':content
                               }
                     return fields
                 def import_from_file(self, fp):
                     parms = {}
                     path, ext = os.path.splitext(fp.name)
                     if ext == '.json':
                         parms = json.load(fp)
                     if ext == '.dds':
                         lines = fp.readlines()
                         parms = dds_data.text_to_dict(lines)
                     if ext == '.racp':
                         if self.device.device_type.name == 'jars':
                             parms = RacpFile(fp).to_dict()
                             parms['filter_parms'] = json.loads(self.filter_parms)
                             return parms
                         parms = RCFile(fp).to_dict()
                     return parms
                 def status_device(self):
                     self.message = 'Function not implemented'
                     return False
                 def stop_device(self):
                     self.message = 'Function not implemented'
                     return False
                 def start_device(self):
                     self.message = 'Function not implemented'
                     return False
                 def write_device(self, parms):
                     self.message = 'Function not implemented'
                     return False
                 def read_device(self):
                     self.message = 'Function not implemented'
                     return False
                 def get_absolute_url(self):
                     return reverse('url_%s_conf' % self.device.device_type.name, args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_%s_conf' % self.device.device_type.name, args=[str(self.id)])
                 def get_absolute_url_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/tasks.py +36 -13

             from __future__ import absolute_import
+            from radarsys.celery import app
             from celery import task
             from datetime import timedelta, datetime
             from .models import Experiment
             @task
             def task_start(id_exp):
                 exp = Experiment.objects.get(pk=id_exp)
+                status = exp.status
-                return exp.start()
+                if exp.status == 2:
+                    print('Experiment {} already running start task not executed'.format(exp))
+                    return 2
+                if status == 3:
+                    now = datetime.now()
+                    start = datetime.combine(now.date(), exp.start_time)
+                    end = datetime.combine(now.date(), exp.end_time)
+                    if end < start:
+                        end += timedelta(1)
+                    try:
+                        print('Starting exp:{}'.format(exp))
+                        exp.status = exp.start()
+                    except:
+                        print('Error')
+                        exp.status = 0
+                    if exp.status == 2:
+                        task = task_stop.apply_async((id_exp,), eta=end+timedelta(hours=5))
+                        exp.task = task.id
+                exp.save()
+                return exp.status
             @task
             def task_stop(id_exp):
                 exp = Experiment.objects.get(pk=id_exp)
+                if exp.status == 2:
+                    try:
+                        print('Stopping exp:{}'.format(exp))
+                        exp.status = exp.stop()
+                    except:
+                        print('Error')
+                        exp.status = 0
-                return exp.stop()
+                now = datetime.now()
+                start = datetime.combine(now.date()+timedelta(1), exp.start_time)
-            def kill_tasks():
+                task = task_start.apply_async((id_exp, ), eta=start+timedelta(hours=5))
+                exp.task = task.id
-                i = task.control.inspect()
+                exp.status = 3
-                tasks = i.scheduled()
+                exp.save()
-                print tasks
+                return exp.status
-                #if tasks:
-                #    print dir(tasks[0])
             #Task to get status
             @task
             def task_status(id_exp):
                 exp = Experiment.objects.get(pk=id_exp)
                 if exp.status==2:
                     run_every = timedelta(minutes=1)
                     now = datetime.utcnow()
                     date = now + run_every
                     task_status.apply_async((id_exp,), eta=date)
                     print "Monitoring..."
                     exp.get_status()
                     return exp.status
                 else:
                     return exp.status

apps/main/templates/experiment.html +4 0

             {% extends "base.html" %}
             {% load bootstrap3 %}
             {% load static %}
             {% load main_tags %}
             {% block extra-head %}
             <link href="{% static 'css/bootstrap-datetimepicker.min.css' %}" media="screen" rel="stylesheet">
             {% endblock %}
             {% block exp-active %}active{% endblock %}
             {% block content-title %}{{title}}{% endblock %}
             {% block content-suptitle %}{{suptitle}}{% endblock %}
             {% block content %}
             {% block menu-actions %}
             <span class=" dropdown pull-right">
               <a href="#" class="dropdown-toggle" data-toggle="dropdown"><span class="glyphicon glyphicon-menu-hamburger gi-2x" aria-hidden="true"></span></a>
               <ul class="dropdown-menu" role="menu">
                 <li><a href="{% url 'url_edit_experiment' experiment.id %}"><span class="glyphicon glyphicon-pencil" aria-hidden="true"></span> Edit</a></li>
                 <li><a href="{% url 'url_delete_experiment' experiment.id %}"><span class="glyphicon glyphicon-remove" aria-hidden="true"></span> Delete</a></li>
                 <li><a href="{{ experiment.get_absolute_url_import }}"><span class="glyphicon glyphicon-import" aria-hidden="true"></span> Import </a></li>
                 <li><a href="{{ experiment.get_absolute_url_export }}"><span class="glyphicon glyphicon-export" aria-hidden="true"></span> Export </a></li>
                 <li><a>----------------</a></li>
                 <li><a href="{{ experiment.get_absolute_url_start}}"><span class="glyphicon glyphicon-play" aria-hidden="true"></span> Start</a></li>
                 <li><a href="{{ experiment.get_absolute_url_stop }}"><span class="glyphicon glyphicon-stop" aria-hidden="true"></span> Stop</a></li>
                 <li><a href="{% url 'url_mix_experiment' experiment.id %}"><span class="glyphicon glyphicon-random" aria-hidden="true"></span> Mix RC Configurations </a></li>
                 <li><a href="{% url 'url_add_dev_conf' experiment.id %}"><span class="glyphicon glyphicon-plus-sign" aria-hidden="true"></span> Add Configuration</a></li>
                 <li><a href="{% url 'url_sum_experiment' experiment.id %}"><span class="glyphicon glyphicon-list-alt" aria-hidden="true"></span> Summary</a></li>
               </ul>
             </span>
             {% endblock %}
             <table class="table table-bordered">
             {% for key in experiment_keys %}
             	{% if key == 'freq' %}
             	<tr><th>Operating Freq. (MHz)</th><td>{{experiment|attr:key}}</td></tr>
             	{% else %}
             	<tr><th>{{key|title}}</th><td>{{experiment|attr:key}}</td></tr>
             	{% endif %}
             {% endfor %}
             </table>
             <br>
             <div class="panel-group" id="accordion" role="tablist" aria-multiselectable="true">
               <div class="panel panel-default bootcards-summary">
                 <div class="panel-heading" role="tab">
                   <h4 class="panel-title">
                       Devices
                   </h4>
                 </div>
                   <div class="panel-body">
             		{% for item in configurations %}
             		<div class="col-xs-6 col-sm-4" style="padding-top:5px;padding-bottom:5px">
                          <a class="bootcards-summary-item" href="{{item.get_absolute_url}}"><br>
                            {% if item.device.device_type.name == 'cgs' %}
                             <i class="fa fa-2x fa-clock-o"></i>
                            {% elif item.device.device_type.name == 'rc' %}
                             <i class="fa fa-2x fa-microchip"></i>
                            {% elif item.device.device_type.name == 'abs' %}
                             <i class="fa fa-2x fa-podcast"></i>
                            {% elif item.device.device_type.name == 'jars' %}
                             <i class="fa fa-2x fa-desktop"></i>
                            {% elif item.device.device_type.name == 'dds' %}
                             <i class="fa fa-2x fa-bar-chart"></i>
                            {% else %}
                             <i class="fa fa-3x fa-puzzle-piece"></i>
                            {%endif%}
                                <h4>{{item}}<br><small>{{item.device.ip_address}}</small>
+            		       {%if experiment.status == 3 %}
+            		       <span class="label label-info">Configured</span>
+            		       {%else%}
             		       <span class="label label-{{item.device.status_color}}">{{item.device.get_status_display}}</span>
+                                   {%endif%}
             		   </h4>
                          </a>
                     </div>
             		{% endfor %}
                   </div>
               </div>
             </div>
             {% endblock %}
             {% block sidebar%}
                {% include "sidebar_devices.html" %}
             {% endblock %}
             {% block extra-js%}
             <script type="text/javascript">
               $(".clickable-row").click(function() {
                 document.location = $(this).data("href");
               });
               $("#bt_edit").click(function() {
             	    document.location = "{% url 'url_edit_experiment' experiment.id%}";
             	  });
               $("#bt_add_conf").click(function() {
                 document.location = "{% url 'url_add_dev_conf' experiment.id %}";
               });
             </script>
             {% endblock %}

apps/main/templates/operation.html +1 -3

             {% extends "base.html" %}
             {% load bootstrap3 %}
             {% load static %}
             {% load main_tags %}
             {% block extra-head %}
             <link href="{% static 'css/bootstrap-datetimepicker.min.css' %}" media="screen" rel="stylesheet">
             {% endblock %}
             {% block operation-active %}active{% endblock %}
             {% block content-title %}{{title}}{% endblock %}
             {% block content %}
             <div class="clearfix"></div>
             {% if campaigns %}
             <h3>Current Campaigns</h3>
             <br>
             <div class="bootcards-list">
               <div class="panel panel-default">
                 <div class="list-group">
                 {% for item in campaigns %}
                 <a class="list-group-item" href="{{item.pk}}">
                     <div class="row">
                       <div class="col-sm-6">
                       <i class="fa fa-3x fa-calendar pull-left"></i>
             	  <h4 class="list-group-item-heading">{{item.name}}</h4>
             	  <p class="list-group-item-text">Radar: {% for radar in item.get_experiments_by_radar %}{{radar.name}},{% endfor %}</p>
             	  </div>
             	  <div class="col-sm-6">
             	  <p class="list-group-item-text">From: {{item.start_date}}</p>
             	  <p class="list-group-item-text">To: {{item.end_date}}</p>
             	  </div>
             	</div>
                 </a>
                 {% endfor %}
               </div>
               </div>
             </div>
             {% endif %}
             {% if campaign %}
             <h3>Systems</h3>
             <br>
             <div class="panel-group" id="accordion" role="tablist" aria-multiselectable="true" >
             	  {% for location in locations %}
             	  <div class="panel panel-default bootcards-summary">
             	    <div class="panel-heading" role="tab">
             	      <h3 class="panel-title">
             	          {{location.name}} [{{campaign.start_date|date:"Y/m/d"}} - {{campaign.end_date|date:"Y/m/d"}}]
             	        <button type="button" name="bt_play" class="btn btn-primary pull-right btn-xs" data-url="{% url 'url_radar_start' campaign.id location.id %}" style="margin-left: 10px">
                             <span class="glyphicon glyphicon-play" aria-hidden="true"></span>
                         </button>
                         <button type="button" name="bt_stop" class="btn btn-primary pull-right btn-xs" data-url="{% url 'url_radar_stop' campaign.id location.id %}" aria-label="Left Align" style="margin-left: 10px">
                             <span class="glyphicon glyphicon-stop" aria-hidden="true"></span>
                         </button>
                         <button type="button" name="bt_refresh" class="btn btn-primary pull-right btn-xs" data-url="{% url 'url_radar_refresh' campaign.id location.id %}" aria-label="Left Align" style="margin-left: 10px">
                             <span class="glyphicon glyphicon-refresh" aria-hidden="true"></span>
                         </button>
             	      </h3>
             	    </div>
             	      <div class="panel-body">
                         <div class="row">
             			{% for item in location.experiments %}
             			    {% if location.name in item.location.name  %}
             					<div class="col-xs-6 col-sm-3" >
             					  <a class="bootcards-summary-item" href="{{item.get_absolute_url}}">
                                       <i class="fa fa-2x fa-cogs"></i>
                                       <h4>{{item.name}}<br><small>{{item.start_time}}-{{item.end_time}}</small>
                                         <span class="label label-{{item.status_color}}">{{item.get_status_display}}</span>
                                       </h4>
                                   </a>
             					</div>
             			     {% endif %}
             			{% endfor %}
                         </div>
             	      </div>
             	    </div>
             	  {% endfor %}
             </div>
             {% endif %}
             {% endblock %}
             {% block extra-js%}
             <script type="text/javascript">
               //--------For PLAY Button-------
                 $("#accordion").on("click", "button[name=bt_play]", function(){
                 	//alert($(this).data('url'));
                 	document.location = $(this).data('url');
                 });
               //--------For STOP Button-------
                 $("#accordion").on("click", "button[name=bt_stop]", function(){
                 	//alert($(this).data('url'));
                 	document.location = $(this).data('url');
                 });
               //--------For REFRESH Button-------
                 $("#accordion").on("click", "button[name=bt_refresh]", function(){
                 	document.location = $(this).data('url');
                 });
             	$("#id_campaign").change(function() {
             		document.location = "{% url 'url_operation'%}"+$(this).val();
                 });
             </script>
             {% endblock %}

apps/main/views.py +13 -11

             import ast
             import json
             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.core.urlresolvers 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
             try:
                 from urllib.parse import urlencode
             except ImportError:
                 from urllib import urlencode
             from .forms import CampaignForm, ExperimentForm, DeviceForm, ConfigurationForm, LocationForm, UploadFileForm, DownloadFileForm, OperationForm, NewForm
             from .forms import OperationSearchForm, FilterForm, ChangeIpForm
-            from .tasks import task_start, task_stop, task_status, kill_tasks
+            from .tasks import task_start
             from apps.rc.forms import RCConfigurationForm, RCLineCode, RCMixConfigurationForm
             from apps.dds.forms import DDSConfigurationForm
             from apps.jars.forms import JARSConfigurationForm
             from apps.cgs.forms import CGSConfigurationForm
             from apps.abs.forms import ABSConfigurationForm
             from apps.usrp.forms import USRPConfigurationForm
             from .utils import Params
             from .models import Campaign, Experiment, Device, Configuration, Location, RunningExperiment, DEV_STATES
             from apps.cgs.models import CGSConfiguration
             from apps.jars.models import JARSConfiguration, EXPERIMENT_TYPE
             from apps.usrp.models import USRPConfiguration
             from apps.abs.models import ABSConfiguration
             from apps.rc.models import RCConfiguration, RCLine, RCLineType
             from apps.dds.models import DDSConfiguration
+            from radarsys.celery import app
             from django.contrib.auth.decorators import login_required
             from django.contrib.auth.decorators import user_passes_test
             from django.contrib.admin.views.decorators import staff_member_required
             CONF_FORMS = {
                 'rc': RCConfigurationForm,
                 'dds': DDSConfigurationForm,
                 'jars': JARSConfigurationForm,
                 'cgs': CGSConfigurationForm,
                 'abs': ABSConfigurationForm,
                 'usrp': USRPConfigurationForm,
             }
             CONF_MODELS = {
                 'rc': RCConfiguration,
                 'dds': DDSConfiguration,
                 'jars': JARSConfiguration,
                 'cgs': CGSConfiguration,
                 'abs': ABSConfiguration,
                 'usrp': USRPConfiguration,
             }
             MIX_MODES = {
                 '0': 'P',
                 '1': 'S',
             }
             MIX_OPERATIONS = {
                 '0': 'OR',
                 '1': 'XOR',
                 '2': 'AND',
                 '3': 'NAND',
             }
             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)
             @user_passes_test(lambda u:u.is_staff)
             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)
             @user_passes_test(lambda u:u.is_staff)
             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)
             @user_passes_test(lambda u:u.is_staff)
             def location_delete(request, id_loc):
                 location = get_object_or_404(Location, pk=id_loc)
                 if request.method=='POST':
                     if request.user.is_staff:
                         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,
                           'previous': location.get_absolute_url(),
                           'delete': True
                           }
                 return render(request, 'confirm.html', kwargs)
             def devices(request):
                 page = request.GET.get('page')
                 order = ('device_type', 'name')
                 kwargs = get_paginator(Device, page, order)
                 kwargs['keys'] = ['name', 'ip_address', 'port_address', 'device_type']
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'List'
                 kwargs['no_sidebar'] = True
                 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', 'name', 'ip_address', 'port_address', 'description']
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'Details'
                 return render(request, 'device.html', kwargs)
             @user_passes_test(lambda u:u.is_staff)
             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'
                 return render(request, 'base_edit.html', kwargs)
             @user_passes_test(lambda u:u.is_staff)
             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'
                 return render(request, 'base_edit.html', kwargs)
             @user_passes_test(lambda u:u.is_staff)
             def device_delete(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 if request.method=='POST':
                     if request.user.is_staff:
                         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,
                           'previous': device.get_absolute_url(),
                           'delete': True
                           }
                 return render(request, 'confirm.html', kwargs)
             @user_passes_test(lambda u:u.is_staff)
             def device_change_ip(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 if request.method=='POST':
                     if request.user.is_staff:
                         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' : ' ',
                           }
                 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']
                 kwargs['title'] = 'Campaign'
                 kwargs['suptitle'] = 'List'
                 kwargs['no_sidebar'] = True
                 kwargs['form'] = form
                 filters.pop('page', None)
                 kwargs['q'] = urlencode(filters)
                 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'
                 return render(request, 'campaign.html', kwargs)
             @user_passes_test(lambda u:u.is_staff)
             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()
                         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'
                 return render(request, 'campaign_edit.html', kwargs)
             @user_passes_test(lambda u:u.is_staff)
             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'
                 return render(request, 'campaign_edit.html', kwargs)
             @user_passes_test(lambda u:u.is_staff)
             def campaign_delete(request, id_camp):
                 campaign = get_object_or_404(Campaign, pk=id_camp)
                 if request.method=='POST':
                     if request.user.is_staff:
                         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,
                           'previous': campaign.get_absolute_url(),
                           'delete': True
                           }
                 return render(request, 'confirm.html', kwargs)
             @user_passes_test(lambda u:u.is_staff)
             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
             @user_passes_test(lambda u:u.is_staff)
             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'
                 return render(request, 'campaign_import.html', kwargs)
             def experiments(request):
                 page = request.GET.get('page')
                 order = ('location',)
                 filters = request.GET.copy()
                 kwargs = get_paginator(Experiment, page, order, filters)
                 form = FilterForm(initial=request.GET, extra_fields=['tags','template'])
                 kwargs['keys'] = ['name', 'radar_system', 'start_time', 'end_time']
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'List'
                 kwargs['no_sidebar'] = True
                 kwargs['form'] = form
                 filters.pop('page', None)
                 kwargs['q'] = urlencode(filters)
                 return render(request, 'base_list.html', kwargs)
             def experiment(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 configurations = Configuration.objects.filter(experiment=experiment, type=0)
                 kwargs = {}
                 kwargs['experiment_keys'] = ['template', 'radar_system', 'name', 'freq', 'start_time', 'end_time']
                 kwargs['experiment'] = experiment
                 kwargs['configuration_keys'] = ['name', 'device__ip_address', 'device__port_address', 'device__status']
                 kwargs['configurations'] = configurations
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Add Configuration'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(experiment=experiment))
                 return render(request, 'experiment.html', kwargs)
             @user_passes_test(lambda u:u.is_staff)
             def experiment_new(request, id_camp=None):
                 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()
                         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'
                 return render(request, 'experiment_edit.html', kwargs)
             @user_passes_test(lambda u:u.is_staff)
             def experiment_edit(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 if request.method == 'GET':
                     form = ExperimentForm(instance=experiment)
                 if request.method=='POST':
                     form = ExperimentForm(request.POST, instance=experiment)
                     if form.is_valid():
                         experiment = form.save()
                         return redirect('url_experiment', id_exp=experiment.id)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 return render(request, 'experiment_edit.html', kwargs)
             @user_passes_test(lambda u:u.is_staff)
             def experiment_delete(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 if request.method=='POST':
                     if request.user.is_staff:
                         for conf in Configuration.objects.filter(experiment=experiment):
                             conf.delete()
                         experiment.delete()
                         return redirect('url_experiments')
                     messages.error(request, 'Not enough permission to delete this object')
                     return redirect(experiment.get_absolute_url())
                 kwargs = {
                           'title': 'Delete',
                           'suptitle': 'Experiment',
                           'object': experiment,
                           'previous': experiment.get_absolute_url(),
                           'delete': True
                           }
                 return render(request, 'confirm.html', kwargs)
             @user_passes_test(lambda u:u.is_staff)
             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
             @user_passes_test(lambda u:u.is_staff)
             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.update(sidebar(experiment=experiment))
                 return render(request, 'experiment_import.html', kwargs)
             @user_passes_test(lambda u:u.is_staff)
             def experiment_start(request, id_exp):
                 exp = get_object_or_404(Experiment, pk=id_exp)
                 if exp.status == 2:
                     messages.warning(request, 'Experiment {} already runnnig'.format(exp))
                 else:
                     exp.status = exp.start()
                     if exp.status==0:
                         messages.error(request, 'Experiment {} not start'.format(exp))
                     if exp.status==2:
                         messages.success(request, 'Experiment {} started'.format(exp))
                     exp.save()
                 return redirect(exp.get_absolute_url())
             @user_passes_test(lambda u:u.is_staff)
             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())
             @user_passes_test(lambda u:u.is_staff)
             def experiment_mix(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 rc_confs = [conf for conf in RCConfiguration.objects.filter(experiment=id_exp,
                                                                             mix=False)]
                 if len(rc_confs)<2:
                     messages.warning(request, 'You need at least two RC Configurations to make a mix')
                     return redirect(experiment.get_absolute_url())
                 mix_confs = RCConfiguration.objects.filter(experiment=id_exp, mix=True)
                 if mix_confs:
                     mix = mix_confs[0]
                 else:
                     mix = RCConfiguration(experiment=experiment,
                                           device=rc_confs[0].device,
                                           ipp=rc_confs[0].ipp,
                                           clock_in=rc_confs[0].clock_in,
                                           clock_divider=rc_confs[0].clock_divider,
                                           mix=True,
                                           parameters='')
                     mix.save()
                     line_type = RCLineType.objects.get(name='mix')
                     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]
                            }
                 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.name = request.POST['name']
                         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,
                           }
                 return render(request, 'experiment_mix.html', kwargs)
             @user_passes_test(lambda u:u.is_staff)
             def experiment_mix_delete(request, id_exp):
-                conf = RCConfiguration.objects.get(experiment=id_exp, mix=True)
+                conf = RCConfiguration.objects.get(experiment=id_exp, mix=True, type=0)
                 values = conf.parameters.split('-')
                 conf.parameters = '-'.join(values[:-1])
                 conf.save()
                 return redirect('url_mix_experiment', id_exp=id_exp)
             def experiment_summary(request, id_exp):
                 experiment      = get_object_or_404(Experiment, pk=id_exp)
                 configurations  = Configuration.objects.filter(experiment=experiment, type=0)
                 kwargs = {}
                 kwargs['experiment_keys'] = ['radar_system', 'name', 'freq', 'start_time', 'end_time']
                 kwargs['experiment'] = experiment
                 kwargs['configurations'] = []
                 kwargs['title'] = 'Experiment Summary'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Verify Parameters'
                 c_vel        = 3.0*(10**8)     #m/s
                 ope_freq     = experiment.freq*(10**6) #1/s
                 radar_lambda = c_vel/ope_freq  #m
                 kwargs['radar_lambda'] = radar_lambda
                 jars_conf = False
                 rc_conf   = False
                 code_id = 0
                 tx_line = {}
                 for configuration in configurations:
                     #--------------------- RC ----------------------:
                     if configuration.device.device_type.name == 'rc':
                         if configuration.mix:
                             continue
                         rc_conf = True
                         ipp = configuration.ipp
                         lines = configuration.get_lines(line_type__name='tx')
                         configuration.tx_lines = []
                         for tx_line in lines:
                             if tx_line.get_name()[-1] == 'A':
                                 txa_line = tx_line
                                 txa_params = json.loads(txa_line.params)
                             line = {'name':tx_line.get_name()}
                             tx_params = json.loads(tx_line.params)
                             line['width'] = tx_params['pulse_width']
                             if line['width'] in (0, '0'):
                                 continue
                             delays = tx_params['delays']
                             if delays not in ('', '0'):
                                 n = len(delays.split(','))
                                 line['taus'] = '{} Taus: {}'.format(n, delays)
                             else:
                                 line['taus'] = '-'
                             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']):
                                     line['codes'] = '{}:{}'.format(RCLineCode.objects.get(pk=code_params['code']),
                                                                    '-'.join(code_params['codes']))
                             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)
                                     line['windows'] = mark_safe(windows)
                             configuration.tx_lines.append(line)
                             if txa_line:
                                 kwargs['duty_cycle'] = float(txa_params['pulse_width'])/ipp*100
                     #-------------------- JARS -----------------------:
                     if configuration.device.device_type.name == 'jars':
                         jars_conf = True
                         kwargs['exp_type']  = EXPERIMENT_TYPE[configuration.exp_type][1]
                         channels_number     = configuration.channels_number
                         exp_type            = configuration.exp_type
                         fftpoints           = configuration.fftpoints
                         filter_parms        = configuration.filter_parms
                         filter_parms        = ast.literal_eval(filter_parms)
                         spectral_number     = configuration.spectral_number
                         acq_profiles        = configuration.acq_profiles
                         cohe_integr         = configuration.cohe_integr
                         profiles_block      = configuration.profiles_block
                         if filter_parms.__class__.__name__=='str':
                             filter_parms = eval(filter_parms)
                     kwargs['configurations'].append(configuration)
                     #------ RC & JARS ------:
                     if rc_conf and jars_conf:
                         #RC filter values:
                         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:
                         try:
                             clock      = eval(filter_parms['clock'])
                             filter_2   = eval(filter_parms['filter_2'])
                             filter_5   = eval(filter_parms['filter_5'])
                             filter_fir = eval(filter_parms['filter_fir'])
                         except:
                             clock      = float(filter_parms['clock'])
                             filter_2   = int(filter_parms['filter_2'])
                             filter_5   = int(filter_parms['filter_5'])
                             filter_fir = int(filter_parms['filter_fir'])
                         Fs_MHz     = clock/(filter_2*filter_5*filter_fir)
                         #Jars values:
                         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))
                         #Values
                         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)
                         kwargs['rate_bh']        = str(rate_bh) + " (Bytes/h)"
                         kwargs['rate_gh']        = str(rate_gh)+" (GBytes/h)"
                         kwargs['va']             = Va
                         kwargs['time_per_block'] = IPP_s * profiles_block * cohe_integr
                         kwargs['acqtime']        = IPP_s * acq_profiles
                         kwargs['vrange']         = 3/(2*IPP_s*cohe_integr)
                     else:
                         kwargs['rate_bh']        = ''
                         kwargs['rate_gh']        = ''
                         kwargs['va']             = ''
                         kwargs['time_per_block'] = ''
                         kwargs['acqtime']        = ''
                         kwargs['vrange']         = ''
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(experiment=experiment))
                 return render(request, 'experiment_summary.html', kwargs)
             @user_passes_test(lambda u:u.is_staff)
             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           = jars.filter_parms
                         filter_parms           = ast.literal_eval(filter_parms)
                         kwargs['filter_parms'] = filter_parms
                         #--Sampling Frequency
                         clock          = eval(filter_parms['clock'])
                         filter_2       = eval(filter_parms['filter_2'])
                         filter_5       = eval(filter_parms['filter_5'])
                         filter_fir     = eval(filter_parms['filter_fir'])
                         samp_freq_jars = clock/filter_2/filter_5/filter_fir
                         kwargs['samp_freq_jars'] = samp_freq_jars
                         kwargs['jars']           = configuration
                     #--------------------- RC ----------------------:
                     if configuration.device.device_type.name == 'rc' and not configuration.mix:
                         rc_conf = True
                         rc = configuration
                         rc_parms = configuration.parms_to_dict()
                         win_lines = rc.get_lines(line_type__name='windows')
                         if win_lines:
                             dh = json.loads(win_lines[0].params)['params'][0]['resolution']
                             #--Sampling Frequency
                             samp_freq_rc = 0.15/dh
                             kwargs['samp_freq_rc'] = samp_freq_rc
                             kwargs['rc_conf'] = rc_conf
                             kwargs['rc']      = configuration
                     #-------------------- DDS ----------------------:
                     if configuration.device.device_type.name == 'dds':
                         dds_conf = True
                         dds = configuration
                         dds_parms = configuration.parms_to_dict()
                         kwargs['dds_conf'] = dds_conf
                         kwargs['dds']      = configuration
                 #------------Validation------------:
                 #Clock
                 if dds_conf and rc_conf and jars_conf:
                     if float(filter_parms['clock']) != float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) and float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) != float(dds_parms['configurations']['byId'][str(dds.pk)]['clock']):
                         messages.warning(request, "Devices don't have the same clock.")
                 elif rc_conf and jars_conf:
                     if float(filter_parms['clock']) != float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']):
                         messages.warning(request, "Devices don't have the same clock.")
                 elif rc_conf and dds_conf:
                     if float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) != float(dds_parms['configurations']['byId'][str(dds.pk)]['clock']):
                         messages.warning(request, "Devices don't have the same clock.")
                     if float(samp_freq_rc) != float(dds_parms['configurations']['byId'][str(dds.pk)]['frequencyA']):
                         messages.warning(request, "Devices don't have the same Frequency A.")
                 #------------POST METHOD------------:
                 if request.method == 'POST':
                     if request.POST['suggest_clock']:
                         try:
                             suggest_clock = float(request.POST['suggest_clock'])
                         except:
                             messages.warning(request, "Invalid value in CLOCK IN.")
                             return redirect('url_verify_experiment', id_exp=experiment.id)
                     else:
                         suggest_clock = ""
                     if suggest_clock:
                         if rc_conf:
                             rc.clock_in = suggest_clock
                             rc.save()
                         if jars_conf:
                             filter_parms           = jars.filter_parms
                             filter_parms           = ast.literal_eval(filter_parms)
                             filter_parms['clock'] = suggest_clock
                             jars.filter_parms = json.dumps(filter_parms)
                             jars.save()
                             kwargs['filter_parms'] = filter_parms
                         if dds_conf:
                             dds.clock = suggest_clock
                             dds.save()
                     if request.POST['suggest_frequencyA']:
                         try:
                             suggest_frequencyA = float(request.POST['suggest_frequencyA'])
                         except:
                             messages.warning(request, "Invalid value in FREQUENCY A.")
                             return redirect('url_verify_experiment', id_exp=experiment.id)
                     else:
                         suggest_frequencyA = ""
                     if suggest_frequencyA:
                         if jars_conf:
                             filter_parms           = jars.filter_parms
                             filter_parms           = ast.literal_eval(filter_parms)
                             filter_parms['fch'] = suggest_frequencyA
                             jars.filter_parms = json.dumps(filter_parms)
                             jars.save()
                             kwargs['filter_parms'] = filter_parms
                         if dds_conf:
                             dds.frequencyA_Mhz = request.POST['suggest_frequencyA']
                             dds.save()
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(experiment=experiment))
                 return render(request, 'experiment_verify.html', kwargs)
             #@user_passes_test(lambda u:u.is_staff)
             def parse_mix_result(s):
                 values = s.split('-')
                 html = 'EXP                MOD OPE DELAY         MASK\r\n'
                 if not values or values[0] in ('', ' '):
                     return mark_safe(html)
                 for i, value in enumerate(values):
                     if not value:
                         continue
                     pk, mode, operation, delay, mask = value.split('|')
                     conf = RCConfiguration.objects.get(pk=pk)
                     if i==0:
                         html += '{:20.18}{:3}{:4}{:9}km{:>6}\r\n'.format(
                                             conf.name,
                                             mode,
                                             '   ',
                                             delay,
                                             mask)
                     else:
                         html += '{:20.18}{:3}{:4}{:9}km{:>6}\r\n'.format(
                                             conf.name,
                                             mode,
                                             operation,
                                             delay,
                                             mask)
                 return mark_safe(html)
             def parse_mask(l):
                 values = []
                 for x in range(8):
                     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 = ('type', 'device__device_type', 'experiment')
                 filters = request.GET.copy()
                 kwargs = get_paginator(Configuration, page, order, filters)
                 form = FilterForm(initial=request.GET, extra_fields=['tags', 'template', 'historical'])
                 kwargs['keys'] = ['name', 'experiment', 'type', 'programmed_date']
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'List'
                 kwargs['no_sidebar'] = True
                 kwargs['form'] = form
                 filters.pop('page', None)
                 kwargs['q'] = urlencode(filters)
                 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())
             @user_passes_test(lambda u:u.is_staff)
             def dev_conf_new(request, id_exp=0, id_dev=0):
                 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()
                         if 'template' in request.GET and conf.device.device_type.name=='rc':
                             lines = RCLine.objects.filter(rc_configuration=request.GET['template'])
                             for line in lines:
                                 line.clone(rc_configuration=conf)
                             new_lines = conf.get_lines()
                             for line in new_lines:
                                 line_params = json.loads(line.params)
                                 if 'TX_ref' in line_params:
                                     ref_line = RCLine.objects.get(pk=line_params['TX_ref'])
                                     line_params['TX_ref'] = ['{}'.format(l.pk) for l in new_lines if l.get_name()==ref_line.get_name()][0]
                                     line.params = json.dumps(line_params)
                                     line.save()
                         return redirect('url_dev_conf', id_conf=conf.pk)
                 kwargs['id_exp'] = id_exp
                 kwargs['form'] = form
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'New'
                 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)
             @user_passes_test(lambda u:u.is_staff)
             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'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
             @user_passes_test(lambda u:u.is_staff)
             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())
             @user_passes_test(lambda u:u.is_staff)
             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())
             def dev_conf_status(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if conf.status_device():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 return redirect(conf.get_absolute_url())
             @user_passes_test(lambda u:u.is_staff)
             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())
             @user_passes_test(lambda u:u.is_staff)
             def dev_conf_write(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if conf.write_device():
                     messages.success(request, conf.message)
                     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())
             @user_passes_test(lambda u:u.is_staff)
             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)
             @user_passes_test(lambda u:u.is_staff)
             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.update(sidebar(conf=conf))
                 return render(request, 'dev_conf_import.html', kwargs)
             @user_passes_test(lambda u:u.is_staff)
             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'
                 return render(request, 'dev_conf_export.html', kwargs)
             @user_passes_test(lambda u:u.is_staff)
             def dev_conf_delete(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if request.method=='POST':
                     if request.user.is_staff:
                         conf.delete()
                         return redirect('url_dev_confs')
                     messages.error(request, 'Not enough permission to delete this object')
                     return redirect(conf.get_absolute_url())
                 kwargs = {
                           'title': 'Delete',
                           'suptitle': 'Experiment',
                           'object': conf,
                           'previous': conf.get_absolute_url(),
                           'delete': True
                           }
                 return render(request, 'confirm.html', kwargs)
             def sidebar(**kwargs):
                 side_data = {}
                 conf = kwargs.get('conf', None)
                 experiment = kwargs.get('experiment', None)
                 if not experiment:
                     experiment = conf.experiment
                 if experiment:
                     side_data['experiment'] = experiment
                     campaign = experiment.campaign_set.all()
                     if campaign:
                         side_data['campaign'] = campaign[0]
                         experiments = campaign[0].experiments.all()
                     else:
                         experiments = [experiment]
                     configurations = experiment.configuration_set.filter(type=0)
                     side_data['side_experiments'] = experiments
                     side_data['side_configurations'] = configurations
                 return side_data
             def get_paginator(model, page, order, filters={}, n=10):
                 kwargs = {}
                 query = Q()
                 if isinstance(filters, QueryDict):
                     filters = filters.dict()
                 [filters.pop(key) for key in filters.keys() if filters[key] in ('', ' ')]
                 filters.pop('page', None)
                 fields = [f.name for f in model._meta.get_fields()]
                 if 'template' in filters:
                     filters['template'] = True
                 if 'historical' in filters:
                     filters.pop('historical')
                     filters['type'] = 1
                 elif 'type' in fields:
                     filters['type'] = 0
                 if 'start_date' in filters:
                     filters['start_date__gte'] = filters.pop('start_date')
                 if 'end_date' in filters:
                     filters['start_date__lte'] = filters.pop('end_date')
                 if 'tags' in filters:
                     tags = filters.pop('tags')
                     if 'tags' in fields:
                         query = query | Q(tags__icontains=tags)
                     if 'name' in fields:
                         query = query | Q(name__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)
                 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
                 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:
                     start = datetime.combine(datetime.now().date(), exp.start_time)
-                    end = datetime.combine(datetime.now().date(), exp.start_time)
+                    end = datetime.combine(datetime.now().date(), exp.end_time)
                     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
                     if now > start and now <= end:
-                        task = task_start.delay(exp.pk)
+                        exp.status = 3
+                        exp.save()
+                        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:
-                            task = task_stop.apply_async((exp.pk,), eta=end+timedelta(hours=5))
                             messages.success(request, 'Experiment {} started'.format(exp))
                     else:
                         task = task_start.apply_async((exp.pk, ), eta=start+timedelta(hours=5))
-                        task = task_stop.apply_async((exp.pk,), eta=end+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']
                 for exp in experiments:
+                    if exp.task:
+                        app.control.revoke(exp.task)
                     if exp.status == 2:
-                        task = task_stop.delay(exp.pk)
+                        exp.stop()
-                        exp.status = task.wait()
                         messages.warning(request, 'Experiment {} stopped'.format(exp))
+                    exp.status = 1
                     exp.save()
-                    else:
-                        messages.error(request, 'Experiment {} not running'.format(exp))
-                kill_tasks()
                 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']
                 for exp in experiments:
                     exp.get_status()
                 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)

radarsys/celery.py +1 0

             from __future__ import absolute_import
             import os
             from celery import Celery
             from django.conf import settings
             # set the default Django settings module for the 'celery' program.
             os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'radarsys.settings')
             app = Celery('radarsys')
             # Using a string here means the worker will not have to
             # pickle the object when using Windows.
             app.config_from_object('django.conf:settings')
+            app.conf.broker_transport_options = {'visibility_timeout': 86400}
             app.autodiscover_tasks(lambda: settings.INSTALLED_APPS)
             @app.task(bind=True)
             def debug_task(self):
                 print('Request: {0!r}'.format(self.request))

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