radarsys Commit - r157:82791b88ae92 · Jicamarca Repository

sync repo...

Juan C. Espinoza -

r157:82791b88ae92

parent child

Context file:

r157:82791b88ae92

Expand all files

apps/jars/templates/jars_import.html created 644 +1 0

	@@ -0,0 +1,1
				1	{% extends "dev_conf_edit.html" %}

apps/main/templates/experiment_verify.html created 644 +145 0

@@ -0,0 +1,145
	1	{% extends "base.html" %}
	2	{% load bootstrap3 %}
	3	{% load static %}
	4	{% load main_tags %}
	5	{% block extra-head %}
	6	<link href="{% static 'css/bootstrap-datetimepicker.min.css' %}" media="screen" rel="stylesheet">
	7	{% endblock %}
	8
	9	{% block exp-active %}active{% endblock %}
	10
	11	{% block content-title %}{{title}}{% endblock %}
	12	{% block content-suptitle %}{{suptitle}}{% endblock %}
	13
	14	{% block content %}
	15
	16	{% block menu-actions %}
	17
	18	{% endblock %}
	19
	20
	21
	22	<table class="table table-bordered" style="text-align:center;">
	23	<!--<h4 class="panel-title"> </h4>-->
	24	<tr>
	25	<th style="text-align:center;">Parameters</th>
	26	<th style="text-align:center;">DDS</th>
	27	<th style="text-align:center;">RC</th>
	28	<th style="text-align:center;">JARS</th>
	29	<th style="text-align:center;">=P</th>
	30	</tr>
	31
	32	<tr>
	33	<th>Clock In</th>
	34	<td id="dds_clock">{{ dds.clock }}</td>
	35	<td id="rc_clock">{{ rc.clock_in }}</td>
	36	<td id="filter_clock">{{ filter_parms.clock }}</td>
	37	<td><input id="suggest_clock"></input></td>
	38	</tr>
	39
	40	<tr>
	41	<th>Frequency A (Mhz)</th>
	42	<td>{{ dds.frequencyA_Mhz }}</td>
	43	<td>x</td>
	44	<td>{{ filter_parms.fch }}</td>
	45	<td><input></input></td>
	46	</tr>
	47
	48	<tr>
	49	<th>Frequency A (Decimal)</th>
	50	<td>{{ dds.frequencyA }}</td>
	51	<td>x</td>
	52	<td>{{ filter_parms.fch_decimal }}</td>
	53	<td><input></input></td>
	54	</tr>
	55
	56	<tr>
	57	<th>Sampling Frequency (MHz)</th>
	58	<td id="dds_sampfreq">{{ dds.frequencyA }}</td>
	59	<td id="rc_sampfreq">{{ samp_freq_rc }}</td>
	60	<td id="jars_sampfreq">{{ samp_freq_jars }}</td>
	61	<td><input id="suggest_sampfreq"></input></td>
	62	</tr>
	63	</table>
	64
	65
	66
	67	<div class="">
	68	<h4 class="panel-title"><b> Extra Parameters </b></h4>
	69	<br>
	70	</div>
	71
	72	<table class="table table-bordered" >
	73	{% for configuration in configurations %}
	74	{% if configuration.device.device_type.name == 'jars' %}
	75	<tr><th>Rate(MB/h)</th><td>{{ rate }}</td></tr>
	76	{% endif %}
	77	{% endfor %}
	78	</table>
	79
	80
	81	<div class="pull-right">
	82	<button type="button" class="btn btn-primary" id="bt_back">Back</button>
	83	<button type="button" class="btn btn-primary" id="bt_update">{{ button }}</button>
	84	</div>
	85
	86	{% endblock %}
	87
	88	{% block sidebar%}
	89	{% include "sidebar_devices.html" %}
	90	{% endblock %}
	91
	92	{% block extra-js%}
	93	<script type="text/javascript">
	94
	95	{% if dds_conf %}
	96	$(document).ready(function() {
	97	$('#dds_clock').click(function(event) {
	98	clock = $("#dds_clock").text();
	99	$("#suggest_clock").val(clock);
	100	});
	101	$('#dds_sampfreq').click(function(event) {
	102	sampfreq = $("#dds_sampfreq").text();
	103	$("#suggest_sampfreq").val(sampfreq);
	104	});
	105	});
	106	{% endif %}
	107	{% if rc_conf %}
	108	$(document).ready(function() {
	109	$('#rc_clock').click(function(event) {
	110	clock = $("#rc_clock").text();
	111	$("#suggest_clock").val(clock);
	112	});
	113	$('#rc_sampfreq').click(function(event) {
	114	sampfreq = $("#rc_sampfreq").text();
	115	$("#suggest_sampfreq").val(sampfreq);
	116	});
	117	});
	118	{% endif %}
	119	{% if jars_conf %}
	120	$(document).ready(function() {
	121	$('#filter_clock').click(function(event) {
	122	clock = $("#filter_clock").text();
	123	$("#suggest_clock").val(clock);
	124	});
	125	$('#jars_sampfreq').click(function(event) {
	126	sampfreq = $("#jars_sampfreq").text();
	127	$("#suggest_sampfreq").val(sampfreq);
	128	});
	129	});
	130	{% endif %}
	131
	132
	133
	134
	135	$(".clickable-row").click(function() {
	136	document.location = $(this).data("href");
	137	});
	138
	139	$("#bt_back").click(function() {
	140	document.location = "{% url 'url_experiment' experiment.id%}";
	141	});
	142
	143
	144	</script>
	145	{% endblock %} No newline at end of file

apps/jars/forms.py +39 -1

+            import os
             from django import forms
             from apps.main.models import Device, Experiment
             from .models import JARSConfiguration, JARSfilter
             from .widgets import SpectralWidget
             class JARSConfigurationForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(JARSConfigurationForm, self).__init__(*args, **kwargs)
                     instance = getattr(self, 'instance', None)
                     if instance and instance.pk:
                         devices = Device.objects.filter(device_type__name='jars')
                         if instance.experiment:
                             experiments = Experiment.objects.filter(pk=instance.experiment.id)
                             self.fields['experiment'].widget.choices = [(experiment.id, experiment) for experiment in experiments]
                         self.fields['device'].widget.choices = [(device.id, device) for device in devices]
                         #self.fields['spectral'].widget = SpectralWidget()
                     self.fields['spectral_number'].widget.attrs['readonly'] = True
                     self.fields['spectral'].widget = SpectralWidget()
                 #-------------JARS Configuration needs an Experiment-----------------
                 def clean(self):
                     cleaned_data = super(JARSConfigurationForm, self).clean()
                     experiment = cleaned_data.get('experiment')
                     if experiment == None:
                         msg = "Error: Jars Configuration needs an Experiment"
                         self.add_error('experiment', msg)
                 class Meta:
                     model = JARSConfiguration
                     exclude = ('type', 'parameters', 'status', 'filter_parms')
             class JARSfilterForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(JARSfilterForm, self).__init__(*args, **kwargs)
                     instance = getattr(self, 'instance', None)
                     self.fields['fch_decimal'].widget.attrs['readonly'] = True
                 class Meta:
                     model = JARSfilter
-                    exclude = ('type', 'parameters', 'status')
  No newline at end of file
+                    exclude = ('type', 'parameters', 'status')
+            class ExtFileField(forms.FileField):
+                """
+                Same as forms.FileField, but you can specify a file extension whitelist.
+                >>> from django.core.files.uploadedfile import SimpleUploadedFile
+                >>>
+                >>> t = ExtFileField(ext_whitelist=(".pdf", ".txt"))
+                >>>
+                >>> t.clean(SimpleUploadedFile('filename.pdf', 'Some File Content'))
+                >>> t.clean(SimpleUploadedFile('filename.txt', 'Some File Content'))
+                >>>
+                >>> t.clean(SimpleUploadedFile('filename.exe', 'Some File Content'))
+                Traceback (most recent call last):
+                ...
+                ValidationError: [u'Not allowed filetype!']
+                """
+                def __init__(self, *args, **kwargs):
+                    extensions = kwargs.pop("extensions")
+                    self.extensions = [i.lower() for i in extensions]
+                    super(ExtFileField, self).__init__(*args, **kwargs)
+                def clean(self, *args, **kwargs):
+                    data = super(ExtFileField, self).clean(*args, **kwargs)
+                    filename = data.name
+                    ext = os.path.splitext(filename)[1]
+                    ext = ext.lower()
+                    if ext not in self.extensions:
+                        raise forms.ValidationError('Not allowed file type: %s' % ext)
+            class JARSImportForm(forms.Form):
+                #file_name = ExtFileField(extensions=['.racp', '.json', '.dat'])
+                file_name = ExtFileField(extensions=['.json'])
  No newline at end of file

apps/jars/models.py +108 -17

             from django.db import models
             from apps.main.models import Configuration
             from django.core.validators import MinValueValidator, MaxValueValidator
+            from django.core.urlresolvers import reverse
+            from devices.jars import api
             from apps.rc.models import RCConfiguration
+            import json
             # Create your models here.
             EXPERIMENT_TYPE = (
                                (0, 'RAW_DATA'),
                                (1, 'PDATA'),
                                )
             DATA_TYPE = (
                          (0, 'SHORT'),
                          (1, 'FLOAT'),
                          )
             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.DecimalField(verbose_name='Frequency (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=19, decimal_places=16, null=True, default=49.9200)
                 fch_decimal = models.BigIntegerField(verbose_name='Frequency (Decimal)',validators=[MinValueValidator(0), MaxValueValidator(2**JARS_NBITS-1)], null=True, default=721554505)
                 filter_fir  = models.PositiveIntegerField(verbose_name='FIR Filter',validators=[MinValueValidator(1), MaxValueValidator(20)], default = 6)
                 filter_2    = models.PositiveIntegerField(verbose_name='Filter 2',validators=[MinValueValidator(1), MaxValueValidator(20)], default = 10)
                 filter_5    = models.PositiveIntegerField(verbose_name='Filter 5',validators=[MinValueValidator(1), MaxValueValidator(20)], default = 1)
                 speed       = models.PositiveIntegerField(verbose_name='Speed',validators=[MinValueValidator(0), MaxValueValidator(100000)], default = 0)
                 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)
                     parameters['speed']       = int(self.speed)
                     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']
                     self.speed       = parameters['speed']
             class JARSConfiguration(Configuration):
                 ADC_RESOLUTION   = 8
                 PCI_DIO_BUSWIDTH = 32
                 HEADER_VERSION   = 1103
                 BEGIN_ON_START   = True
                 REFRESH_RATE     = 1
                 #rc               = models.ForeignKey(RCConfiguration, on_delete=models.CASCADE, null=True)
                 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')
-                rd_directory     = models.CharField(verbose_name='Raw Data Directory', max_length=40, default='', blank=True, null=True)
+                rd_directory     = models.CharField(verbose_name='Raw Data Directory', max_length=200, default='', blank=True, null=True)
-                raw_data_blocks  = models.PositiveIntegerField(verbose_name='Raw Data Blocks', validators=[MaxValueValidator(5000)], default=120)
+                pd_directory     = models.CharField(verbose_name='Process Data Directory', max_length=200, default='', blank=True, null=True)
+                #raw_data_blocks  = models.PositiveIntegerField(verbose_name='Raw Data Blocks', validators=[MaxValueValidator(5000)], default=120)
                 data_type        = models.PositiveIntegerField(verbose_name='Data Type', choices=DATA_TYPE, default=0)
                 acq_profiles     = models.PositiveIntegerField(verbose_name='Acquired Profiles', validators=[MaxValueValidator(5000)], default=400)
                 profiles_block   = models.PositiveIntegerField(verbose_name='Profiles Per Block', validators=[MaxValueValidator(5000)], 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)
                 filter           = models.ForeignKey(JARSfilter, on_delete=models.CASCADE, null=True)
                 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=True)
-                acq_link         = models.BooleanField(verbose_name='Acquisition Link', default=True)
+                #acq_link         = models.BooleanField(verbose_name='Acquisition Link', default=True)
-                view_raw_data    = models.BooleanField(verbose_name='View Raw Data', default=True)
+                #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='{}')
                 class Meta:
                     db_table = 'jars_configurations'
                 def parms_to_dict(self):
                     parameters = {}
+                    parameters['device_id']        = self.device.id
                     parameters['name']             = self.name
                     #parameters['rc']               = self.rc.name
                     parameters['exp_type']         = self.exp_type
                     parameters['exptype']          = EXPERIMENT_TYPE[self.exp_type][1]
                     parameters['cards_number']     = self.cards_number
                     parameters['channels_number']  = self.channels_number
                     parameters['channels']         = self.channels
                     parameters['rd_directory']     = self.rd_directory
-                    parameters['raw_data_blocks']  = self.raw_data_blocks
+                    #parameters['raw_data_blocks']  = self.raw_data_blocks
                     parameters['data_type']        = self.data_type
+                    parameters['cohe_integr_str']  = self.cohe_integr_str
                     parameters['acq_profiles']     = self.acq_profiles
                     parameters['profiles_block']   = self.profiles_block
+                    parameters['ftp_interval']     = self.ftp_interval
                     parameters['fftpoints']        = self.fftpoints
                     parameters['cohe_integr']      = self.cohe_integr
                     #parameters['incohe_integr']    = self.incohe_integr
                     parameters['filter']           = self.filter.name
+                    parameters['filter_parms']     = self.filter_parms
                     #parameters['spectral_number']  = self.spectral_number
                     #parameters['spectral']         = self.spectral
                     parameters['create_directory'] = bool(self.create_directory)
                     parameters['include_expname']  = bool(self.include_expname)
-                    parameters['acq_link']         = bool(self.acq_link)
+                    #parameters['acq_link']         = bool(self.acq_link)
-                    parameters['view_raw_data']    = bool(self.view_raw_data)
+                    #parameters['view_raw_data']    = bool(self.view_raw_data)
                     parameters['save_ch_dc']       = bool(self.save_ch_dc)
+                    parameters['save_data']        = bool(self.save_data)
                     if parameters['exptype'] == 'PDATA':
                         parameters['incohe_integr']    = self.incohe_integr
                         parameters['spectral_number']  = self.spectral_number
                         parameters['spectral']         = self.spectral
+                        parameters['pd_directory']     = self.pd_directory
                     return parameters
                 def add_parms_to_filter(self):
                     self.filter_parms = self.filter.parms_to_dict()
                     self.save()
                 def dict_to_parms(self, parameters):
+                    self.name           = parameters['name']
+                    self.device.id       = int(parameters['device_id'])
                     self.exp_type        = int(parameters['exp_type'])
                     if parameters['exptype'] == 'PDATA':
                         self.incohe_integr   = parameters['incohe_integr']
                         self.spectral_number = parameters['spectral_number']
-                        self.spectral        =  parameters['spectral']
+                        self.spectral        = parameters['spectral']
+                        self.pd_directory    = parameters['pd_directory']
                     self.cards_number    = int(parameters['cards_number'])
                     self.channels_number = int(parameters['channels_number'])
                     self.channels        = parameters['channels']
                     self.rd_directory    = parameters['rd_directory']
-                    self.raw_data_blocks = parameters['raw_data_blocks']
+                    #self.raw_data_blocks = parameters['raw_data_blocks']
                     self.data_type       = parameters['data_type']
+                    self.cohe_integr_str = parameters['cohe_integr_str']
                     self.acq_profiles    = parameters['acq_profiles']
                     self.profiles_block  = parameters['profiles_block']
+                    self.ftp_interval    = parameters['ftp_interval']
                     self.fftpoints       = parameters['fftpoints']
                     self.cohe_integr     = parameters['cohe_integr']
-                    filter_name    = parameters['filter']
+                    filter_name       = parameters['filter']
-                    self.filter    = JARS.objects.get(name=filter_name)
+                    self.filter    = JARSfilter.objects.get(name=filter_name)
-                    self.save()
                     self.add_parms_to_filter()
+                    self.filter_parms = parameters['filter_parms']
                     self.create_directory = bool(parameters['create_directory'])
                     self.include_expname  = bool(parameters['include_expname'])
-                    self.acq_link         = bool(parameters['acq_link'])
+                    #self.acq_link         = bool(parameters['acq_link'])
-                    self.view_raw_data    = bool(parameters['view_raw_data'])
+                    #self.view_raw_data    = bool(parameters['view_raw_data'])
                     self.save_ch_dc       = bool(parameters['save_ch_dc'])
+                    self.save_data        = bool(parameters['save_data'])
                 def status_device(self):
-                    return
+                    answer = api.status(self.device.ip_address,self.device.port_address)
+                    self.device.status = int(answer[0])
+                    self.message = answer[2:]
+                    self.device.save()
+                    return self.device.status
+                def stop_device(self):
+                    answer = api.stop(self.device.ip_address,self.device.port_address)
+                    self.device.status = int(answer[0])
+                    self.message = answer[2:]
+                    self.device.save()
+                    return self.device.status
                 def read_device(self):
-                    return
+                    answer = api.read(self.device.ip_address,self.device.port_address)
+                    self.device.status = int(answer[0])
+                    try:
+                        data = json.loads(answer[2:])
+                        parms = data['configurations']['jars']
+                    except:
+                        self.device.status = 0
+                        self.device.save()
+                        self.message = 'Could not read JARS configuration.'
+                        return ''
+                    #self.dict_to_parms(parms)
+                    self.message = 'Current JARS configuration was read successfully.'
+                    self.device.save()
+                    return parms
                 def write_device(self):
-                    return
  No newline at end of file
+                    data = self.experiment.parms_to_dict()
+                    data = json.loads(data)
+                    data['configurations']['dds']         =''
+                    data['configurations']['cgs']         =''
+                    data['configurations']['rc']['pulses']=''
+                    data['configurations']['rc']['delays']=''
+                    json_data = json.dumps(data)
+                    answer = api.configure(self.device.ip_address,self.device.port_address,json_data)
+                    #print answer
+                    self.device.status = int(answer[0])
+                    self.message = answer[2:]
+                    self.device.save()
+                    return self.device.status
+                def echo(self):
+                    answer = api.echo(self.device.ip_address,self.device.port_address,'(=')
+                    #print answer
+                    self.device.status = int(answer[0])
+                    self.message = answer[2:]
+                    self.device.save()
+                    return #self.device.status
+                def update_from_file(self, parameters):
+                    self.dict_to_parms(parameters)
+                    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)])
  No newline at end of file

apps/jars/urls.py +2 0

             from django.conf.urls import url
             urlpatterns = (
                 url(r'^(?P<id_conf>-?\d+)/$', 'apps.jars.views.jars_conf', name='url_jars_conf'),
                 url(r'^(?P<id_conf>-?\d+)/edit/$', 'apps.jars.views.jars_conf_edit', name='url_edit_jars_conf'),
                 url(r'^(?P<conf_id>-?\d+)/new_filter/$', 'apps.jars.views.new_filter', name='url_new_jars_filter'),
                 url(r'^(?P<conf_id>-?\d+)/view_filter/(?P<filter_id>-?\d+)/$', 'apps.jars.views.view_filter', name='url_jars_filter'),
                 url(r'^(?P<conf_id>-?\d+)/view_filter/(?P<filter_id>-?\d+)/edit$', 'apps.jars.views.edit_filter', name='url_edit_jars_filter'),
+                url(r'^(?P<conf_id>-?\d+)/import/$', 'apps.jars.views.import_file', name='url_import_jars_conf'),
+                url(r'^(?P<conf_id>-?\d+)/read/$', 'apps.jars.views.read_conf', name='url_read_jars_conf'),
             )

apps/jars/views.py +77 -5

             from django.shortcuts import render_to_response
             from django.template import RequestContext
             from django.shortcuts import redirect, render, get_object_or_404
             from django.contrib import messages
             from apps.main.models import Device
             from apps.main.views import sidebar
             from .models import JARSConfiguration, JARSfilter
-            from .forms import JARSConfigurationForm, JARSfilterForm
+            from .forms import JARSConfigurationForm, JARSfilterForm, JARSImportForm
             # Create your views here.
             def jars_conf(request, id_conf):
                 conf = get_object_or_404(JARSConfiguration, pk=id_conf)
                 ip=conf.device.ip_address
                 port=conf.device.port_address
                 kwargs = {}
                 kwargs['status'] = conf.device.get_status_display()
                 kwargs['dev_conf'] = conf
                 kwargs['dev_conf_keys'] = ['name',
                                            'cards_number', 'channels_number', 'channels',
-                                           'rd_directory', 'raw_data_blocks', 'data_type',
+                                           'rd_directory', 'pd_directory',
-                                           'acq_profiles', 'profiles_block', 'fftpoints',
+                                           'data_type',
+                                           'acq_profiles', 'profiles_block', 'ftp_interval', 'fftpoints',
+                                           'cohe_integr_str',
                                            'incohe_integr', 'cohe_integr', 'filter', 'spectral_number',
                                            'spectral', 'create_directory', 'include_expname',
-                                           'acq_link', 'view_raw_data', 'save_ch_dc',]
+                                           'save_ch_dc', 'save_data']
                 kwargs['title'] = 'JARS Configuration'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Edit Configuration'
-                kwargs['no_play'] = True
+                #kwargs['no_play'] = True
+                kwargs['only_stop'] = True
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'jars_conf.html', kwargs)
             def jars_conf_edit(request, id_conf):
                 conf = get_object_or_404(JARSConfiguration, pk=id_conf)
                 if request.method=='GET':
                     form = JARSConfigurationForm(instance=conf)
                 if request.method=='POST':
                     form = JARSConfigurationForm(request.POST, instance=conf)
                     if form.is_valid():
                         conf = form.save(commit=False)
                         conf.save()
                         return redirect('url_jars_conf', id_conf=conf.id)
                         ##ERRORS
                 kwargs = {}
                 kwargs['filter_id'] = conf.filter.id
                 kwargs['id_dev'] = conf.id
                 kwargs['form'] = form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Save'
                 return render(request, 'jars_conf_edit.html', kwargs)
+            def import_file(request, conf_id):
+                conf = get_object_or_404(JARSConfiguration, pk=conf_id)
+                if request.method=='POST':
+                    form = JARSImportForm(request.POST, request.FILES)
+                    if form.is_valid():
+                        try:
+                            parms = conf.import_from_file(request.FILES['file_name'])
+                            if parms:
+                                conf.update_from_file(parms)
+                                messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name'])
+                                return redirect(conf.get_absolute_url_edit())
+                        except Exception as e:
+                            messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], e))
+                else:
+                    messages.warning(request, 'Your current configuration will be replaced')
+                    form = JARSImportForm()
+                kwargs = {}
+                kwargs['form'] = form
+                kwargs['title'] = 'JARS Configuration'
+                kwargs['suptitle'] = 'Import file'
+                kwargs['button'] = 'Upload'
+                kwargs['previous'] = conf.get_absolute_url()
+                return render(request, 'jars_import.html', kwargs)
+            def read_conf(request, conf_id):
+                conf   = get_object_or_404(JARSConfiguration, pk=conf_id)
+                #filter = get_object_or_404(JARSfilter, pk=filter_id)
+                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 = JARSConfigurationForm(initial=parms, instance=conf)
+                if request.method=='POST':
+                    form = JARSConfigurationForm(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['filter_id'] = conf.filter.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, 'jars_conf_edit.html', kwargs)
             def view_filter(request, conf_id, filter_id):
                 conf = get_object_or_404(JARSConfiguration, pk=conf_id)
                 filter = get_object_or_404(JARSfilter, pk=filter_id)
                 filter_parms       = eval(conf.filter_parms)
                 filter.name        = filter_parms['name']
                 filter.clock       = filter_parms['clock']
                 filter.mult        = filter_parms['mult']
                 filter.fch         = filter_parms['fch']
                 filter.fch_decimal = filter_parms['fch_decimal']
                 filter.filter_fir  = filter_parms['filter_fir']
                 filter.filter_2    = filter_parms['filter_2']
                 filter.filter_5    = filter_parms['filter_5']
                 filter.speed       = filter_parms['speed']
                 kwargs = {}
                 kwargs['conf']          = conf
                 kwargs['filter']        = filter
                 kwargs['dev_conf']      = filter
                 kwargs['dev_conf_keys'] = ['name', 'clock',
                                            'mult', 'fch', 'fch_decimal',
                                            'filter_fir', 'filter_2',
                                            'filter_5', 'speed']
                 kwargs['title']         = 'Filter View'
                 kwargs['suptitle']      = 'Details'
                 kwargs['button']        = 'SI'
                 kwargs['edit_button']   = 'Edit Filter'
                 kwargs['add_button']    = 'New Filter'
                 return render(request, 'jars_filter.html', kwargs)
             def edit_filter(request, conf_id, filter_id):
                 conf = get_object_or_404(JARSConfiguration, pk=conf_id)
                 filter_parms = eval(conf.filter_parms)
                 if filter_id:
                     filter = get_object_or_404(JARSfilter, pk=filter_id)
                 if request.method=='GET':
                     form = JARSfilterForm(initial=filter_parms)
                 if request.method=='POST':
                     parms = {}
                     parms['name']        = request.POST['name']
                     parms['clock']       = request.POST['clock']
                     parms['mult']        = request.POST['mult']
                     parms['fch']         = request.POST['fch']
                     parms['fch_decimal'] = request.POST['fch_decimal']
                     parms['filter_fir'] = request.POST['filter_fir']
                     parms['filter_2']   = request.POST['filter_2']
                     parms['filter_5']   = request.POST['filter_5']
                     parms['speed']      = request.POST['speed']
                     conf.filter_parms = parms
                     conf.save()
                     #form = JARSfilterForm(request.POST)
                     #form = JARSfilterForm(request.POST, instance=filter)
                     #if form.is_valid():
                         #form.save()
                     #    messages.success(request, 'JARS Filter successfully updated')
                     #    return redirect('url_jars_filter', conf.id, filter.id)
                     return redirect('url_jars_filter', conf.id, filter.id)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = conf.name
                 kwargs['suptitle'] = 'Edit Filter'
                 kwargs['button'] = 'Save'
                # kwargs['previous'] = conf.get_absolute_url_edit()
                 kwargs['dev_conf'] = conf
                 return render(request, 'jars_filter_edit.html', kwargs)
             def new_filter(request, conf_id):
                 conf = get_object_or_404(JARSConfiguration, pk=conf_id)
                 if request.method=='GET':
                     form = JARSfilterForm()
                 if request.method=='POST':
                     form = JARSfilterForm(request.POST)
                     if form.is_valid():
                         form.save()
                         new_filter  = get_object_or_404(JARSfilter, name=request.POST['name'])
                         conf.filter = new_filter
                         conf.add_parms_to_filter()
                         messages.success(request, 'New JARS Filter successfully created')
                         return redirect('url_edit_jars_conf', id_conf=conf.id)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'New Filter'
                 kwargs['suptitle'] = ''
                 kwargs['button'] = 'Create'
                # kwargs['previous'] = conf.get_absolute_url_edit()
                 kwargs['dev_conf'] = conf
                 return render(request, 'jars_new_filter.html', kwargs)

apps/main/models.py +10 0

             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from datetime import datetime
             from django.db import models
             from polymorphic import PolymorphicModel
             from django.core.urlresolvers import reverse
             CONF_STATES = (
                              (0, 'Disconnected'),
                              (1, 'Connected'),
                              (2, 'Running'),
                          )
             EXP_STATES = (
                              (0,'Error'),                 #RED
                              (1,'Configured'),            #BLUE
                              (2,'Running'),               #GREEN
                              (3,'Waiting'),               #YELLOW
                              (4,'Not Configured'),        #WHITE
                          )
             CONF_TYPES = (
                              (0, 'Active'),
                              (1, 'Historical'),
                          )
             DEV_STATES = (
                              (0, 'No connected'),
                              (1, 'Connected'),
                              (2, 'Configured'),
                              (3, 'Running'),
                          )
             DEV_TYPES = (
                             ('', 'Select a device type'),
                             ('rc', 'Radar Controller'),
                             ('rc_mix', 'Radar Controller (Mix)'),
                             ('dds', 'Direct Digital Synthesizer'),
                             ('jars', 'Jicamarca Radar Acquisition System'),
                             ('usrp', 'Universal Software Radio Peripheral'),
                             ('cgs', 'Clock Generator System'),
                             ('abs', 'Automatic Beam Switching'),
                         )
             DEV_PORTS = {
                             'rc'    : 2000,
                             'rc_mix': 2000,
                             'dds'   : 2000,
                             'jars'  : 2000,
                             'usrp'  : 2000,
                             'cgs'   : 8080,
                             'abs'   : 8080
                         }
             RADAR_STATES = (
                              (0, 'No connected'),
                              (1, 'Connected'),
                              (2, 'Configured'),
                              (3, 'Running'),
                              (4, 'Scheduled'),
                          )
             # Create your models here.
             class Location(models.Model):
                 name = models.CharField(max_length = 30)
                 description = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'db_location'
                 def __unicode__(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')
                 description = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'db_device_types'
                 def __unicode__(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 __unicode__(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 get_absolute_url(self):
                     return reverse('url_device', args=[str(self.id)])
             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 __unicode__(self):
                     if self.template:
                         return u'{} (template)'.format(self.name)
                     else:
                         return u'{}'.format(self.name)
                 def parms_to_dict(self):
                     import json
                     parameters = {}
                     exp_parameters = {}
                     experiments = Experiment.objects.filter(campaign = self)
                     i=1
                     for experiment in experiments:
                         exp_parameters['experiment-'+str(i)]  = json.loads(experiment.parms_to_dict())
                         i += 1
                     parameters['experiments'] = exp_parameters
                     parameters['end_date']    = self.end_date.strftime("%Y-%m-%d")
                     parameters['start_date']  = self.start_date.strftime("%Y-%m-%d")
                     parameters['campaign']    = self.__unicode__()
                     parameters['tags']        =self.tags
                     parameters = json.dumps(parameters, indent=2, sort_keys=False)
                     return parameters
                 def import_from_file(self, fp):
                     import os, json
                     parms = {}
                     path, ext = os.path.splitext(fp.name)
                     if ext == '.json':
                         parms = json.load(fp)
                     return parms
                 def dict_to_parms(self, parms, CONF_MODELS):
                     experiments = Experiment.objects.filter(campaign = self)
                     configurations = Configuration.objects.filter(experiment = experiments)
                     if configurations:
                         for configuration in configurations:
                             configuration.delete()
                     if experiments:
                         for experiment in experiments:
                             experiment.delete()
                     for parms_exp in parms['experiments']:
                         location = Location.objects.get(name = parms['experiments'][parms_exp]['radar'])
                         new_exp = Experiment(
                                              name        = parms['experiments'][parms_exp]['experiment'],
                                              location    = location,
                                              start_time  = parms['experiments'][parms_exp]['start_time'],
                                              end_time    = parms['experiments'][parms_exp]['end_time'],
                                              )
                         new_exp.save()
                         new_exp.dict_to_parms(parms['experiments'][parms_exp],CONF_MODELS)
                         new_exp.save()
                         self.name       = parms['campaign']
                         self.start_date = parms['start_date']
                         self.end_date   = parms['end_date']
                         self.tags       = parms['tags']
                         self.experiments.add(new_exp)
                         self.save()
                     return self
                 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)
                 start_time = models.TimeField(default='00:00:00')
                 end_time = models.TimeField(default='23:59:59')
                 status = models.PositiveSmallIntegerField(default=0, choices=EXP_STATES)
                 class Meta:
                     db_table = 'db_experiments'
                     ordering = ('template', 'name')
                 def __unicode__(self):
                     if self.template:
                         return u'%s (template)' % (self.name)
                     else:
                         return u'%s' % (self.name)
                 @property
                 def radar_system(self):
                     return self.location
                 def clone(self, **kwargs):
                     confs = Configuration.objects.filter(experiment=self, type=0)
                     self.pk = None
                     self.name = '{} [{:%Y/%m/%d}]'.format(self.name, datetime.now())
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     for conf in confs:
                         conf.clone(experiment=self, template=False)
                     return self
                 def get_status(self):
                     configurations =  Configuration.objects.filter(experiment=self)
                     exp_status=[]
                     for conf in configurations:
                         print conf.status_device()
                         exp_status.append(conf.status_device())
                     if not exp_status: #No Configuration
                         self.status = 4
                         self.save()
                         return
                     total = 1
                     for e_s in exp_status:
                         total = total*e_s
                     if total == 0:                      #Error
                         status = 0
                     elif total == (3**len(exp_status)): #Running
                         status = 2
                     else:
                         status = 1                      #Configurated
                     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 get_absolute_url(self):
                     return reverse('url_experiment', args=[str(self.id)])
                 def parms_to_dict(self):
                     import json
                     configurations = Configuration.objects.filter(experiment=self)
                     conf_parameters = {}
                     parameters={}
                     for configuration in configurations:
                         if 'cgs' in configuration.device.device_type.name:
                             conf_parameters['cgs'] = configuration.parms_to_dict()
                         if 'dds' in configuration.device.device_type.name:
                             conf_parameters['dds'] = configuration.parms_to_dict()
                         if 'rc' in configuration.device.device_type.name:
                             conf_parameters['rc'] = configuration.parms_to_dict()
                         if 'jars' in configuration.device.device_type.name:
                             conf_parameters['jars'] = configuration.parms_to_dict()
                         if 'usrp' in configuration.device.device_type.name:
                             conf_parameters['usrp'] = configuration.parms_to_dict()
                         if 'abs' in configuration.device.device_type.name:
                             conf_parameters['abs'] = configuration.parms_to_dict()
                     parameters['configurations'] = conf_parameters
                     parameters['end_time']       = self.end_time.strftime("%H:%M:%S")
                     parameters['start_time']     = self.start_time.strftime("%H:%M:%S")
                     parameters['radar']          = self.radar_system.name
                     parameters['experiment']     = self.name
                     parameters = json.dumps(parameters, indent=2)
                     return parameters
                 def import_from_file(self, fp):
                     import os, json
                     parms = {}
                     path, ext = os.path.splitext(fp.name)
                     if ext == '.json':
                         parms = json.load(fp)
                     return parms
                 def dict_to_parms(self, parms, CONF_MODELS):
                     configurations = Configuration.objects.filter(experiment=self)
                     if configurations:
                                 for configuration in configurations:
                                     configuration.delete()
                     for conf_type in parms['configurations']:
                                 #--For ABS Device:
                                 #--For USRP Device:
                                 #--For JARS Device:
+                                if conf_type == 'jars':
+                                    device = get_object_or_404(Device, pk=parms['configurations']['jars']['device_id'])
+                                    DevConfModel = CONF_MODELS[conf_type]
+                                    confjars_form = DevConfModel(
+                                                              experiment = self,
+                                                              name = 'JARS',
+                                                              device=device,
+                                                              )
+                                    confjars_form.dict_to_parms(parms['configurations']['jars'])
+                                    confjars_form.save()
                                 #--For RC Device:
                                 if conf_type == 'rc':
                                     device = get_object_or_404(Device, pk=parms['configurations']['rc']['device_id'])
                                     DevConfModel = CONF_MODELS[conf_type]
                                     confrc_form = DevConfModel(
                                                               experiment = self,
                                                               name = 'RC',
                                                               device=device,
                                                               )
                                     confrc_form.dict_to_parms(parms['configurations']['rc'])
                                     confrc_form.save()
                                 #--For DDS Device:
                                 if conf_type == 'dds':
                                     device = get_object_or_404(Device, pk=parms['configurations']['dds']['device_id'])
                                     DevConfModel = CONF_MODELS[conf_type]
                                     confdds_form = DevConfModel(
                                                               experiment = self,
                                                               name = 'DDS',
                                                               device=device,
                                                               )
                                     confdds_form.dict_to_parms(parms['configurations']['dds'])
                                     confdds_form.save()
                                 #--For CGS Device:
                                 if conf_type == 'cgs':
                                     device = get_object_or_404(Device, pk=parms['configurations']['cgs']['device_id'])
                                     DevConfModel = CONF_MODELS[conf_type]
                                     confcgs_form = DevConfModel(
                                                               experiment = self,
                                                               name = 'CGS',
                                                               device=device,
                                                               )
                                     confcgs_form.dict_to_parms(parms['configurations']['cgs'])
                                     confcgs_form.save()
                     location = Location.objects.get(name = parms['radar'])
                     self.name       = parms['experiment']
                     self.location   = location
                     self.start_time = parms['start_time']
                     self.end_time   = parms['end_time']
                     self.save()
                     return self
                 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)])
             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 __unicode__(self):
                     device = '{}:'.format(self.device.device_type.name.upper())
                     if 'mix' in self._meta.get_all_field_names():
                         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 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):
                     parameters = {}
                     for key in self.__dict__.keys():
                         parameters[key] = getattr(self, key)
                     return parameters
                 def parms_to_text(self):
                     raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
                     return ''
                 def parms_to_binary(self):
                     raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
                     return ''
                 def dict_to_parms(self, parameters):
                     if type(parameters) != type({}):
                         return
                     for key in parameters.keys():
                         setattr(self, key, parameters[key])
                 def export_to_file(self, format="json"):
                     import json
                     content_type = ''
                     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):
                     import os, json
                     parms = {}
                     path, ext = os.path.splitext(fp.name)
                     if ext == '.json':
                         parms = json.load(fp)
                     return parms
                 def status_device(self):
                     raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
                     return None
                 def stop_device(self):
                     raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
                     return None
                 def start_device(self):
                     raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
                     return None
                 def write_device(self, parms):
                     raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
                     return None
                 def read_device(self):
                     raise NotImplementedError, "This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper()
                     return None
                 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/templates/dev_conf.html +3 -1

             {% extends "base.html" %}
             {% load bootstrap3 %}
             {% load static %}
             {% load main_tags %}
             {% block search-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="{{ dev_conf.get_absolute_url_edit }}"><span class="glyphicon glyphicon-pencil" aria-hidden="true"></span> Edit</a></li>
                 <li><a href="{% url 'url_delete_dev_conf' dev_conf.id %}"><span class="glyphicon glyphicon-remove" aria-hidden="true"></span> Delete</a></li>
                 <li><a href="{{ dev_conf.get_absolute_url_import }}"><span class="glyphicon glyphicon-import" aria-hidden="true"></span> Import </a></li>
                 <li><a href="{{ dev_conf.get_absolute_url_export }}"><span class="glyphicon glyphicon-export" aria-hidden="true"></span> Export </a></li>
                 {% block extra-menu-actions %}
                 {% endblock %}
                 <li><a>----------------</a></li>
                 <li><a href="{{ dev_conf.get_absolute_url_status }}"><span class="glyphicon glyphicon-refresh" aria-hidden="true"></span> Status</a></li>
                 {% if not no_play %}
-                <li><a href="{{ dev_conf.get_absolute_url_start}}"><span class="glyphicon glyphicon-play" aria-hidden="true"></span> Start</a></li>
+                    {% if not only_stop %}
+                        <li><a href="{{ dev_conf.get_absolute_url_start}}"><span class="glyphicon glyphicon-play" aria-hidden="true"></span> Start</a></li>
+                    {% endif %}
                 <li><a href="{{ dev_conf.get_absolute_url_stop }}"><span class="glyphicon glyphicon-stop" aria-hidden="true"></span> Stop</a></li>
                 {% endif %}
                 <li><a href="{{ dev_conf.get_absolute_url_write }}"><span class="glyphicon glyphicon-download" aria-hidden="true"></span> Write</a></li>
                 <li><a href="{{ dev_conf.get_absolute_url_read }}"><span class="glyphicon glyphicon-upload" aria-hidden="true"></span> Read</a></li>
               </ul>
             </span>
             {% endblock %}
             <table class="table table-bordered">
             	<tr>
             		<th>Status</th>
             		<td>{%if status != "No connected" %} <span class="glyphicon glyphicon-ok-circle text-success" aria-hidden="true"></span> {{status}}  {% else %} <span class="glyphicon glyphicon-remove-circle text-danger" aria-hidden="true"></span> {{status}} {% endif %}</td>
             	</tr>
             	{% for key in dev_conf_keys %}
             	<tr>
             		<th>{% get_verbose_field_name dev_conf key %}</th>
             		<td>{{dev_conf|attr:key}}</td>
             	</tr>
             	{% endfor %}
             </table>
             {% block extra-content %}
             {% endblock %}
             {% endblock %}
             {% block sidebar%}
             {% include "sidebar_devices.html" %}
             {% endblock %}
             {% block extra-js%}
             <script type="text/javascript">
               $("#bt_edit").click(function() {
                 document.location = "{{ dev_conf.get_absolute_url_edit }}";
               });
               $("#bt_read").click(function() {
                 document.location = "{{ dev_conf.get_absolute_url_read }}";
               });
               $("#bt_write").click(function() {
                 document.location = "{{ dev_conf.get_absolute_url_write }}";
               });
               $("#bt_import").click(function() {
                 document.location = "{{ dev_conf.get_absolute_url_import }}";
               });
               $("#bt_export").click(function() {
                 document.location = "{{ dev_conf.get_absolute_url_export }}";
               });
             </script>
             {% endblock %}

apps/main/templates/experiment_summary.html +60 -46

             {% 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>
                 {% block extra-menu-actions %}
                 {% endblock %}
                 <li><a>----------------</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=#><span class="glyphicon glyphicon-check" aria-hidden="true"></span> Verify Parameters</a></li>
               </ul>
             </span> -->
             {% endblock %}
             <table class="table table-bordered">
             {% for key in experiment_keys %}
             <tr><th>{{key|title}}</th><td>{{experiment|attr:key}}</td></tr>
             {% endfor %}
             </table>
-            <div class="">
-            <h4 class="panel-title"><b> Parameters </b></h4>
-            <br>
-            </div>
-            <table class="table table-bordered">
             {% for configuration in configurations %}
             	{% if configuration.device.device_type.name == 'dds' %}
-            		<!--<h4 class="panel-title">  </h4>-->
+            		<div class="">
-            		<tr><th>dds</th><td>(=</td></tr>
+            		<h4 class="panel-title"><b> DDS </b></h4>
+            		<br>
+            		</div>
+            		<table class="table table-bordered">
+            			<!--<h4 class="panel-title">  </h4>-->
+            			<tr><th>dds</th><td>(=</td></tr>
+            		</table>
             	{% endif %}
             	{% if configuration.device.device_type.name == 'rc' %}
-            		<!--<h4 class="panel-title">  </h4>-->
+            		<div class="">
-            		<tr><th>IPP(km)</th><td>{{experiment_data.configurations.rc.ipp}}</td></tr>
+            		<h4 class="panel-title"><b> CR </b></h4>
-            		<tr><th>NTX</th><td>{{experiment_data.configurations.rc.ntx}}</td></tr>
+            		<br>
-            		<tr><th>TX</th><td>{{tx}}</td></tr>
+            		</div>
-            		<tr><th>Code</th><td>{{code}}</td></tr>
-            		<tr><th>Sampling Window</th><td>{{window|linebreaks}}</td></tr>
-            	{% endif %}
-            	{% if configuration.device.device_type.name == 'rc_mix' %}
+            		<table class="table table-bordered">
-            		<!--<h4 class="panel-title">  </h4>-->
+            			<!--<h4 class="panel-title">  </h4>-->
-            		<tr><th>rc_mix</th><td>(=</td></tr>
+            			<tr><th>IPP(km)</th><td>{{experiment_data.configurations.rc.ipp}}</td></tr>
+            			<tr><th>NTX</th><td>{{experiment_data.configurations.rc.ntx}}</td></tr>
+            			<tr><th>TX</th><td>{{tx}}</td></tr>
+            			<tr><th>Code</th><td>{{code}}</td></tr>
+            			<tr><th>Sampling Window</th><td>{{window|linebreaks}}</td></tr>
+            		</table>
             	{% endif %}
             	{% if configuration.device.device_type.name == 'jars' %}
-            		<!--<h4 class="panel-title"> JARS </h4>-->
+            		<div class="">
-            		<tr><th>Data Type</th><td>{{exp_type}}</td></tr>
+            		<h4 class="panel-title"><b> JARS </b></h4>
-            		<tr><th># Channels</th><td>{{configuration.channels_number}}</td></tr>
+            		<br>
-            		<tr><th>Coh Int</th><td>{{configuration.cohe_integr}}</td></tr>
+            		</div>
-            		<tr><th>FFT Points</th><td>{{configuration.fftpoints}}</td></tr>
-            		{% if exp_type == 'PDATA'%}
-            			<tr><th>Inc Int</th><td>{{configuration.incohe_integr}}</td></tr>
-            			<tr><th>Spec. Comb.</th><td>{{configuration.spectral}}</td></tr>
-            		{% endif %}
-            		<tr><th>Acq Prof</th><td>{{configuration.acq_profiles}}</td></tr>
-            		<tr><th>Prof x Block</th><td>{{configuration.profiles_block}}</td></tr>
-            		<tr><th>Block x File</th><td>(=</td></tr>
-            	{% endif %}
-            	{% if configuration.device.device_type.name == 'usrp' %}
-            		<!--<h4 class="panel-title">  </h4>-->
-            		<tr><th>usrp</th><td>(=</td></tr>
-            	{% endif %}
-            	{% if configuration.device.device_type.name == 'cgs' %}
-            		<!--<h4 class="panel-title"> CGS </h4>-->
-            		<!--<tr><th>Frequency 0</th><td>{{configuration.freq0}}</td></tr>-->
-            		<!--<tr><th>Frequency 1</th><td>{{configuration.freq1}}</td></tr>-->
-            		<!--<tr><th>Frequency 2</th><td>{{configuration.freq2}}</td></tr>-->
-            		<!--<tr><th>Frequency 3</th><td>{{configuration.freq3}}</td></tr>-->
-            	{% endif %}
-            	{% if configuration.device.device_type.name == 'abs' %}
+            		<table class="table table-bordered">
-            		<!--<h4 class="panel-title">  </h4>-->
+            			<!--<h4 class="panel-title"> JARS </h4>-->
-            		<tr><th>abs</th><td>(=</td></tr>
+            			<tr><th>Data Type</th><td>{{exp_type}}</td></tr>
+            			<tr><th># Channels</th><td>{{configuration.channels_number}}</td></tr>
+            			<tr><th>Coh Int</th><td>{{configuration.cohe_integr}}</td></tr>
+            			<tr><th>FFT Points</th><td>{{configuration.fftpoints}}</td></tr>
+            			{% if exp_type == 'PDATA'%}
+            				<tr><th>Inc Int</th><td>{{configuration.incohe_integr}}</td></tr>
+            				<tr><th>Spec. Comb.</th><td>{{configuration.spectral}}</td></tr>
+            			{% endif %}
+            			<tr><th>Acq Prof</th><td>{{configuration.acq_profiles}}</td></tr>
+            			<tr><th>Prof x Block</th><td>{{configuration.profiles_block}}</td></tr>
+            			<tr><th>Block x File</th><td>{{ configuration.raw_data_blocks }}</td></tr>
+            		</table>
             	{% endif %}
             {% endfor %}
+            <div class="">
+            <h4 class="panel-title"><b> Extra Parameters </b></h4>
+            <br>
+            </div>
+            <table class="table table-bordered">
+            {% if jars_conf %}
+            		<tr><th>Rate (MB/h)</th><td>{{ rate }}</td></tr>
+            {% endif %}
+            {% if dds_conf %}
+            		<tr><th>Vmax (m/s)</th><td>{{ rate }}</td></tr>
+            {% endif %}
             </table>
             <div class="pull-right">
             <button type="button" class="btn btn-primary" id="bt_back">Back</button>
             <button type="button" class="btn btn-primary" id="bt_verify">Verify Parameters</button>
             </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_back").click(function() {
             	    document.location = "{% url 'url_experiment' experiment.id%}";
               });
+              $("#bt_verify").click(function() {
+            	    document.location = "{% url 'url_verify_experiment' experiment.id%}";
+              });
             </script>
             {% endblock %}

apps/main/urls.py +1 0

             from django.conf.urls import url
             urlpatterns = (
                 url(r'^location/new/$', 'apps.main.views.location_new', name='url_add_location'),
                 url(r'^location/$', 'apps.main.views.locations', name='url_locations'),
                 url(r'^location/(?P<id_loc>-?\d+)/$', 'apps.main.views.location', name='url_location'),
                 url(r'^location/(?P<id_loc>-?\d+)/edit/$', 'apps.main.views.location_edit', name='url_edit_location'),
                 url(r'^location/(?P<id_loc>-?\d+)/delete/$', 'apps.main.views.location_delete', name='url_delete_location'),
                 url(r'^device/new/$', 'apps.main.views.device_new', name='url_add_device'),
                 url(r'^device/$', 'apps.main.views.devices', name='url_devices'),
                 url(r'^device/(?P<id_dev>-?\d+)/$', 'apps.main.views.device', name='url_device'),
                 url(r'^device/(?P<id_dev>-?\d+)/edit/$', 'apps.main.views.device_edit', name='url_edit_device'),
                 url(r'^device/(?P<id_dev>-?\d+)/delete/$', 'apps.main.views.device_delete', name='url_delete_device'),
                 url(r'^campaign/new/$', 'apps.main.views.campaign_new', name='url_add_campaign'),
                 url(r'^campaign/$', 'apps.main.views.campaigns', name='url_campaigns'),
                 url(r'^campaign/(?P<id_camp>-?\d+)/$', 'apps.main.views.campaign', name='url_campaign'),
                 url(r'^campaign/(?P<id_camp>-?\d+)/edit/$', 'apps.main.views.campaign_edit', name='url_edit_campaign'),
                 url(r'^campaign/(?P<id_camp>-?\d+)/delete/$', 'apps.main.views.campaign_delete', name='url_delete_campaign'),
                 url(r'^campaign/(?P<id_camp>-?\d+)/export/$', 'apps.main.views.campaign_export', name='url_export_campaign'),
                 url(r'^campaign/(?P<id_camp>-?\d+)/import/$', 'apps.main.views.campaign_import', name='url_import_campaign'),
                 url(r'^experiment/new/$', 'apps.main.views.experiment_new', name='url_add_experiment'),
                 url(r'^experiment/$', 'apps.main.views.experiments', name='url_experiments'),
                 url(r'^experiment/(?P<id_exp>-?\d+)/$', 'apps.main.views.experiment', name='url_experiment'),
                 url(r'^experiment/(?P<id_exp>-?\d+)/edit/$', 'apps.main.views.experiment_edit', name='url_edit_experiment'),
                 url(r'^experiment/(?P<id_exp>-?\d+)/delete/$', 'apps.main.views.experiment_delete', name='url_delete_experiment'),
                 url(r'^experiment/(?P<id_exp>-?\d+)/export/$', 'apps.main.views.experiment_export', name='url_export_experiment'),
                 url(r'^experiment/(?P<id_exp>-?\d+)/import/$', 'apps.main.views.experiment_import', name='url_import_experiment'),
                 url(r'^experiment/(?P<id_exp>-?\d+)/mix/$', 'apps.main.views.experiment_mix', name='url_mix_experiment'),
                 url(r'^experiment/(?P<id_exp>-?\d+)/mix/delete/$', 'apps.main.views.experiment_mix_delete', name='url_delete_mix_experiment'),
                 url(r'^experiment/(?P<id_exp>-?\d+)/summary/$', 'apps.main.views.experiment_summary', name='url_sum_experiment'),
+                url(r'^experiment/(?P<id_exp>-?\d+)/verify/$', 'apps.main.views.experiment_verify', name='url_verify_experiment'),
                 url(r'^experiment/(?P<id_exp>-?\d+)/new_dev_conf/$', 'apps.main.views.dev_conf_new', name='url_add_dev_conf'),
                 url(r'^experiment/(?P<id_exp>-?\d+)/new_dev_conf/(?P<id_dev>-?\d+)/$', 'apps.main.views.dev_conf_new', name='url_add_dev_conf'),
                 url(r'^dev_conf/$', 'apps.main.views.dev_confs', name='url_dev_confs'),
                 url(r'^dev_conf/(?P<id_conf>-?\d+)/$', 'apps.main.views.dev_conf', name='url_dev_conf'),
                 url(r'^dev_conf/(?P<id_conf>-?\d+)/edit/$', 'apps.main.views.dev_conf_edit', name='url_edit_dev_conf'),
                 url(r'^dev_conf/(?P<id_conf>-?\d+)/delete/$', 'apps.main.views.dev_conf_delete', name='url_delete_dev_conf'),
                 url(r'^dev_conf/(?P<id_conf>-?\d+)/write/$', 'apps.main.views.dev_conf_write', name='url_write_dev_conf'),
                 url(r'^dev_conf/(?P<id_conf>-?\d+)/read/$', 'apps.main.views.dev_conf_read', name='url_read_dev_conf'),
                 url(r'^dev_conf/(?P<id_conf>-?\d+)/import/$', 'apps.main.views.dev_conf_import', name='url_import_dev_conf'),
                 url(r'^dev_conf/(?P<id_conf>-?\d+)/export/$', 'apps.main.views.dev_conf_export', name='url_export_dev_conf'),
                 url(r'^dev_conf/(?P<id_conf>-?\d+)/start/$', 'apps.main.views.dev_conf_start', name='url_start_dev_conf'),
                 url(r'^dev_conf/(?P<id_conf>-?\d+)/stop/$', 'apps.main.views.dev_conf_stop', name='url_stop_dev_conf'),
                 url(r'^dev_conf/(?P<id_conf>-?\d+)/status/$', 'apps.main.views.dev_conf_status', name='url_status_dev_conf'),
                 url(r'^operation/$', 'apps.main.views.operation', name='url_operation'),
                 url(r'^operation/(?P<id_camp>-?\d+)/$', 'apps.main.views.operation', name='url_operation'),
                 url(r'^operation/search/$', 'apps.main.views.operation_search', name='url_operation_search'),
                 url(r'^operation/search/(?P<id_camp>-?\d+)/$', 'apps.main.views.operation_search', name='url_operation_search'),
                 url(r'^operation/(?P<id_camp>-?\d+)/radar/(?P<id_radar>-?\d+)/play/$', 'apps.main.views.radar_play', name='url_radar_play'),
                 url(r'^operation/(?P<id_camp>-?\d+)/radar/(?P<id_radar>-?\d+)/stop/$', 'apps.main.views.radar_stop', name='url_radar_stop'),
                 url(r'^operation/(?P<id_camp>-?\d+)/radar/(?P<id_radar>-?\d+)/refresh/$', 'apps.main.views.radar_refresh', name='url_radar_refresh'),
             )

apps/main/views.py +146 -4

             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 datetime import datetime
             import urllib
             from .forms import CampaignForm, ExperimentForm, DeviceForm, ConfigurationForm, LocationForm, UploadFileForm, DownloadFileForm, OperationForm, NewForm
             from .forms import OperationSearchForm, FilterForm
             from apps.cgs.forms import CGSConfigurationForm
             from apps.jars.forms import JARSConfigurationForm
             from apps.usrp.forms import USRPConfigurationForm
             from apps.abs.forms import ABSConfigurationForm
             from apps.rc.forms import RCConfigurationForm, RCMixConfigurationForm
             from apps.dds.forms import DDSConfigurationForm
             from .models import Campaign, Experiment, Device, Configuration, Location, RunningExperiment
             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 django.http.request import QueryDict
+            #from __builtin__ import False
             # Create your views here.
             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 = {}
                 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'
                 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)
             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)
             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)
             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'
                 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)
             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)
             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)
             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)
             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['form'] = form
                 filters.pop('page', None)
                 kwargs['q'] = urllib.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)
             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)
             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)
             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)
             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(content)
                 return response
             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():
                         parms = campaign.import_from_file(request.FILES['file'])
                         if parms:
                             parms['name'] = parms['campaign']
                             new_camp = campaign.dict_to_parms(parms, 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['form'] = form
                 filters.pop('page', None)
                 kwargs['q'] = urllib.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', '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)
             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)
                     print form.data
                     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)
             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)
             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)
             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(content)
                 return response
             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():
                         parms = experiment.import_from_file(request.FILES['file'])
                         if parms:
                             new_exp = experiment.dict_to_parms(parms, 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)
             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)
             def experiment_mix_delete(request, id_exp):
                 conf = RCConfiguration.objects.get(experiment=id_exp, mix=True)
                 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):
                 import json
+                import ast
                 experiment      = get_object_or_404(Experiment, pk=id_exp)
                 experiment_data = json.loads(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'] = 'Experiment Summary'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Verify Parameters'
+                jars_conf = False
+                rc_conf   = False
                 for configuration in configurations:
+                    #-------------------- JARS -----------------------:
                     if configuration.device.device_type.name == 'jars':
-                        kwargs['exp_type'] =  EXPERIMENT_TYPE[configuration.exp_type][1]
+                        jars_conf = True
+                        kwargs['jars_conf'] = jars_conf
+                        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
+                    #--------------------- RC ----------------------:
                     if configuration.device.device_type.name == 'rc':
+                        rc_conf = True
+                        kwargs['rc_conf'] = rc_conf
                         rc_lines = experiment_data['configurations']['rc']['lines']
+                        ipp = configuration.ipp
                         if experiment_data['configurations']['rc']['mix'] == 'True':
                             tx = ''
                             code = ''
                             window = ''
                         else:
                             code = rc_lines[3]['code']
                             window_data = rc_lines[6]['params'][0]
                             h0  = str(window_data['first_height'])
                             dh  = str(window_data['resolution'])
                             nsa = str(window_data['number_of_samples'])
                             window = 'Ho='+h0+'km\nDH='+dh+'km\nNSA='+nsa
                             tx = ''
                             if float(rc_lines[1]['delays']) == 0:
                                 tx = rc_lines[2]['pulse_width']
                             elif float(rc_lines[2]['delays']) == 0:
                                 tx = rc_lines[1]['pulse_width']
                             else:
                                 tx = rc_lines[1]['pulse_width']+' | '+rc_lines[2]['pulse_width']
                         kwargs['tx']   = tx
                         kwargs['code'] = code
                         kwargs['window'] = window
+                    #-------------------- DDS -----------------------:
+                    if configuration.device.device_type.name == 'dds':
+                        dds_conf = True
+                        kwargs['dds_conf'] = dds_conf
+                    #------ RC & JARS ------:
+                    ipp = 937.5 #
+                    nsa = 200#
+                    dh = 1.5             #
+                    channels_number = 5 #
+                    if rc_conf and jars_conf:
+                        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
+                        ipps           = (ipp*pow(10,-6))/0.15
+                        GB             = 1048576.0*1024.0
+                        Hour           = 3600
+                        rate           = b/ipps
+                        rate           = rate *(1/GB)*(Hour)
+                        kwargs['rate'] = str(rate)+" GB/h"
+                    else:
+                        kwargs['rate'] = ''
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(experiment=experiment))
                 return render(request, 'experiment_summary.html', kwargs)
+            def experiment_verify(request, id_exp):
+                import json
+                import ast
+                experiment      = get_object_or_404(Experiment, pk=id_exp)
+                experiment_data = json.loads(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
+                        kwargs['jars_conf']    = jars_conf
+                        filter_parms           = configuration.filter_parms
+                        filter_parms           = ast.literal_eval(filter_parms)
+                        kwargs['filter_parms'] = filter_parms
+                        #--Sampling Frequency
+                        clock          = filter_parms['clock']
+                        filter_2       = filter_parms['filter_2']
+                        filter_5       = filter_parms['filter_5']
+                        filter_fir     = 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':
+                        rc_conf = True
+                        rc_parms = configuration.parms_to_dict()
+                        if rc_parms['mix'] == 'True':
+                            pass
+                        else:
+                            rc_lines     = rc_parms['lines']
+                            dh           = rc_lines[6]['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_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 filter_parms['clock'] != rc_parms['clock_in'] and rc_parms['clock_in'] != dds_parms['clock']:
+                        messages.warning(request, "Devices don't have the same clock.")
+                elif rc_conf and jars_conf:
+                    if filter_parms['clock'] != rc_parms['clock_in']:
+                        messages.warning(request, "Devices don't have the same clock.")
+                elif rc_conf and dds_conf:
+                    if rc_parms['clock_in'] != dds_parms['clock']:
+                        messages.warning(request, "Devices don't have the same clock.")
+                    if float(samp_freq_rc) != float(dds_parms['frequencyA']):
+                        messages.warning(request, "Devices don't have the same Frequency A.")
+                ###### SIDEBAR ######
+                kwargs.update(sidebar(experiment=experiment))
+                return render(request, 'experiment_verify.html', kwargs)
             def parse_mix_result(s):
                 values = s.split('-')
                 html = 'EXP                MOD OPE DELAY         MASK\r\n'
                 if not values or values[0] in ('', ' '):
                     return mark_safe(html)
                 for i, value in enumerate(values):
                     if not value:
                         continue
                     pk, mode, operation, delay, mask = value.split('|')
                     conf = 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'])
                 kwargs['keys'] = ['name', 'experiment', 'type', 'programmed_date']
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'List'
                 kwargs['form'] = form
                 filters.pop('page', None)
                 kwargs['q'] = urllib.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())
             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)
                         if conf.device.device_type.name=='jars':
                             conf.add_parms_to_filter()
                         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)
             def dev_conf_edit(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfModel = CONF_MODELS[conf.device.device_type.name]
                 DevConfForm = CONF_FORMS[conf.device.device_type.name]
                 dev_conf = DevConfModel.objects.get(pk=id_conf)
                 if request.method=='GET':
                     form = DevConfForm(instance=dev_conf)
                 if request.method=='POST':
                     form = DevConfForm(request.POST, instance=dev_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)
             def dev_conf_start(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfModel = CONF_MODELS[conf.device.device_type.name]
                 conf = DevConfModel.objects.get(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())
             def dev_conf_stop(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfModel = CONF_MODELS[conf.device.device_type.name]
                 conf = DevConfModel.objects.get(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)
                 DevConfModel = CONF_MODELS[conf.device.device_type.name]
                 conf = DevConfModel.objects.get(pk=id_conf)
                 if conf.status_device():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 return redirect(conf.get_absolute_url())
             def dev_conf_write(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfModel = CONF_MODELS[conf.device.device_type.name]
                 conf = DevConfModel.objects.get(pk=id_conf)
                 answer = conf.write_device()
                 conf.status_device()
                 if answer:
                     messages.success(request, conf.message)
                     #Creating a historical configuration
-                    conf.clone(type=0, template=False)
+                    conf.clone(type=1, template=False)
                     #Original configuration
                     conf = DevConfModel.objects.get(pk=id_conf)
                 else:
                     messages.error(request, conf.message)
                 return redirect(conf.get_absolute_url())
             def dev_conf_read(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfModel = CONF_MODELS[conf.device.device_type.name]
                 DevConfForm = CONF_FORMS[conf.device.device_type.name]
                 conf = DevConfModel.objects.get(pk=id_conf)
                 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)
             def dev_conf_import(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfModel = CONF_MODELS[conf.device.device_type.name]
                 DevConfForm = CONF_FORMS[conf.device.device_type.name]
                 conf = DevConfModel.objects.get(pk=id_conf)
                 if request.method == 'GET':
                     file_form = UploadFileForm()
                 if request.method == 'POST':
                     file_form = UploadFileForm(request.POST, request.FILES)
                     if file_form.is_valid():
                         parms = conf.import_from_file(request.FILES['file'])
                         if parms:
                             messages.success(request, "Parameters imported from: '%s'." %request.FILES['file'].name)
                             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))
                             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)
             def dev_conf_export(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfModel = CONF_MODELS[conf.device.device_type.name]
                 conf = DevConfModel.objects.get(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'])
                         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)
             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)
                 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 model._meta.get_all_field_names():
                         query = query | Q(tags__icontains=tags)
                     if 'name' in model._meta.get_all_field_names():
                         query = query | Q(name__icontains=tags)
                     if 'location' in model._meta.get_all_field_names():
                         query = query | Q(location__name__icontains=tags)
                     if 'device' in model._meta.get_all_field_names():
                         query = query | Q(device__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):
                 if not id_camp:
                     campaigns = Campaign.objects.all().order_by('-start_date')
                     if not campaigns:
                         kwargs = {}
                         kwargs['title'] = 'No Campaigns'
                         kwargs['suptitle'] = 'Empty'
                         return render(request, 'operation.html', kwargs)
                     id_camp = campaigns[0].id
                 campaign = get_object_or_404(Campaign, pk = id_camp)
                 if request.method=='GET':
                     form = OperationForm(initial={'campaign': campaign.id}, length = 5)
                 if request.method=='POST':
                     form = OperationForm(request.POST, initial={'campaign':campaign.id}, length = 5)
                     if form.is_valid():
                         return redirect('url_operation', id_camp=campaign.id)
                 #locations = Location.objects.filter(experiment__campaign__pk = campaign.id).distinct()
                 experiments = Experiment.objects.filter(campaign__pk=campaign.id)
                 #for exs in experiments:
                 #    exs.get_status()
                 locations= Location.objects.filter(experiment=experiments).distinct()
                 #experiments = [Experiment.objects.filter(location__pk=location.id).filter(campaign__pk=campaign.id) for location in locations]
                 kwargs = {}
                 #---Campaign
                 kwargs['campaign'] = campaign
                 kwargs['campaign_keys'] = ['name', 'start_date', 'end_date', 'tags', 'description']
                 #---Experiment
                 keys = ['id', 'name', 'start_time', 'end_time', 'status']
                 kwargs['experiment_keys'] = keys[1:]
                 kwargs['experiments'] = experiments
                 #---Radar
                 kwargs['locations'] = locations
                 #---Else
                 kwargs['title'] = 'Campaign'
                 kwargs['suptitle'] = campaign.name
                 kwargs['form'] = form
                 kwargs['button'] = 'Search'
                 kwargs['details'] = True
                 kwargs['search_button'] = True
                 return render(request, 'operation.html', kwargs)
             def operation_search(request, id_camp=None):
                 if not id_camp:
                     campaigns = Campaign.objects.all().order_by('-start_date')
                     if not campaigns:
                         return render(request, 'operation.html', {})
                     id_camp = campaigns[0].id
                 campaign = get_object_or_404(Campaign, pk = id_camp)
                 if request.method=='GET':
                     form = OperationSearchForm(initial={'campaign': campaign.id})
                 if request.method=='POST':
                     form = OperationSearchForm(request.POST, initial={'campaign':campaign.id})
                     if form.is_valid():
                         return redirect('url_operation', id_camp=campaign.id)
                 #locations = Location.objects.filter(experiment__campaign__pk = campaign.id).distinct()
                 experiments = Experiment.objects.filter(campaign__pk=campaign.id)
                 #for exs in experiments:
                 #    exs.get_status()
                 locations= Location.objects.filter(experiment=experiments).distinct()
                 form = OperationSearchForm(initial={'campaign': campaign.id})
                 kwargs = {}
                 #---Campaign
                 kwargs['campaign'] = campaign
                 kwargs['campaign_keys'] = ['name', 'start_date', 'end_date', 'tags', 'description']
                 #---Experiment
                 keys = ['id', 'name', 'start_time', 'end_time', 'status']
                 kwargs['experiment_keys'] = keys[1:]
                 kwargs['experiments'] = experiments
                 #---Radar
                 kwargs['locations'] = locations
                 #---Else
                 kwargs['title'] = 'Campaign'
                 kwargs['suptitle'] = campaign.name
                 kwargs['form'] = form
                 kwargs['button'] = 'Select'
                 kwargs['details'] = True
                 kwargs['search_button'] = False
                 return render(request, 'operation.html', kwargs)
             def radar_play(request, id_camp, id_radar):
                 campaign = get_object_or_404(Campaign, pk = id_camp)
                 radar = get_object_or_404(Location, pk = id_radar)
                 today = datetime.today()
                 now = today.time()
                 #--Clear Old Experiments From RunningExperiment Object
                 running_experiment = RunningExperiment.objects.filter(radar=radar)
                 if running_experiment:
                     running_experiment = running_experiment[0]
                     running_experiment.running_experiment.clear()
                     running_experiment.save()
                 #--If campaign datetime is ok:
                 if today >= campaign.start_date and today <= campaign.end_date:
                     experiments = Experiment.objects.filter(campaign=campaign).filter(location=radar)
                     for exp in experiments:
                         #--If experiment time is ok:
                         if now >= exp.start_time and now <= exp.end_time:
                             configurations =  Configuration.objects.filter(experiment = exp)
                             for conf in configurations:
                                 if 'cgs' in conf.device.device_type.name:
                                     conf.status_device()
                                 else:
                                     answer = conf.start_device()
                                     conf.status_device()
                                     #--Running Experiment
                                     old_running_experiment = RunningExperiment.objects.filter(radar=radar)
                                     #--If RunningExperiment element exists
                                     if old_running_experiment:
                                         old_running_experiment = old_running_experiment[0]
                                         old_running_experiment.running_experiment.add(exp)
                                         old_running_experiment.status = 3
                                         old_running_experiment.save()
                                     #--Create a new Running_Experiment Object
                                     else:
                                         new_running_experiment = RunningExperiment(
                                                                                radar = radar,
                                                                                status = 3,
                                                                                )
                                         new_running_experiment.save()
                                         new_running_experiment.running_experiment.add(exp)
                                         new_running_experiment.save()
                                     if answer:
                                         messages.success(request, conf.message)
                                         exp.status=2
                                         exp.save()
                                     else:
                                         messages.error(request, conf.message)
                         else:
                             if exp.status == 1 or exp.status == 3:
                                 exp.status=3
                                 exp.save()
                 route = request.META['HTTP_REFERER']
                 route = str(route)
                 if 'search' in route:
                     return HttpResponseRedirect(reverse('url_operation_search', args=[id_camp]))
                 else:
                     return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
             def radar_stop(request, id_camp, id_radar):
                 campaign = get_object_or_404(Campaign, pk = id_camp)
                 radar = get_object_or_404(Location, pk = id_radar)
                 experiments = Experiment.objects.filter(campaign=campaign).filter(location=radar)
                 for exp in experiments:
                     configurations =  Configuration.objects.filter(experiment = exp)
                     for conf in configurations:
                         if 'cgs' in conf.device.device_type.name:
                             conf.status_device()
                         else:
                             answer = conf.stop_device()
                             conf.status_device()
                             if answer:
                                 messages.success(request, conf.message)
                                 exp.status=1
                                 exp.save()
                             else:
                                 messages.error(request, conf.message)
                 route = request.META['HTTP_REFERER']
                 route = str(route)
                 if 'search' in route:
                     return HttpResponseRedirect(reverse('url_operation_search', args=[id_camp]))
                 else:
                     return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
             def radar_refresh(request, id_camp, id_radar):
                 campaign = get_object_or_404(Campaign, pk = id_camp)
                 radar = get_object_or_404(Location, pk = id_radar)
                 experiments = Experiment.objects.filter(campaign=campaign).filter(location=radar)
                 for exs in experiments:
                     exs.get_status()
                 route = request.META['HTTP_REFERER']
                 route = str(route)
                 if 'search' in route:
                     return HttpResponseRedirect(reverse('url_operation_search', args=[id_camp]))
                 else:
                     return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))

apps/rc/fixtures/rc_initial_data.json +1 -1

             [{"fields": {"number_of_codes": 0, "codes": "[]", "name": "None", "bits_per_code": 0}, "model": "rc.rclinecode", "pk": 1},
              {"fields": {"number_of_codes": 2, "codes": "[u'11101101', u'11100010']", "name": "COMPLEMENTARY_CODE_8", "bits_per_code": 8}, "model": "rc.rclinecode", "pk": 2},
              {"fields": {"number_of_codes": 1, "codes": "[u'1101101001000100010001111000']", "name": "BINARY_CODE_28", "bits_per_code": 28}, "model": "rc.rclinecode", "pk": 3},
              {"fields": {"number_of_codes": 2, "codes": "[u'11', u'10']", "name": "COMPLEMENTARY_CODE_2", "bits_per_code": 2}, "model": "rc.rclinecode", "pk": 4},
              {"fields": {"number_of_codes": 2, "codes": "[u'1110110111100010111011010001110111101101111000100001001011100010', u'1110110111100010111011010001110100010010000111011110110100011101']", "name": "COMPLEMENTARY_CODE_64", "bits_per_code": 64}, "model": "rc.rclinecode", "pk": 5},
              {"fields": {"number_of_codes": 1, "codes": "[u'11100010010']", "name": "BARKER11", "bits_per_code": 11}, "model": "rc.rclinecode", "pk": 6},
              {"fields": {"number_of_codes": 2, "codes": "[u'1111100110101' ]", "name": "BARKER13", "bits_per_code": 13}, "model": "rc.rclinecode", "pk": 7},
              {"fields": {"number_of_codes": 2, "codes": "[u'1101101001000100010001111000', u'0010010110111011101110000111']", "name": "BINARY_CODE_28_FLIP", "bits_per_code": 28}, "model": "rc.rclinecode", "pk": 8},
              {"fields": {"number_of_codes": 2, "codes": "[u'11101101111000101110110100011101', u'11101101111000100001001011100010']", "name": "COMPLEMENTARY_CODE_32", "bits_per_code": 32}, "model": "rc.rclinecode", "pk": 9},
              {"fields": {"number_of_codes": 128, "codes": "[u'1111000100100101', u'1011001010010111', u'1101001000100000', u'1001000110010010', u'1110001001111011', u'1010000111001001', u'1100000101111110', u'1000001011001100', u'1111101001010110', u'1011100111100100', u'1101100101010011', u'1001101011100001', u'1110100100001000', u'1010101010111010', u'1100101000001101', u'1000100110111111', u'1111010010011100', u'1011011100101110', u'1101011110011001', u'1001010000101011', u'1110011111000010', u'1010010001110000', u'1100010011000111', u'1000011101110101', u'1111111111101111', u'1011110001011101', u'1101110011101010', u'1001111101011000', u'1110110010110001', u'1010111100000011', u'1100111110110100', u'1000110000000110', u'0011111000000011', u'0111110110110001', u'0001110100000110', u'0101111010110100', u'0010110101011101', u'0110111011101111', u'0000111001011000', u'0100110111101010', u'0011010101110000', u'0111011011000010', u'0001011001110101', u'0101010111000111', u'0010011000101110', u'0110010110011100', u'0000010100101011', u'0100011010011001', u'0011101110111010', u'0111100000001000', u'0001100010111111', u'0101101100001101', u'0010100011100100', u'0110101101010110', u'0000101111100001', u'0100100001010011', u'0011000011001001', u'0111001101111011', u'0001001111001100', u'0101000001111110', u'0010001110010111', u'0110000000100101', u'0000000010010010', u'0100001100100000', u'1010110011001110', u'1110111101111100', u'1000111111001011', u'1100110001111001', u'1011111110010000', u'1111110000100010', u'1001110010010101', u'1101111100100111', u'1010011110111101', u'1110010000001111', u'1000010010111000', u'1100011100001010', u'1011010011100011', u'1111011101010001', u'1001011111100110', u'1101010001010100', u'1010100101110111', u'1110101011000101', u'1000101001110010', u'1100100111000000', u'1011101000101001', u'1111100110011011', u'1001100100101100', u'1101101010011110', u'1010001000000100', u'1110000110110110', u'1000000100000001', u'1100001010110011', u'1011000101011010', u'1111001011101000', u'1001001001011111', u'1101000111101101', u'1100100111000110', u'1000101001110100', u'1110101011000011', u'1010100101110001', u'1101101010011000', u'1001100100101010', u'1111100110011101', u'1011101000101111', u'1100001010110101', u'1000000100000111', u'1110000110110000', u'1010001000000010', u'1101000111101011', u'1001001001011001', u'1111001011101110', u'1011000101011100', u'1100110001111111', u'1000111111001101', u'1110111101111010', u'1010110011001000', u'1101111100100001', u'1001110010010011', u'1111110000100100', u'1011111110010110', u'1100011100001100', u'1000010010111110', u'1110010000001001', u'1010011110111011', u'1101010001010010', u'1001011111100000', u'1111011101010111', u'1011010011100101']", "name": "AC128", "bits_per_code": 16}, "model": "rc.rclinecode", "pk": 10},
              {"fields": {"number_of_codes": 2, "codes": "[u'11101101111000101110110100011101111011011110001000010010111000101110110111100010111011010001110100010010000111011110110100011101', u'11101101111000101110110100011101111011011110001000010010111000100001001000011101000100101110001011101101111000100001001011100010']", "name": "COMPLEMENTARY_CODE_128", "bits_per_code": 128}, "model": "rc.rclinecode", "pk": 11},
              {"fields": {"number_of_codes": 2, "codes": "[u'1110110111100010', u'1110110100011101']", "name": "COMPLEMENTARY_CODE_16", "bits_per_code": 16}, "model": "rc.rclinecode", "pk": 12},
              {"fields": {"number_of_codes": 1, "codes": "[u'11']", "name": "BARKER2", "bits_per_code": 2}, "model": "rc.rclinecode", "pk": 13},
              {"fields": {"number_of_codes": 1, "codes": "[u'110']", "name": "BARKER3", "bits_per_code": 3}, "model": "rc.rclinecode", "pk": 14},
              {"fields": {"number_of_codes": 2, "codes": "[u'1110', u'1101']", "name": "COMPLEMENTARY_CODE_4", "bits_per_code": 4}, "model": "rc.rclinecode", "pk": 15},
              {"fields": {"number_of_codes": 1, "codes": "[u'1110010']", "name": "BARKER7", "bits_per_code": 7}, "model": "rc.rclinecode", "pk": 16},
              {"fields": {"number_of_codes": 1, "codes": "[u'1101']", "name": "BARKER4", "bits_per_code": 4}, "model": "rc.rclinecode", "pk": 17},
              {"fields": {"number_of_codes": 1, "codes": "[u'11101']", "name": "BARKER5", "bits_per_code": 5}, "model": "rc.rclinecode", "pk": 18},
              {"fields": {"number_of_codes": 0, "codes": "[]", "name": "USERDEFINE", "bits_per_code": 0}, "model": "rc.rclinecode", "pk": 19},
              {"fields": {"params": "{\"TX_ref\": {\"model\": \"RCLine\",  \"value\": \"\"}, \"range\": { \"value\": 0, \"help\": \"Frame numbers or frame ranges separated by commas, use 0 for all frames eg: 1,2,10-15\"}}", "name": "tr", "description": ""}, "model": "rc.rclinetype", "pk": 1},
              {"fields": {"params": "{\"pulse_width\":{\"value\": 0, \"widget\":\"dc\"},\r\n \"delays\":{\"value\": \"\", \"widget\":\"km\", \"help\": \"Delay entries separated by commas (TAUs)\"},\r\n \"range\":{\"value\": 0, \"help\": \"Frame numbers or frame ranges separated by commas, use 0 for all frames eg: 1,2,10-15\"}}", "name": "tx", "description": ""}, "model": "rc.rclinetype", "pk": 2},
              {"fields": {"params": "{\"TX_ref\": {\"model\": \"RCLine\",  \"value\": \"\"}, \"code\": {\"model\":\"RCLineCode\",\"value\": \"\"}, \"codes\":{\"value\":\"\", \"widget\":\"codes\"}}", "name": "codes", "description": ""}, "model": "rc.rclinetype", "pk": 3},
-             {"fields": {"params": "{ \"TX_ref\":{\"model\": \"RCLine\",  \"value\": \"\"}, \"params\": {\"first_height\":{ \"value\": 0, \"widget\":\"km\"},\"resolution\": {\"value\": 0, \"widget\":\"km\"}, \"number_of_samples\": { \"value\": 0, \"help\":\"number of samples (NSA)\"}}}", "name": "windows", "description": ""}, "model": "rc.rclinetype", "pk": 4},
+             {"fields": {"params": "{ \"TX_ref\":{\"model\": \"RCLine\",  \"value\": \"\"}, \"params\": {\"first_height\":{ \"value\": 0, \"widget\":\"km\"},\"resolution\": {\"value\": 0, \"widget\":\"km\"}, \"number_of_samples\": { \"value\": 0, \"help\":\"number of samples (NSA)\"}, \"last_height\": { \"value\": 0}}}", "name": "windows", "description": ""}, "model": "rc.rclinetype", "pk": 4},
              {"fields": {"params": "{\"invert\":{\"value\": 0, \"help\": \"Set to 1 for synchro pulse at the end\"}}", "name": "sync", "description": ""}, "model": "rc.rclinetype", "pk": 5},
              {"fields": {"params": "{ \"periodic\": { \"value\": 0, \"help\": \"Set to 1 for IPP periodic\"}, \"params\": {\"begin\": { \"value\": 0, \"widget\":\"unit\"}, \"end\": {\"value\": 0, \"widget\":\"unit\"}}}", "name": "prog_pulses", "description": ""}, "model": "rc.rclinetype", "pk": 6},
              {"fields": {"params": "{\"number_of_flips\": {\"value\": 0}}", "name": "flip", "description": ""}, "model": "rc.rclinetype", "pk": 7},
              {"fields": {"params": "{}", "name": "none", "description": ""}, "model": "rc.rclinetype", "pk": 8},
              {"fields": {"params": "{}", "name": "mix", "description": ""}, "model": "rc.rclinetype", "pk": 9}]

apps/rc/models.py +32 -13

             import ast
             import json
             import numpy as np
             from polymorphic import PolymorphicModel
             from django.db import models
             from django.core.urlresolvers import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from apps.main.models import Configuration
             from devices.rc import api
             from .utils import RCFile
             # Create your models here.
             LINE_TYPES = (
                 ('none', 'Not used'),
                 ('tr', 'Transmission/reception selector signal'),
                 ('tx', 'A modulating signal (Transmission pulse)'),
                 ('codes', 'BPSK modulating signal'),
                 ('windows', 'Sample window signal'),
                 ('sync', 'Synchronizing signal'),
                 ('flip', 'IPP related periodic signal'),
                 ('prog_pulses', 'Programmable pulse'),
                 ('mix', 'Mixed line'),
                 )
             SAMPLING_REFS = (
                 ('none', 'No Reference'),
+                ('begin_baud', 'Begin of the first baud'),
                 ('first_baud', 'Middle of the first baud'),
                 ('sub_baud', 'Middle of the sub-baud')
                              )
             DAT_CMDS = {
                     # Pulse Design commands
                     'DISABLE' : 0, # Disables pulse generation
                     'ENABLE' : 24, # Enables pulse generation
                     'DELAY_START' : 40, # Write delay status to memory
                     'FLIP_START' : 48, # Write flip status to memory
                     'SAMPLING_PERIOD' : 64, # Establish Sampling Period
                     'TX_ONE' : 72, # Output '0' in line TX
                     'TX_ZERO' : 88, # Output '0' in line TX
                     'SW_ONE' : 104, # Output '0' in line SW
                     'SW_ZERO' : 112, # Output '1' in line SW
                     'RESTART': 120, # Restarts CR8 Firmware
                     'CONTINUE' : 253, # Function Unknown
                     # Commands available to new controllers
                     # In Pulse Design Executable, the clock divisor code is written as 12 at the start, but it should be written as code 22(below) just before the final enable.
                     'CLOCK_DIVISOR_INIT' : 12, # Specifies Clock Divisor. Legacy command, ignored in the actual .dat conversion
                     'CLOCK_DIVISOR_LAST' : 22, # Specifies Clock Divisor (default 60 if not included) syntax: 255,22 254,N-1.
                     'CLOCK_DIVIDER' : 8,
                         }
             class RCConfiguration(Configuration):
                 ipp = models.FloatField(verbose_name='IPP [Km]', validators=[MinValueValidator(1), MaxValueValidator(9000)], default=300)
                 ntx = models.PositiveIntegerField(verbose_name='Number of TX', validators=[MinValueValidator(1), MaxValueValidator(400)], default=1)
                 clock_in = models.FloatField(verbose_name='Clock in [MHz]', validators=[MinValueValidator(1), MaxValueValidator(80)], default=1)
                 clock_divider = models.PositiveIntegerField(verbose_name='Clock divider', validators=[MinValueValidator(1), MaxValueValidator(256)], default=1)
                 clock = models.FloatField(verbose_name='Clock Master [MHz]', blank=True, default=1)
                 time_before = models.PositiveIntegerField(verbose_name='Time before [&mu;S]', default=12)
                 time_after = models.PositiveIntegerField(verbose_name='Time after [&mu;S]', default=1)
                 sync = models.PositiveIntegerField(verbose_name='Synchro delay', default=0)
                 sampling_reference = models.CharField(verbose_name='Sampling Reference', choices=SAMPLING_REFS, default='none', max_length=40)
                 control_tx = models.BooleanField(verbose_name='Control Switch TX', default=False)
                 control_sw = models.BooleanField(verbose_name='Control Switch SW', default=False)
                 total_units = models.PositiveIntegerField(default=0)
                 mix = models.BooleanField(default=False)
                 class Meta:
                     db_table = 'rc_configurations'
                 def get_absolute_url_plot(self):
                     return reverse('url_plot_rc_pulses', args=[str(self.id)])
                 def get_absolute_url_import(self):
                     return reverse('url_import_rc_conf', args=[str(self.id)])
                 @property
                 def ipp_unit(self):
                     return '{} ({})'.format(self.ipp, int(self.ipp*self.km2unit))
                 @property
                 def us2unit(self):
                     return self.clock_in/self.clock_divider
                 @property
                 def km2unit(self):
                     return 20./3*(self.clock_in/self.clock_divider)
                 def clone(self, **kwargs):
                     lines = self.get_lines()
                     self.pk = None
                     self.id = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     for line in lines:
                         line.clone(rc_configuration=self)
                     return self
                 def get_lines(self, **kwargs):
                     '''
                     Retrieve configuration lines
                     '''
                     return RCLine.objects.filter(rc_configuration=self.pk, **kwargs)
                 def clean_lines(self):
                     '''
                     '''
                     empty_line = RCLineType.objects.get(name='none')
                     for line in self.get_lines():
                         line.line_type = empty_line
                         line.params = '{}'
                         line.save()
                 def parms_to_dict(self):
                     '''
                     '''
                     ignored = ('parameters', 'type', 'polymorphic_ctype', 'configuration_ptr',
                                'created_date', 'programmed_date')
                     data = {}
                     for field in self._meta.fields:
                         if field.name in ignored:
                             continue
                         data[field.name] = '{}'.format(field.value_from_object(self))
                     data['device_id'] = data.pop('device')
                     data['lines'] = []
                     for line in self.get_lines():
                         line_data = json.loads(line.params)
                         if 'TX_ref' in line_data and line_data['TX_ref'] not in (0, '0'):
-                            line_data['TX_ref'] = RCLine.objects.get(pk=line_data['TX_ref']).get_name()
+                            line_data['TX_ref'] = line.get_name()
                         if 'code' in line_data:
                             line_data['code'] = RCLineCode.objects.get(pk=line_data['code']).name
                         line_data['type'] = line.line_type.name
+                        line_data['name'] = line.get_name()
                         data['lines'].append(line_data)
                     data['delays'] = self.get_delays()
                     data['pulses'] = self.get_pulses()
                     return data
                 def dict_to_parms(self, data):
                     '''
                     '''
                     self.name = data['name']
                     self.ipp = float(data['ipp'])
                     self.ntx = int(data['ntx'])
                     self.clock_in = float(data['clock_in'])
                     self.clock_divider = int(data['clock_divider'])
                     self.clock = float(data['clock'])
                     self.time_before = data['time_before']
                     self.time_after = data['time_after']
                     self.sync = data['sync']
                     self.sampling_reference = data['sampling_reference']
                     self.total_units = self.ipp*self.ntx*self.km2unit
                     self.save()
                     self.clean_lines()
                     lines = []
                     positions = {'tx':0, 'tr':0}
                     for i, line_data in enumerate(data['lines']):
                         line_type = RCLineType.objects.get(name=line_data.pop('type'))
                         if line_type.name=='codes':
                             code = RCLineCode.objects.get(name=line_data['code'])
                             line_data['code'] = code.pk
                         line = RCLine.objects.filter(rc_configuration=self, channel=i)
                         if line:
                             line = line[0]
                             line.line_type = line_type
                             line.params = json.dumps(line_data)
                         else:
                             line = RCLine(rc_configuration=self, line_type=line_type,
                                           params=json.dumps(line_data),
                                           channel=i)
                         if line_type.name=='tx':
                             line.position = positions['tx']
                             positions['tx'] += 1
                         if line_type.name=='tr':
                             line.position = positions['tr']
                             positions['tr'] += 1
                         line.save()
                         lines.append(line)
                     for line, line_data in zip(lines, data['lines']):
                         if 'TX_ref' in line_data:
                             params = json.loads(line.params)
                             if line_data['TX_ref'] in (0, '0'):
                                 params['TX_ref'] = '0'
                             else:
                                 params['TX_ref'] = [l.pk for l in lines if l.line_type.name=='tx' and line_data['TX_ref'] in l.get_name()][0]
                             line.params = json.dumps(params)
                             line.save()
                 def get_delays(self):
                     pulses = [line.pulses_as_points() for line in self.get_lines()]
                     points = [tup for tups in pulses for tup in tups]
                     points = set([x for tup in points for x in tup])
                     points = list(points)
                     points.sort()
                     if points[0]<>0:
                         points.insert(0, 0)
                     return [points[i+1]-points[i] for i in range(len(points)-1)]
                 def get_pulses(self, binary=True):
                     pulses = [line.pulses_as_points() for line in self.get_lines()]
                     points = [tup for tups in pulses for tup in tups]
                     points = set([x for tup in points for x in tup])
                     points = list(points)
                     points.sort()
                     line_points = [line.pulses_as_points() for line in self.get_lines()]
                     line_points = [[(x, x+y) for x,y in tups] for tups in line_points]
                     line_points = [[t for x in tups for t in x] for tups in line_points]
                     states = [[1 if x in tups else 0 for tups in line_points] for x in points]
                     if binary:
                         states.reverse()
                         states = [int(''.join([str(x) for x in flips]), 2) for flips in states]
                     return states[:-1]
                 def add_cmd(self, cmd):
                     if cmd in DAT_CMDS:
                         return (255, DAT_CMDS[cmd])
                 def add_data(self, value):
                     return (254, value-1)
                 def parms_to_binary(self):
                     '''
                     Create "dat" stream to be send to CR
                     '''
                     data = []
                     # create header
                     data.append(self.add_cmd('DISABLE'))
                     data.append(self.add_cmd('CONTINUE'))
                     data.append(self.add_cmd('RESTART'))
                     if self.control_sw:
                         data.append(self.add_cmd('SW_ONE'))
                     else:
                         data.append(self.add_cmd('SW_ZERO'))
                     if self.control_tx:
                         data.append(self.add_cmd('TX_ONE'))
                     else:
                         data.append(self.add_cmd('TX_ZERO'))
                     # write divider
                     data.append(self.add_cmd('CLOCK_DIVIDER'))
                     data.append(self.add_data(self.clock_divider))
                     # write delays
                     data.append(self.add_cmd('DELAY_START'))
                     # first delay is always zero
                     data.append(self.add_data(1))
                     delays = self.get_delays()
                     for delay in delays:
                         while delay>252:
                             data.append(self.add_data(253))
                             delay -= 253
                         data.append(self.add_data(delay))
                     # write flips
                     data.append(self.add_cmd('FLIP_START'))
                     states = self.get_pulses(binary=False)
                     for flips, delay in zip(states, delays):
                         flips.reverse()
                         flip = int(''.join([str(x) for x in flips]), 2)
                         data.append(self.add_data(flip+1))
                         while delay>252:
                             data.append(self.add_data(1))
                             delay -= 253
                     # write sampling period
                     data.append(self.add_cmd('SAMPLING_PERIOD'))
                     wins = self.get_lines(line_type__name='windows')
                     if wins:
                         win_params = json.loads(wins[0].params)['params']
                         if win_params:
                             dh = int(win_params[0]['resolution']*self.km2unit)
                         else:
                             dh = 1
                     else:
                         dh = 1
                     data.append(self.add_data(dh))
                     # write enable
                     data.append(self.add_cmd('ENABLE'))
                     return '\n'.join(['{}'.format(x) for tup in data for x in tup])
                 def update_from_file(self, filename):
                     '''
                     Update instance from file
                     '''
                     f = RCFile(filename)
                     self.dict_to_parms(f.data)
                     self.update_pulses()
                 def update_pulses(self):
                     for line in self.get_lines():
                         line.update_pulses()
-                def plot_pulses(self):
+                def plot_pulses(self, km=False):
                     import matplotlib.pyplot as plt
                     from bokeh.resources import CDN
                     from bokeh.embed import components
                     from bokeh.mpl import to_bokeh
                     from bokeh.models.tools import WheelZoomTool, ResetTool, PanTool, PreviewSaveTool
                     lines = self.get_lines()
                     N = len(lines)
+                    npoints = self.total_units/self.km2unit if km else self.total_units
                     fig = plt.figure(figsize=(10, 2+N*0.5))
                     ax = fig.add_subplot(111)
-                    labels = []
+                    labels = ['IPP']
                     for i, line in enumerate(lines):
-                        labels.append(line.get_name())
+                        labels.append(line.get_name(channel=True))
-                        l = ax.plot((0, self.total_units),(N-i-1, N-i-1))
+                        l = ax.plot((0, npoints),(N-i-1, N-i-1))
-                        points = [(tup[0], tup[1]-tup[0]) for tup in line.pulses_as_points() if tup<>(0,0)]
+                        points = [(tup[0], tup[1]-tup[0]) for tup in line.pulses_as_points(km=km) if tup<>(0,0)]
                         ax.broken_barh(points, (N-i-1, 0.5),
                                        edgecolor=l[0].get_color(), facecolor='none')
+                    n = 0
+                    f = ((self.ntx+50)/100)*5 if ((self.ntx+50)/100)*10>0 else 2
+                    for x in np.arange(0, npoints, self.ipp if km else self.ipp*self.km2unit):
+                        if n%f==0:
+                            ax.text(x, N, '%s' % n, size=10)
+                        n += 1
                     labels.reverse()
                     ax.set_yticklabels(labels)
                     ax.set_xlabel = 'Units'
                     plot = to_bokeh(fig, use_pandas=False)
                     plot.tools = [PanTool(dimensions=['width']), WheelZoomTool(dimensions=['width']), ResetTool(), PreviewSaveTool()]
                     return components(plot, CDN)
                 def status_device(self):
                     return 0
                 def stop_device(self):
                     answer = api.disable(ip = self.device.ip_address,
                                          port = self.device.port_address)
                     if answer[0] != "1":
                         self.message = answer[0:]
                         return 0
                     self.message = answer[2:]
                     return 1
                 def start_device(self):
                     answer = api.enable(ip = self.device.ip_address,
                                         port = self.device.port_address)
                     if answer[0] != "1":
                         self.message = answer[0:]
                         return 0
                     self.message = answer[2:]
                     return 1
                 def write_device(self):
                     answer = api.write_config(ip = self.device.ip_address,
                                              port = self.device.port_address,
                                              parms = self.parms_to_dict())
                     if answer[0] != "1":
                         self.message = answer[0:]
                         return 0
                     self.message = answer[2:]
                     return 1
             class RCLineCode(models.Model):
                 name = models.CharField(max_length=40)
                 bits_per_code = models.PositiveIntegerField(default=0)
                 number_of_codes = models.PositiveIntegerField(default=0)
                 codes = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'rc_line_codes'
                     ordering = ('name',)
                 def __unicode__(self):
                     return u'%s' % self.name
             class RCLineType(models.Model):
                 name = models.CharField(choices=LINE_TYPES, max_length=40)
                 description = models.TextField(blank=True, null=True)
                 params = models.TextField(default='[]')
                 class Meta:
                     db_table = 'rc_line_types'
                 def __unicode__(self):
                     return u'%s - %s' % (self.name.upper(), self.get_name_display())
             class RCLine(models.Model):
                 rc_configuration = models.ForeignKey(RCConfiguration, on_delete=models.CASCADE)
                 line_type = models.ForeignKey(RCLineType)
                 channel = models.PositiveIntegerField(default=0)
                 position = models.PositiveIntegerField(default=0)
                 params = models.TextField(default='{}')
                 pulses = models.TextField(default='')
                 class Meta:
                     db_table = 'rc_lines'
                     ordering = ['channel']
                 def __unicode__(self):
                     if self.rc_configuration:
                         return u'%s - %s' % (self.rc_configuration, self.get_name())
                 def clone(self, **kwargs):
                     self.pk = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     return self
-                def get_name(self):
+                def get_name(self, channel=False):
                     chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
                     s = ''
                     if self.line_type.name in ('tx',):
                         s = chars[self.position]
                     elif self.line_type.name in ('codes', 'windows', 'tr'):
                         if 'TX_ref' in json.loads(self.params):
                             pk = json.loads(self.params)['TX_ref']
                             if pk in (0, '0'):
                                 s = ','.join(chars[l.position] for l in self.rc_configuration.get_lines(line_type__name='tx'))
                             else:
                                 ref = RCLine.objects.get(pk=pk)
                                 s = chars[ref.position]
                             s = '({})'.format(s)
-                    if s:
-                        return '{}{} {}'.format(self.line_type.name.upper(), s, self.channel)
+                    s = '{}{}'.format(self.line_type.name.upper(), s)
+                    if channel:
+                        return '{} {}'.format(s, self.channel)
                     else:
-                        return '{} {}'.format(self.line_type.name.upper(), self.channel)
+                        return s
                 def get_lines(self, **kwargs):
                     return RCLine.objects.filter(rc_configuration=self.rc_configuration, **kwargs)
                 def pulses_as_array(self):
                     y = np.zeros(self.rc_configuration.total_units)
                     for tup in ast.literal_eval(self.pulses):
                         y[tup[0]:tup[1]] = 1
                     return y.astype(np.int8)
-                def pulses_as_points(self):
+                def pulses_as_points(self, km=False):
-                    return ast.literal_eval(self.pulses)
+                    if km:
+                        unit2km = 1/self.rc_configuration.km2unit
+                        return [(tup[0]*unit2km, tup[1]*unit2km) for tup in ast.literal_eval(self.pulses)]
+                    else:
+                        return ast.literal_eval(self.pulses)
                 def get_win_ref(self, params, tx_id, km2unit):
                     ref = self.rc_configuration.sampling_reference
                     codes = [line for line in self.get_lines(line_type__name='codes') if int(json.loads(line.params)['TX_ref'])==int(tx_id)]
                     if codes:
                         tx_width = float(json.loads(RCLine.objects.get(pk=tx_id).params)['pulse_width'])*km2unit/len(json.loads(codes[0].params)['codes'][0])
                     else:
                         tx_width = float(json.loads(RCLine.objects.get(pk=tx_id).params)['pulse_width'])*km2unit
                     if ref=='first_baud':
                         return int(1 + (tx_width + 1)/2 + params['first_height']*km2unit - params['resolution']*km2unit)
                     elif ref=='sub_baud':
                         return int(1 + params['first_height']*km2unit - params['resolution']*km2unit/2)
                     else:
                         return 0
                 def update_pulses(self):
                     '''
                     Update pulses field
                     '''
                     km2unit = self.rc_configuration.km2unit
                     us2unit = self.rc_configuration.us2unit
                     ipp = self.rc_configuration.ipp
                     ntx = self.rc_configuration.ntx
                     ipp_u = int(ipp*km2unit)
                     total = ipp_u*ntx if self.rc_configuration.total_units==0 else self.rc_configuration.total_units
                     y = []
                     if self.line_type.name=='tr':
                         tr_params = json.loads(self.params)
                         if tr_params['TX_ref'] in ('0', 0):
                             txs = self.get_lines(line_type__name='tx')
                         else:
                             txs = RCLine.objects.filter(pk=tr_params['TX_ref'])
                         for tx in txs:
                             params = json.loads(tx.params)
                             if float(params['pulse_width'])==0:
                                 continue
                             delays = [float(d)*km2unit for d in params['delays'].split(',') if d]
                             width = float(params['pulse_width'])*km2unit+int(self.rc_configuration.time_before*us2unit)
                             before = 0
                             after = int(self.rc_configuration.time_after*us2unit)
                             y_tx = self.points(ntx, ipp_u, width,
                                                delay=delays,
                                                before=before,
                                                after=after,
                                                sync=self.rc_configuration.sync)
                             ranges = params['range'].split(',')
                             if len(ranges)>0 and ranges[0]<>'0':
                                 y_tx = self.mask_ranges(y_tx, ranges)
                             tr_ranges = tr_params['range'].split(',')
                             if len(tr_ranges)>0 and tr_ranges[0]<>'0':
                                 y_tx = self.mask_ranges(y_tx, tr_ranges)
                             y.extend(y_tx)
                         self.pulses = unicode(y)
                         y = self.array_to_points(self.pulses_as_array())
                     elif self.line_type.name=='tx':
                         params = json.loads(self.params)
                         delays = [float(d)*km2unit for d in params['delays'].split(',') if d]
                         width = float(params['pulse_width'])*km2unit
                         if width>0:
                             before = int(self.rc_configuration.time_before*us2unit)
                             after = 0
                             y = self.points(ntx, ipp_u, width,
                                             delay=delays,
                                             before=before,
                                             after=after,
                                             sync=self.rc_configuration.sync)
                             ranges = params['range'].split(',')
                             if len(ranges)>0 and ranges[0]<>'0':
                                 y = self.mask_ranges(y, ranges)
                     elif self.line_type.name=='flip':
                         n = float(json.loads(self.params)['number_of_flips'])
                         width = n*ipp*km2unit
                         y = self.points(int((ntx+1)/(2*n)), ipp_u*n*2, width)
                     elif self.line_type.name=='codes':
                         params = json.loads(self.params)
                         tx = RCLine.objects.get(pk=params['TX_ref'])
                         tx_params = json.loads(tx.params)
                         delays = [float(d)*km2unit for d in tx_params['delays'].split(',') if d]
                         f = int(float(tx_params['pulse_width'])*km2unit)/len(params['codes'][0])
                         codes = [(np.fromstring(''.join([s*f for s in code]), dtype=np.uint8)-48).astype(np.int8) for code in params['codes']]
                         codes = [self.array_to_points(code) for code in codes]
                         n = len(codes)
                         for i, tup in enumerate(tx.pulses_as_points()):
                             code = codes[i%n]
                             y.extend([(c[0]+tup[0], c[1]+tup[0]) for c in code])
                         ranges = tx_params['range'].split(',')
                         if len(ranges)>0 and ranges[0]<>'0':
                             y = self.mask_ranges(y, ranges)
                     elif self.line_type.name=='sync':
                         params = json.loads(self.params)
                         n = ipp_u*ntx
                         if params['invert'] in ('1', 1):
                             y = [(n-1, n)]
                         else:
                             y = [(0, 1)]
                     elif self.line_type.name=='prog_pulses':
                         params = json.loads(self.params)
                         if int(params['periodic'])==0:
                             nntx = 1
                             nipp = ipp_u*ntx
                         else:
                             nntx = ntx
                             nipp = ipp_u
                         if 'params' in params and len(params['params'])>0:
                             for p in params['params']:
                                 y_pp = self.points(nntx, nipp,
                                                    p['end']-p['begin'],
                                                    before=p['begin'])
                                 y.extend(y_pp)
                     elif self.line_type.name=='windows':
                         params = json.loads(self.params)
                         if 'params' in params and len(params['params'])>0:
                             tr_params = json.loads(self.get_lines(line_type__name='tr')[0].params)
                             tr_ranges = tr_params['range'].split(',')
                             for p in params['params']:
                                 y_win = self.points(ntx, ipp_u,
                                                     p['resolution']*p['number_of_samples']*km2unit,
                                                     before=int(self.rc_configuration.time_before*us2unit)+self.get_win_ref(p, params['TX_ref'], km2unit),
                                                     sync=self.rc_configuration.sync)
                                 if len(tr_ranges)>0 and tr_ranges[0]<>'0':
                                     y_win = self.mask_ranges(y_win, tr_ranges)
                                 y.extend(y_win)
                     elif self.line_type.name=='mix':
                         values = self.rc_configuration.parameters.split('-')
                         confs = [RCConfiguration.objects.get(pk=value.split('|')[0]) for value in values]
                         modes = [value.split('|')[1] for value in values]
                         ops = [value.split('|')[2] for value in values]
                         delays = [value.split('|')[3] for value in values]
                         masks = [value.split('|')[4] for value in values]
                         mask = list('{:8b}'.format(int(masks[0])))
                         mask.reverse()
                         if mask[self.channel] in ('0', '', ' '):
                             y = np.zeros(confs[0].total_units, dtype=np.int8)
                         else:
                             y = confs[0].get_lines(channel=self.channel)[0].pulses_as_array()
                         for i in range(1, len(values)):
                             mask = list('{:8b}'.format(int(masks[i])))
                             mask.reverse()
                             if mask[self.channel] in ('0', '', ' '):
                                 continue
                             Y = confs[i].get_lines(channel=self.channel)[0].pulses_as_array()
                             delay = float(delays[i])*km2unit
                             if modes[i]=='P':
                                 if delay>0:
                                     if delay<self.rc_configuration.ipp*km2unit and len(Y)==len(y):
                                         y_temp = np.empty_like(Y)
                                         y_temp[:delay] = 0
                                         y_temp[delay:] = Y[:-delay]
                                     elif delay+len(Y)>len(y):
                                         y_new = np.zeros(delay+len(Y), dtype=np.int8)
                                         y_new[:len(y)] = y
                                         y = y_new
                                         y_temp = np.zeros(delay+len(Y), dtype=np.int8)
                                         y_temp[-len(Y):] = Y
                                     elif delay+len(Y)==len(y):
                                         y_temp = np.zeros(delay+len(Y))
                                         y_temp[-len(Y):] = Y
                                     elif delay+len(Y)<len(y):
                                         y_temp = np.zeros(len(y), dtype=np.int8)
                                         y_temp[delay:delay+len(Y)] = Y
                                 if ops[i]=='OR':
                                     y = y | y_temp
                                 elif ops[i]=='XOR':
                                     y = y ^ y_temp
                                 elif ops[i]=='AND':
                                     y = y & y_temp
                                 elif ops[i]=='NAND':
                                     y = y & ~y_temp
                             else:
                                 y = np.concatenate([y, Y])
                         total = len(y)
                         y = self.array_to_points(y)
                     else:
                         y = []
                     if self.rc_configuration.total_units <> total:
                         self.rc_configuration.total_units = total
                         self.rc_configuration.save()
                     self.pulses = unicode(y)
                     self.save()
                 @staticmethod
                 def array_to_points(X):
                     d = X[1:]-X[:-1]
                     up = np.where(d==1)[0]
                     if X[0]==1:
                         up = np.concatenate((np.array([-1]), up))
                     up += 1
                     dw = np.where(d==-1)[0]
                     if X[-1]==1:
                         dw = np.concatenate((dw, np.array([len(X)-1])))
                     dw += 1
                     return [(tup[0], tup[1]) for tup in zip(up, dw)]
                 @staticmethod
                 def mask_ranges(Y, ranges):
                     y = [(0, 0) for __ in Y]
                     for index in ranges:
                         if '-' in index:
                             args = [int(a) for a in index.split('-')]
                             y[args[0]-1:args[1]] = Y[args[0]-1:args[1]]
                         else:
                             y[int(index-1)] = Y[int(index-1)]
                     return y
                 @staticmethod
                 def points(ntx, ipp, width, delay=[0], before=0, after=0, sync=0):
                     delays = len(delay)
                     Y = [(ipp*x+before+delay[x%delays], ipp*x+width+before+delay[x%delays]+after) for x in range(ntx)]
                     return Y

apps/rc/static/js/cr.js +50 -1

             var km_fields = [];
             var unit_fields = [];
             var dc_fields = [];
             function str2hz(s){
               return 150000*Math.pow(parseFloat(s), -1);
             }
             function str2unit(s){
               var km2unit = (20/3)*(parseFloat($('#id_clock_in').val())/parseFloat($('#id_clock_divider').val()));
               var ret = "";
               values = s.split(",");
               for (i=0; i<values.length; i++) {
-                ret += Math.round(parseFloat(values[i]))*km2unit;
+                ret += Math.round(parseFloat(values[i])*km2unit);
+                ret += ",";
+              }
+              return ret.substring(0, ret.length-1);
+            }
+            function str2int(s){
+              var ret = "";
+              values = s.split(",");
+              for (i=0; i<values.length; i++) {
+                ret += Math.round(parseFloat(values[i]));
                 ret += ",";
               }
               return ret.substring(0, ret.length-1);
             }
             function str2km(s){
               var km2unit = (20/3)*(parseFloat($('#id_clock_in').val())/parseFloat($('#id_clock_divider').val()));
               var ret = "";
               values = s.split(",");
               for (i=0; i<values.length; i++) {
                 ret += parseFloat(values[i])/km2unit;
                 ret += ",";
               }
               return ret.substring(0, ret.length-1);
             }
             function str2dc(s){
               return  parseFloat(s)*100/parseFloat($('#id_ipp').val())
             }
             function updateUnits() {
               for (j=0; j<km_fields.length; j++){
                 label_unit = "#"+km_fields[j]+"_unit";
                 label = "#"+km_fields[j];
                 $(label_unit).val(str2unit($(label).val()));
               }
             }
             function updateDc() {
               for (j=0; j<dc_fields.length; j++){
                 label_dc = "#"+dc_fields[j]+"_dc";
                 label = "#"+dc_fields[j];
                 $(label_dc).val(str2dc($(label).val()));
               }
             }
+            function updateWindows(label) {
+              if (label.indexOf("first_height")>0){
+                llabel = label.replace("first_height", "last_height");
+                rlabel = label.replace("first_height", "resolution");
+                nlabel = label.replace("first_height", "number_of_samples");
+                value = parseFloat($(label).val())+parseFloat($(rlabel).val())*(parseInt($(nlabel).val())-1);
+                $(llabel).val(value);
+              }
+              if (label.indexOf("resolution")>0){
+                llabel = label.replace("resolution", "last_height");
+                flabel = label.replace("resolution", "first_height");
+                nlabel = label.replace("resolution", "number_of_samples");
+                value = parseFloat($(flabel).val())+parseFloat($(label).val())*(parseInt($(nlabel).val())-1);
+                $(llabel).val(value);
+              }
+              if (label.indexOf("number_of_samples")>0){
+                llabel = label.replace("number_of_samples", "last_height");
+                rlabel = label.replace("number_of_samples", "resolution");
+                flabel = label.replace("number_of_samples", "first_height");
+                value = parseFloat($(flabel).val())+parseFloat($(rlabel).val())*(parseInt($(label).val())-1);
+                $(llabel).val(value);
+              }
+              if (label.indexOf("last_height")>0){
+                flabel = label.replace("last_height", "first_height");
+                rlabel = label.replace("last_height", "resolution");
+                nlabel = label.replace("last_height", "number_of_samples");
+                nvalue = Math.round((parseFloat($(label).val())-parseFloat($(flabel).val()))/parseFloat($(rlabel).val()))+1;
+                $(nlabel).val(nvalue);
+                value = parseFloat($(flabel).val())+parseFloat($(rlabel).val())*(nvalue-1);
+                $(label).val(value);
+              }
+            }
               $("#id_clock_in").change(function() {
                 $("#id_clock").val(parseFloat($('#id_clock_in').val())/parseFloat($('#id_clock_divider').val()));
                 updateUnits();
               });
               $("#id_clock_divider").change(function() {
                 $("#id_clock").val(parseFloat($('#id_clock_in').val())/parseFloat($('#id_clock_divider').val()));
                 updateUnits();
               });

apps/rc/templates/rc_conf.html +10 -1

             {% extends "dev_conf.html" %}
             {% load static %}
             {% load bootstrap3 %}
             {% load main_tags %}
             {% block extra-menu-actions %}
             <li><a href="{{ dev_conf.get_absolute_url_plot }}" target="_blank"><span class="glyphicon glyphicon-picture" aria-hidden="true"></span> View Pulses </a></li>
             {% endblock %}
             {% block extra-content %}
             <div class="clearfix"></div>
-            <h2>RC Lines</h2><hr>
+            <h2>RC Lines</h2>
+            <hr>
             <div class="panel-group" id="div_lines" role="tablist" aria-multiselectable="true">
             {% include "rc_lines.html" %}
             </div>
             {% endblock extra-content%}
+            {% block extra-js%}
+            <script type="text/javascript">
+              $("#bt_toggle").click(function() {
+                $(".panel-collapse").collapse('toggle')
+              });
+            </script>
+            {% endblock %}
  No newline at end of file

apps/rc/templates/rc_conf_edit.html +4 0

             {% extends "dev_conf_edit.html" %}
             {% load bootstrap3 %}
             {% load static %}
             {% block extra-head %}
             <style type="text/css">
                 /* show the move cursor as the user moves the mouse over the panel header.*/
                 .panel-default { cursor: move; }
             </style>
             <script src="{% static 'js/jquery-ui.min.js' %}"></script>
             {% endblock %}
             {% block content %}
             <form class="form" method="post">
               {% csrf_token %}
               {% bootstrap_form form layout='horizontal' size='medium' %}
               <div style="clear: both;"></div>
               <h2>RC Lines</h2><hr>
               <div class="panel-group" id="div_lines" role="tablist" aria-multiselectable="true">
               {% include "rc_lines.html" %}
               </div>
               <div style="clear: both;"></div>
               <br>
               <div class="pull-right">
               <button type="button" class="btn btn-primary" onclick="{% if previous %}window.location.replace('{{ previous }}');{% else %}history.go(-1);{% endif %}">Cancel</button>
               <button type="button" class="btn btn-primary" id="bt_add_line">Add Line</button>
               <button type="submit" class="btn btn-primary">{{button}}</button>
               </div>
             </form>
             {% endblock %}
             {% block extra-js%}
             <script src="{% static 'js/cr.js' %}"></script>
             <script type="text/javascript">
               $("#div_lines").on("click", "button[name=bt_remove_line]", function(){
                 document.location = "/rc/{{dev_conf.id}}/line/"+$(this).val()+"/delete/";
               });
               $("#div_lines").on("click", "button[name=bt_remove_subline]", function(){
                 document.location = $(this).data('url');
               });
               $("#div_lines").on("click", "button[name=bt_add_subline]", function(){
                 document.location = "/rc/{{dev_conf.id}}/line/"+$(this).val()+"/add_subline/";
               });
               $("#div_lines").on("click", "button[name=bt_edit_codes]", function(){
                 document.location = "/rc/{{dev_conf.id}}/line/"+$(this).val()+"/codes/";
               });
               $("#bt_add_line").click(function() {
                 document.location = "{% url 'url_add_rc_line' dev_conf.id%}";
               });
               $(".panel-group").sortable({
                 //placeholder: "ui-state-highlight",
                 update: function( event, ui ) {
                     var sorted = $( ".panel-group" ).sortable( "serialize", { key: "item" } );
                     var url = "{% url 'url_update_rc_lines_position' dev_conf.id %}";
                     var csrf_token = "{{csrf_token}}";
                     $.post( url, { 'items': sorted, 'csrfmiddlewaretoken': csrf_token }, function(data){
                        $("#div_lines").html(data.html);
                     });
                 }
               });
+              $("#bt_toggle").click(function() {
+                $(".panel-collapse").collapse('toggle')
+              });
             </script>
             {% endblock %}
   No newline at end of file

apps/rc/templates/rc_lines.html +3 -1

             {% load bootstrap3 %}
+            <div class="pull-right"><button id="bt_toggle" type="button" class="btn btn-default btn-sm" >
+            Expand/Collapse
+            </button></div><br><br>
             {% for line in rc_lines %}
               <div class="panel panel-default" id="panel-{{line.id}}">
                 <div class="panel-heading" role="tab" id="heading{{line.id}}">
                   <h4 class="panel-title">
                     <a role="button" data-toggle="collapse" data-parent="#div_lines" href="#collapse{{line.id}}" aria-expanded="true" aria-controls="collapse{{line.id}}">
                       CH{{line.channel}} - {{line.get_name}}
                     </a>
                   {% if edit %}
                   <button type="button" class="btn-xs btn-default pull-right" name="bt_remove_line" value="{{line.pk}}"><span class="glyphicon glyphicon-remove" aria-hidden="true"></span></button>
                   {% endif %}
                   </h4>
                 </div>
                 <div id="collapse{{line.id}}" class="panel-collapse collapse" role="tabpanel" aria-labelledby="heading{{line.id}}">
                   <div class="panel-body">
                     {% bootstrap_form line.form layout='horizontal' size='small' %}
                     <br><br>
                     {% for f in line.subforms %}
                       <div class="form-group form-group-sm">
                       <label class="col-md-3 control-label">{{line.line_type.name}}-{{ forloop.counter }}</label>
                       <div class="col-md-9">{% if edit %}<button type='button' name="bt_remove_subline" class="btn-xs btn-default" data-url="{% url 'url_remove_rc_subline' dev_conf.id line.id forloop.counter %}"><span class="glyphicon glyphicon-remove" aria-hidden="true"></span></button>{% endif %}</div>
                       </div><div class="clearfix"></div>
                       {% bootstrap_form f layout='horizontal' size='small' %}
                       <div class="clearfix"></div>
                     {% endfor %}
                     {% if edit and line.subform %}
                       <br>
                       <button type="button" class="btn btn-sm btn-default" style="margin-left: 10px" name="bt_add_subline" value="{{line.pk}}">Add {{line.line_type.name}}</button>
                     {% endif %}
                     {% if edit and line.line_type.name == 'codes' %}
                       <br>
                       <button type="button" class="btn btn-sm btn-default" style="margin-left: 10px" name="bt_edit_codes" value="{{line.pk}}">Edit</button>
                     {% endif %}
                   </div>
                 </div>
               </div>
             {% endfor%}

apps/rc/templates/rc_pulses.html +42 -4

@@ -1,24 +1,62
1	{% extends "dev_conf.html" %}	1	{% extends "dev_conf.html" %}
2	{% load static %}	2	{% load static %}
3	{% load bootstrap3 %}	3	{% load bootstrap3 %}
4	{% load main_tags %}	4	{% load main_tags %}
5		5
6	{% block extra-head %}	6	{% block extra-head %}
7	<link href="http://cdn.pydata.org/bokeh/release/bokeh-0.11.1.min.css" rel="stylesheet" type="text/css">	7	<link href="http://cdn.pydata.org/bokeh/release/bokeh-0.11.1.min.css" rel="stylesheet" type="text/css">
8	{% endblock %}	8	{% endblock %}
9		9
10	{% block content %}	10	{% block content %}
		11
11	<div id="div_plot">{{div}}</div>	12	<div id="div_plot">{{div}}</div>
12	<br>	13	<br>
13	<div class="col-md-2">1 Km =</div><div class="col-md-3">{{units}} Units</div>	14
14	<br>	15	<form class="form-horizontal">
15	<div class="col-md-2">1 Unit=</div><div class="col-md-3">{{kms}} Km</div>	16	<div class="form-group">
		17	<label class="col-sm-2 control-label">Axis</label>
		18	<div class="col-sm-4">
		19	<select class="form-control" id='id_axis'>
		20	<option value=0>Units</option>
		21	{%if km_selected %}
		22	<option value=1 selected>Km</option>
		23	{%else%}
		24	<option value=1>Km</option>
		25	{%endif%}
		26	</select>
		27	</div>
		28	</div>
		29	<div class="form-group">
		30	<label class="col-sm-2 control-label">1 Km</label>
		31	<div class="col-sm-4">
		32	<p class="form-control-static">{{units}} Units</p>
		33	</div>
		34	</div>
		35	<div class="form-group">
		36	<label class="col-sm-2 control-label">1 Unit</label>
		37	<div class="col-sm-4">
		38	<p class="form-control-static">{{kms}} Km</p>
		39	</div>
		40	</div>
		41	</form>
		42
16	{% endblock %}	43	{% endblock %}
17		44
18	{% block extra-js%}	45	{% block extra-js%}
19		46
20	<script src="{% static 'js/bokeh-0.11.1.min.js' %}"></script>	47	<script src="{% static 'js/bokeh-0.11.1.min.js' %}"></script>
21		48
		49	<script type="text/javascript">
		50
		51	$("#id_axis").change(function() {
		52	if($(this).val()=='0'){
		53	document.location = '?unit';
		54	}else{
		55	document.location = '?km'
		56	}
		57	});
		58
		59	</script>
22	{{script}}	60	{{script}}
23		61
24	{% endblock %} No newline at end of file	62	{% endblock %}

apps/rc/utils.py +5 -2

             import json
             class RCFile(object):
                 '''
                 Class to handle Radar controller configuration files
                 '''
                 def __init__(self, f=None):
                     self.data = {}
                     if isinstance(f, str):
                         self.f = open(f)
                         self.name = f.split('/')[-1]
                     elif hasattr(f, 'read'):
                         self.f = f
                         self.name = f.name.split('/')[-1]
                     else:
                         self.f = f
                         self.name = None
                     if self.f:
                         if 'racp' in self.name:
                             self.parse_racp()
                         elif 'dat' in self.name:
                             self.parse_dat()
                         elif 'json' in self.name:
                             self.data = json.load(self.f)
                     self.f.close()
                 def get_line_parameters(self, data, line):
                     line_params = {}
                     for label in data:
                         if 'L%d' % line in label or '(Line %d)' % line in label or 'Line%d' % line in label:
                             line_params[label] = data[label]
                     return line_params
                 def parse_racp(self):
                     data = {}
                     raw_data =  [s.strip() for s in self.f.readlines()]
                     for line in raw_data:
                         if line and '=' in line:
                             label, value = line.strip().split('=')
                             data[label] = value
                     self.data['experiment_type'] = data['EXPERIMENT TYPE']
                     self.data['header_version'] = data['HEADER VERSION']
                     self.data['name'] = data['EXPERIMENT NAME']
                     self.data['ipp'] = float(data['IPP'])
                     self.data['ntx'] = int(data['NTX'])
                     if 'CLOCK DIVIDER' in data:
                         self.data['clock_divider'] = int(data['CLOCK DIVIDER'])
                     else:
                         self.data['clock_divider'] = 1
                     self.data['clock_in'] = float(data['RELOJ'])*self.data['clock_divider']
                     self.data['clock'] = float(data['RELOJ'])
                     self.data['time_before'] = int(data['TR_BEFORE'])
                     self.data['time_after'] = int(data['TR_AFTER'])
                     if 'SYNCHRO DELAY' in data:
                         self.data['sync'] = int(data['SYNCHRO DELAY'])
                     else:
                         self.data['sync'] = 0
                     self.data['lines'] = []
                     if 'SAMPLING REFERENCE' in data:
                         if data['SAMPLING REFERENCE']=='MIDDLE OF FIRST BAUD':
                             self.data['sampling_reference'] = 'first_baud'
                         elif data['SAMPLING REFERENCE']=='MIDDLE OF FIRST SUB-BAUD':
                             self.data['sampling_reference'] = 'sub_baud'
                         else:
                             self.data['sampling_reference'] = 'none'
                     #Add TR line
                     if 'Pulse selection_TR' in data:
                         if 'A,' in data['Pulse selection_TR']:
                             rng = data['Pulse selection_TR'].replace('A,', '')
                             ref = 'TXA'
                         elif 'A' in data['Pulse selection_TR']:
                             rng = data['Pulse selection_TR'].replace('A', '')
                             ref = 'TXA'
                         elif 'B,' in data['Pulse selection_TR']:
                             rng = data['Pulse selection_TR'].replace('B,', '')
                             ref = 'TXB'
                         elif 'B' in data['Pulse selection_TR']:
                             rng = data['Pulse selection_TR'].replace('B', '')
                             ref = 'TXB'
                         else:
                             rng = data['Pulse selection_TR']
                             ref = '0'
                         line = {'type':'tr', 'range': rng if rng else '0', 'TX_ref':ref}
                     else:
                         line = {'type': 'tr', 'range': '0', 'TX_ref': '0'}
                     self.data['lines'].append(line)
                     #Add TX's lines
                     if 'TXA' in data:
                         line = {'type':'tx', 'pulse_width':data['TXA'], 'delays':'0'}
                         if 'Pulse selection_TXA' in data:
                             line['range'] = data['Pulse selection_TXA']
                         else:
                             line['range'] = '0'
                         self.data['lines'].append(line)
                     else:
                         self.data['lines'].append({'type':'tx', 'pulse_width':'0', 'delays':'0', 'range':'0'})
                     if 'TXB' in data:
                         line = {'type':'tx', 'pulse_width':data['TXB'], 'delays':'0'}
                         if 'Pulse selection_TXB' in data:
                             line['range'] = data['Pulse selection_TXB']
                         else:
                             line['range'] = '0'
                         if 'Number of Taus' in data:
                             delays = [data['TAU({0})'.format(i)] for i in range(int(data['Number of Taus']))]
                             line['delays'] = ','.join(delays)
                         self.data['lines'].append(line)
                     else:
                         self.data['lines'].append({'type':'tx', 'pulse_width':'0', 'delays':'0', 'range':'0'})
                     #Add Other lines (4-6)
                     for n in range(4, 7):
                         params = self.get_line_parameters(data, n)
                         labels = params.keys()
                         if 'L%d_FLIP' % n in labels:
                             line = {'type':'flip', 'number_of_flips':data['L%d_FLIP' % n]}
                         elif 'Code Type' in data and n==4:
                             line = {'type':'codes', 'code':data['Code Type'], 'TX_ref':data['L%d_REFERENCE' % n]}
                             if 'Number of Codes' in data:
                                 line['codes'] = [data['COD({})'.format(x)] for x in range(int(data['Number of Codes']))]
                         elif 'Code Type (Line %d)' % n in labels:
                             line = {'type':'codes', 'code':data['Code Type (Line %d)' % n], 'TX_ref':data['L%d_REFERENCE' % n]}
                             if 'Number of Codes (Line %d)' % n in data:
                                 line['codes'] = [data['L{}_COD({})'.format(n, x)] for x in range(int(data['Number of Codes (Line %d)' % n]))]
                         elif 'Sampling Windows (Line %d)' % n in data:
                             line = {'type':'windows', 'TX_ref':data['L%d_REFERENCE' % n]}
                             windows = []
                             for w in range(int(data['Sampling Windows (Line %d)' % n])):
                                 windows.append({'first_height':float(data['L%d_H0(%d)' % (n, w)]),
+                                     'resolution':float(data['L%d_DH(%d)' % (n, w)]),
                                      'number_of_samples':int(data['L%d_NSA(%d)' % (n, w)]),
-                                     'resolution':float(data['L%d_DH(%d)' % (n, w)])}
+                                     'last_height':float(data['L%d_DH(%d)' % (n, w)])*(int(data['L%d_NSA(%d)' % (n, w)])-1)+float(data['L%d_H0(%d)' % (n, w)])
+                                     }
                                     )
                             line['params'] = windows
                         elif 'Line%d' % n in labels and data['Line%d' % n]=='Synchro':
                             line = {'type':'sync', 'invert':0}
                         elif 'L%d Number Of Portions' % n in labels:
                             line = {'type':'prog_pulses'}
                             if 'L%s Portions IPP Periodic' % n in data:
                                 line['periodic'] = 1 if data['L%s Portions IPP Periodic' % n]=='YES' else 0
                             portions = []
                             x = raw_data.index('L%d Number Of Portions=%s' % (n, data['L%d Number Of Portions' % n]))
                             for w in range(int(data['L%d Number Of Portions' % n])):
                                 begin = raw_data[x+1+2*w].split('=')[-1]
                                 end = raw_data[x+2+2*w].split('=')[-1]
                                 portions.append({'begin':int(begin),
                                      'end':int(end)}
                                     )
                             line['params'] = portions
                         elif 'FLIP1' in data and n==5:
                             line = {'type':'flip', 'number_of_flips':data['FLIP1']}
                         elif 'FLIP2' in data and n==6:
                             line = {'type':'flip', 'number_of_flips':data['FLIP2']}
                         else:
                             line = {'type':'none'}
                         self.data['lines'].append(line)
                     #Add line 7 (windows)
                     if 'Sampling Windows' in data:
                         line = {'type':'windows', 'TX_ref':data['L7_REFERENCE']}
                         windows = []
                         x = raw_data.index('Sampling Windows=%s' % data['Sampling Windows'])
                         for w in range(int(data['Sampling Windows'])):
                             h0 = raw_data[x+1+3*w].split('=')[-1]
                             nsa = raw_data[x+2+3*w].split('=')[-1]
                             dh = raw_data[x+3+3*w].split('=')[-1]
                             windows.append({'first_height':float(h0),
                                  'number_of_samples':int(nsa),
-                                 'resolution':float(dh)}
+                                 'resolution':float(dh),
+                                 'last_height':float(h0)+float(dh)*(int(nsa)-1)}
                                 )
                         line['params'] = windows
                         self.data['lines'].append(line)
                     else:
                         self.data['lines'].append({'type':'none'})
                     #Add line 8 (synchro inverted)
                     self.data['lines'].append({'type':'sync', 'invert':1})
                     return
                 def parse_dat(self):
                     pass
                 def get_json(self, indent=None):
                     return json.dumps(self.data, indent=indent)

apps/rc/views.py +8 -3

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

apps/rc/widgets.py +31 -5

             import ast
             import json
             from itertools import chain
             from django import forms
             from django.utils.safestring import mark_safe
             from django.utils.encoding import force_unicode
             from django.utils.html import conditional_escape
             class KmUnitWidget(forms.widgets.TextInput):
                 def render(self, label, value, attrs=None):
                     if isinstance(value, (int, float)):
                         unit = int(value*attrs['km2unit'])
                     elif isinstance(value, basestring):
                         units = []
                         values = [s for s in value.split(',') if s]
                         for val in values:
                             units.append('{0:.0f}'.format(float(val)*attrs['km2unit']))
                         unit = ','.join(units)
                     disabled = 'disabled' if attrs.get('disabled', False) else ''
                     name = attrs.get('name', label)
                     if attrs['id'] in ('id_delays',):
                         input_type = 'text'
                     else:
                         input_type = 'number'
                     if 'line' in attrs:
-                        label += '_{0}'.format(attrs['line'].pk)
+                        label += '_{0}_{1}'.format(attrs['line'].pk, name.split('|')[0])
                     html = '''<div class="col-md-12 col-no-padding">
                     <div class="col-md-5 col-no-padding"><input type="{0}" step="any" {1} class="form-control" id="id_{2}" name="{3}" value="{4}"></div>
                     <div class="col-md-1 col-no-padding">Km</div>
                     <div class="col-md-5 col-no-padding"><input type="{0}" {1} class="form-control" id="id_{2}_unit" value="{5}"></div>
                     <div class="col-md-1 col-no-padding">Units</div></div><br>'''.format(input_type, disabled, label, name, value, unit)
                     script = '''<script type="text/javascript">
                     $(document).ready(function () {{
                       km_fields.push("id_{label}");
                       unit_fields.push("id_{label}_unit");
                       $("#id_{label}").change(function() {{
                         $("#id_{label}_unit").val(str2unit($(this).val()));
                         $("#id_{label}").val(str2km($("#id_{label}_unit").val()));
+                        updateWindows("#id_{label}");
                       }});
                       $("#id_{label}_unit").change(function() {{
-                        $(this).val(parseFloat($(this).val()));
+                        $(this).val(str2int($(this).val()));
                         $("#id_{label}").val(str2km($(this).val()));
+                        updateWindows("#id_{label}");
                       }});
                     }});
                     </script>'''.format(label=label)
                     if disabled:
                         return mark_safe(html)
                     else:
                         return mark_safe(html+script)
             class UnitKmWidget(forms.widgets.TextInput):
                 def render(self, label, value, attrs=None):
                     if isinstance(value, (int, float)):
                         km = value/attrs['km2unit']
                     elif isinstance(value, basestring):
                         kms = []
                         values = [s for s in value.split(',') if s]
                         for val in values:
                             kms.append('{0:.0f}'.format(float(val)/attrs['km2unit']))
                         km = ','.join(kms)
                     disabled = 'disabled' if attrs.get('disabled', False) else ''
                     name = attrs.get('name', label)
                     if 'line' in attrs:
-                        label += '_{0}'.format(attrs['line'].pk)
+                        label += '_{0}_{1}'.format(attrs['line'].pk, name.split('|')[0])
                     html = '''<div class="col-md-12 col-no-padding">
                     <div class="col-md-5 col-no-padding"><input type="number" {0} class="form-control" id="id_{1}_unit" name="{2}" value="{3}"></div>
                     <div class="col-md-1 col-no-padding">Units</div>
                     <div class="col-md-5 col-no-padding"><input type="number" step="any" {4} class="form-control" id="id_{5}" value="{6}"></div>
                     <div class="col-md-1 col-no-padding">Km</div></div>'''.format(disabled, label, name, value, disabled, label, km)
                     script = '''<script type="text/javascript">
                     $(document).ready(function () {{
                       km_fields.push("id_{label}");
                       unit_fields.push("id_{label}_unit");
                       $("#id_{label}").change(function() {{
                         $("#id_{label}_unit").val(str2unit($(this).val()));
                       }});
                       $("#id_{label}_unit").change(function() {{
                         $("#id_{label}").val(str2km($(this).val()));
                       }});
                     }});
                     </script>'''.format(label=label)
                     if disabled:
                         return mark_safe(html)
                     else:
                         return mark_safe(html+script)
             class KmUnitHzWidget(forms.widgets.TextInput):
                 def render(self, label, value, attrs=None):
                     unit = float(value)*attrs['km2unit']
                     if unit%10==0:
                         unit = int(unit)
                     hz = 150000*float(value)**-1
                     disabled = 'disabled' if attrs.get('disabled', False) else ''
                     name = attrs.get('name', label)
                     if 'line' in attrs:
                         label += '_{0}'.format(attrs['line'].pk)
                     html = '''<div class="col-md-12 col-no-padding">
                     <div class="col-md-3 col-no-padding"><input type="number" step="any" {0} class="form-control" id="id_{1}" name="{2}" value="{3}"></div>
                     <div class="col-md-1 col-no-padding">Km</div>
                     <div class="col-md-3 col-no-padding"><input type="number" {4} class="form-control" id="id_{1}_unit" value="{5}"></div>
                     <div class="col-md-1 col-no-padding">Units</div>
                     <div class="col-md-3 col-no-padding"><input type="number" step="any" {4} class="form-control" id="id_{1}_hz" value="{6}"></div>
                     <div class="col-md-1 col-no-padding">Hz</div>
                     </div>'''.format(disabled, label, name, value, disabled, unit, hz)
                     script = '''<script type="text/javascript">
                     $(document).ready(function () {{
                       km_fields.push("id_{label}");
                       unit_fields.push("id_{label}_unit");
                       $("#id_{label}").change(function() {{
                         $("#id_{label}_unit").val(str2unit($(this).val()));
+                        $("#id_{label}").val(str2km($("#id_{label}_unit").val()));
                         $("#id_{label}_hz").val(str2hz($(this).val()));
                         updateDc();
                       }});
                       $("#id_{label}_unit").change(function() {{
                         $(this).val(Math.round(parseFloat($(this).val())/10)*10);
                         $("#id_{label}").val(str2km($(this).val()));
                         $("#id_{label}_hz").val(str2hz($("#id_{label}").val()));
                         updateDc();
                       }});
                       $("#id_{label}_hz").change(function() {{
                         $("#id_{label}").val(str2hz($(this).val()));
                         $("#id_{label}_unit").val(str2unit($("#id_{label}").val()));
                         updateDc();
                       }});
                     }});
                     </script>'''.format(label=label)
                     if disabled:
                         return mark_safe(html)
                     else:
                         return mark_safe(html+script)
             class KmUnitDcWidget(forms.widgets.TextInput):
                 def render(self, label, value, attrs=None):
                     unit = int(float(value)*attrs['km2unit'])
                     disabled = 'disabled' if attrs.get('disabled', False) else ''
                     name = attrs.get('name', label)
                     label += '_{0}'.format(attrs['line'].pk)
                     dc = float(json.loads(attrs['line'].params)['pulse_width'])*100/attrs['line'].rc_configuration.ipp
                     html = '''<div class="col-md-12 col-no-padding">
                     <div class="col-md-3 col-no-padding"><input type="number" step="any" {0} class="form-control" id="id_{1}" name="{2}" value="{3}"></div>
                     <div class="col-md-1 col-no-padding">Km</div>
                     <div class="col-md-3 col-no-padding"><input type="number" {4} class="form-control" id="id_{1}_unit" value="{5}"></div>
                     <div class="col-md-1 col-no-padding">Units</div>
                     <div class="col-md-3 col-no-padding"><input type="number" step="any" {4} class="form-control" id="id_{1}_dc" value="{6}"></div>
                     <div class="col-md-1 col-no-padding">DC[%]</div>
                     </div>'''.format(disabled, label, name, value, disabled, unit, dc)
                     script = '''<script type="text/javascript">
                     $(document).ready(function () {{
                       km_fields.push("id_{label}");
                       unit_fields.push("id_{label}_unit");
                       dc_fields.push("id_{label}");
                       $("#id_{label}").change(function() {{
                         $("#id_{label}_unit").val(str2unit($(this).val()));
+                        $("#id_{label}").val(str2km($("#id_{label}_unit").val()));
                         $("#id_{label}_dc").val(str2dc($("#id_{label}").val()));
                       }});
                       $("#id_{label}_unit").change(function() {{
                         $("#id_{label}").val(str2km($(this).val()));
                         $("#id_{label}_dc").val(str2dc($("#id_{label}").val()));
                       }});
                       $("#id_{label}_dc").change(function() {{
                         $("#id_{label}").val(parseFloat($(this).val())*100/parseFloat($("#id_ipp").val()));
                         $("#id_{label}_unit").val(str2unit($("#id_{label}").val()));
                       }});
                     }});
                     </script>'''.format(label=label)
                     if disabled:
                         return mark_safe(html)
                     else:
                         return mark_safe(html+script)
             class DefaultWidget(forms.widgets.TextInput):
                 def render(self, label, value, attrs=None):
                     disabled = 'disabled' if attrs.get('disabled', False) else ''
+                    itype = 'number' if label in ('number_of_samples', 'last_height') else 'text'
                     name = attrs.get('name', label)
+                    if 'line' in attrs:
+                        label += '_{0}_{1}'.format(attrs['line'].pk, name.split('|')[0])
+                    html = '<div class="col-md-12 col-no-padding"><div class="col-md-5 col-no-padding"><input {0} type="{1}" class="form-control" id="id_{2}" name="{3}" value="{4}"></div></div>'.format(disabled, itype, label, name, value)
+                    if 'last_height' in label or 'number_of_samples' in label:
+                        script = '''<script type="text/javascript">
+                    $(document).ready(function () {{
+                      $("#id_{label}").change(function() {{
+                        updateWindows("#id_{label}");
+                      }});
+                    }});
+                    </script>'''.format(label=label)
+                    else:
+                        script = ''
+                    if disabled:
+                        return mark_safe(html)
+                    else:
+                        return mark_safe(html+script)
-                    html = '<div class="col-md-12 col-no-padding"><div class="col-md-5 col-no-padding"><input {0} type="text" class="form-control" id="id_{1}" name="{2}" value="{3}"></div></div>'.format(disabled, label, name, value)
                     return mark_safe(html)
             class HiddenWidget(forms.widgets.HiddenInput):
                 def render(self, label, value, attrs=None):
                     disabled = 'disabled' if attrs.get('disabled', False) else ''
                     name = self.attrs.get('name', label)
                     html = '<input {0} type="hidden" class="form-control" id="id_{1}" name="{2}" value="{3}">'.format(disabled, label, name, value)
                     return mark_safe(html)
             class CodesWidget(forms.widgets.Textarea):
                 def render(self, label, value, attrs=None):
                     disabled = 'disabled' if attrs.get('disabled', False) else ''
                     name = attrs.get('name', label)
                     if '[' in value:
                         value = ast.literal_eval(value)
                     if isinstance(value, list):
                         codes = '\r\n'.join(value)
                     else:
                         codes = value
                     html = '<textarea rows="5" {0} class="form-control" id="id_{1}" name="{2}" style="white-space:nowrap; overflow:scroll;">{3}</textarea>'.format(disabled, label, name, codes)
                     return mark_safe(html)
             class HCheckboxSelectMultiple(forms.CheckboxSelectMultiple):
                 def render(self, name, value, attrs=None, choices=()):
                     if value is None: value = []
                     has_id = attrs and 'id' in attrs
                     final_attrs = self.build_attrs(attrs, name=name)
                     output = [u'<br><ul>']
                     # Normalize to strings
                     str_values = set([force_unicode(v) for v in value])
                     for i, (option_value, option_label) in enumerate(chain(self.choices, choices)):
                         # If an ID attribute was given, add a numeric index as a suffix,
                         # so that the checkboxes don't all have the same ID attribute.
                         if has_id:
                             final_attrs = dict(final_attrs, id='%s_%s' % (attrs['id'], i))
                             label_for = u' for="%s"' % final_attrs['id']
                         else:
                             label_for = ''
                         cb = forms.CheckboxInput(final_attrs, check_test=lambda value: value in str_values)
                         option_value = force_unicode(option_value)
                         rendered_cb = cb.render(name, option_value)
                         option_label = conditional_escape(force_unicode(option_label))
                         output.append(u'<span><label%s>%s %s</label></span>' % (label_for, rendered_cb, option_label))
                     output.append(u'</div><br>')
                     return mark_safe(u'\n'.join(output))
   No newline at end of file

devices/rc/api.py +26 -8

             '''
             Created on Dec 2, 2014
             @author: Miguel Urco
             eth_device decorator is used to implement an api to ethernet devices.
             When eth_device decorator is used it adds two parameters to any function (ip and port)
             #Definition
             @eth_device
             def enable_rf()
                 cmd = "xxxxx"
                 payload = "xxxxxx"
                 return cmd, payload
             #How to call this function:
             answer = enable_rf(ip, port)
             '''
             import data
             from devices.jro_device import eth_device, IdClass
             ID_CLASS = IdClass["rc"]
             CMD_RESET           =0X01
             CMD_ENABLE          =0X02
             CMD_CHANGEIP        =0X03
             CMD_STATUS          =0X04
             CMD_DISABLE         =0X02
             CMD_ECHO            =0XFE
             RC_CMD_RESET        =0X10
             RC_CMD_WRITE        =0x50
             RC_CMD_READ         =0x8000
+            RC_CMD_ENABLE       =0X24
+            RC_CMD_DISABLE      =0X00
             @eth_device(ID_CLASS)
             def reset():
                 cmd = CMD_RESET
                 payload = ""
                 return cmd, payload
             @eth_device(ID_CLASS)
             def change_ip(ip, mask="255.255.255.0", gateway="0.0.0.0"):
                 cmd = CMD_CHANGEIP
                 payload = ip + '/' + mask + '/' + gateway
                 return cmd, payload
             @eth_device(ID_CLASS)
             def status():
                 cmd = CMD_STATUS
                 payload = ""
                 return cmd, payload
             @eth_device(ID_CLASS)
             def echo():
                 cmd = CMD_ECHO
                 payload = ""
                 return cmd, payload
             @eth_device(ID_CLASS)
+            def enable():
+                cmd = RC_CMD_ENABLE
+                payload = chr(0x01)
+                return cmd, payload
+            @eth_device(ID_CLASS)
+            def disable():
+                cmd = RC_CMD_DISABLE
+                payload = chr(0x00)
+                return cmd, payload
+            @eth_device(ID_CLASS)
             def read_all_device():
                 payload = ""
-                return CR_CMD_READ, payload
+                return RC_CMD_READ, payload
             @eth_device(ID_CLASS)
             def write_all_device(payload):
-                return CR_CMD_WRITE, payload
+                return RC_CMD_WRITE, payload
             def read_config(ip, port):
                 """
                 Output:
                     parms   : Dictionary with keys
                 """
                 payload = read_all_device(ip, port)
                 return data.rc_str_to_dict(payload)
             def write_config(ip, port, parms):
                 """
                 Input:
                     ip      :
                     port    :
                     parms   : Dictionary with keys
                 """
-                payload = data.dict_to_rc_str(parms)
+                payload = write_ram_memory(parms['pulses'], parms['delays'])
                 answer = write_all_device(ip, port, payload)
                 return answer
             def __get_low_byte(valor):
-               return ord(valor & 0x00FF)
+                return ord(valor & 0x00FF)
             def __get_high_byte(valor):
-               return ord((valor & 0xFF00) >> 8)
+                return ord((valor & 0xFF00) >> 8)
-            @eth_device(ID_CLASS)
             def write_ram_memory(vector_valores, vector_tiempos):
                 l1 = len(vector_valores)
                 l2 = len(vector_tiempos)
                 cad = ""
                 for i in range(l1):
-                  cad += ord(84) + __get_low_byte(vector_valores[i]) + ord(85) + __get_high_byte(vector_valores[i]) + \
+                    cad += ord(84) + __get_low_byte(vector_valores[i]) + ord(85) + __get_high_byte(vector_valores[i]) + \
                          ord(84) + __get_low_byte(vector_tiempos[i]) + ord(85) + __get_high_byte(vector_tiempos[i])
-                return RC_CMD_WRITE, cad
+                return cad
             if __name__ == '__main__':
                 ip = "10.10.20.150"
                 port = 2000
                 print status(ip, port)
                 print read_config(ip, port)

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