radarsys Commit - r328:e61e12b2d8be · Jicamarca Repository

Add compatibility with embed CGS in RC

Juan C. Espinoza -

r328:e61e12b2d8be

parent child

Context file:

r328:e61e12b2d8be

Collapse all files

.env +3 -3

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

apps/main/templates/dev_conf.html +2 0

             {% extends "base.html" %}
             {% load bootstrap3 %}
             {% load static %}
             {% load main_tags %}
             {% 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="{{ dev_conf.get_absolute_url_delete }}"><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 %}
                     {% 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>
                 {% if dev_conf.device.device_type.name != 'abs' %}
                 <li><a href="{{ dev_conf.get_absolute_url_read }}"><span class="glyphicon glyphicon-upload" aria-hidden="true"></span> Read</a></li>
                 {% endif %}
               </ul>
             </span>
             {% endblock %}
+            {% block content-detail %}
             <table class="table table-bordered">
             	<tr>
             		<th>Status</th>
             		<td class="text-{{dev_conf.device.status_color}}"><strong> {% if dev_conf.device.device_type.name == 'abs' %} {{connected_modules}} {% else %} {{dev_conf.device.get_status_display}}{% endif %}</strong></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>
+            {% endblock %}
             {% block extra-content %}
             {% endblock %}
             {% 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/views.py +4 -1

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

apps/rc/admin.py +2 -1

             from django.contrib import admin
-            from .models import RCConfiguration, RCLine, RCLineType, RCLineCode
+            from .models import RCConfiguration, RCLine, RCLineType, RCLineCode, RCClock
             # Register your models here.
             admin.site.register(RCConfiguration)
             admin.site.register(RCLine)
             admin.site.register(RCLineType)
             admin.site.register(RCLineCode)
+            admin.site.register(RCClock)

apps/rc/forms.py +33 -2

             import os
             import json
             from django import forms
             from django.utils.safestring import mark_safe
             from apps.main.models import Device
             from apps.main.forms import add_empty_choice
-            from .models import RCConfiguration, RCLine, RCLineType, RCLineCode
+            from .models import RCConfiguration, RCLine, RCLineType, RCLineCode, RCClock
             from .widgets import KmUnitWidget, KmUnitHzWidget, KmUnitDcWidget, UnitKmWidget, DefaultWidget, CodesWidget, HiddenWidget, HCheckboxSelectMultiple
             def create_choices_from_model(model, conf_id, all_choice=False):
                 if model=='RCLine':
                     instance = RCConfiguration.objects.get(pk=conf_id)
                     choices =  [(line.pk, line.get_name()) for line in instance.get_lines(line_type__name='tx')]
                     if all_choice:
                         choices = add_empty_choice(choices, label='All')
                 else:
                     instance = globals()[model]
                     choices = instance.objects.all().values_list('pk', 'name')
                 return choices
             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 RCConfigurationForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(RCConfigurationForm, self).__init__(*args, **kwargs)
                     instance = getattr(self, 'instance', None)
                     if instance and instance.pk:
                         devices = Device.objects.filter(device_type__name='rc')
                         if instance.experiment:
                             self.fields['experiment'].widget.attrs['read_only'] = True
                             #self.fields['experiment'].widget.choices = [(instance.experiment.id, instance.experiment)]
                         self.fields['device'].widget.choices = [(device.id, device) for device in devices]
                         self.fields['ipp'].widget = KmUnitHzWidget(attrs={'km2unit':instance.km2unit})
                         self.fields['clock'].widget.attrs['readonly'] = True
                     self.fields['time_before'].label = mark_safe(self.fields['time_before'].label)
                     self.fields['time_after'].label = mark_safe(self.fields['time_after'].label)
                     if 'initial' in kwargs and 'experiment' in kwargs['initial'] and kwargs['initial']['experiment'] not in (0, '0'):
                         self.fields['experiment'].widget.attrs['readonly'] = True
                 class Meta:
                     model = RCConfiguration
-                    exclude = ('type', 'parameters', 'status', 'total_units', 'mix', 'author', 'hash')
+                    exclude = ('type', 'parameters', 'status', 'total_units', 'mix', 'author', 'hash', 'clock_in')
                 def clean(self):
                     form_data = super(RCConfigurationForm, self).clean()
                     if 'clock_divider' in form_data:
                         if form_data['clock_divider']<1:
                             self.add_error('clock_divider', 'Invalid Value')
                         #else:
                         #    if form_data['ipp']*(20./3*(form_data['clock_in']/form_data['clock_divider']))%10!=0:
                         #        self.add_error('ipp', 'Invalid IPP units={}'.format(form_data['ipp']*(20./3*(form_data['clock_in']/form_data['clock_divider']))))
                     return form_data
                 def save(self, *args, **kwargs):
                     conf = super(RCConfigurationForm, self).save(*args, **kwargs)
                     conf.total_units = conf.ipp*conf.ntx*conf.km2unit
                     conf.save()
                     return conf
             class RCMixConfigurationForm(forms.Form):
                 clock_in = forms.CharField(widget=forms.HiddenInput())
                 clock_divider = forms.CharField(widget=forms.HiddenInput())
                 name = forms.CharField()
                 experiment = forms.ChoiceField()
                 mode = forms.ChoiceField(widget=forms.RadioSelect(),
                                          choices=[(0, 'Parallel'), (1, 'Sequence')],
                                          initial=0)
                 operation = forms.ChoiceField(widget=forms.RadioSelect(),
                                               choices=[(0, 'OR'), (1, 'XOR'), (2, 'AND'), (3, 'NAND')],
                                               initial=1)
                 delay = forms.CharField()
                 mask = forms.MultipleChoiceField(
                     choices=[(0, 'L1'),(1, 'L2'),(2, 'L3'),(3, 'L4'),(4, 'L5'),(5, 'L6'),(6, 'L7'),(7, 'L8'),
                     (8, 'L9'),(9, 'L10'),(10, 'L11'),(11, 'L12'),(12, 'L13'),(13, 'L14'),(14, 'L15'),(15, 'L16')],
                     widget=HCheckboxSelectMultiple())
                 result = forms.CharField(required=False,
                                          widget=forms.Textarea(attrs={'readonly':True, 'rows':5, 'class':'tabuled'}))
                 def __init__(self, *args, **kwargs):
                     confs = kwargs.pop('confs', [])
                     if confs:
                         km2unit = confs[0].km2unit
                         clock_in = confs[0].clock_in
                         clock_divider = confs[0].clock_divider
                     else:
                         km2unit = clock_in = clock_divider = 0
                     super(RCMixConfigurationForm, self).__init__(*args, **kwargs)
                     self.fields['experiment'].choices = [(conf.pk, '{} | {}'.format(conf.pk, conf.name)) for conf in confs]
                     self.fields['delay'].widget = KmUnitWidget(attrs = {'km2unit':km2unit})
                     self.fields['clock_in'].initial = clock_in
                     self.fields['clock_divider'].initial = clock_divider
             class RCLineForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     self.extra_fields = kwargs.pop('extra_fields', [])
                     super(RCLineForm, self).__init__(*args, **kwargs)
                     if 'initial' in kwargs and 'line_type' in kwargs['initial']:
                         line_type = RCLineType.objects.get(pk=kwargs['initial']['line_type'])
                         if 'code_id' in kwargs['initial']:
                             model_initial = kwargs['initial']['code_id']
                         else:
                             model_initial = 0
                         params = json.loads(line_type.params)
                         for label, value in self.extra_fields.items():
                             if label=='params':
                                 continue
                             if 'model' in params[label]:
                                 self.fields[label] = forms.ChoiceField(choices=create_choices_from_model(params[label]['model'],
                                                                                                          kwargs['initial']['rc_configuration']),
                                                                        initial=model_initial)
                             else:
                                 if label=='codes' and 'code_id' in kwargs['initial']:
                                     self.fields[label] = forms.CharField(initial=RCLineCode.objects.get(pk=kwargs['initial']['code_id']).codes)
                                 else:
                                     self.fields[label] = forms.CharField(initial=value['value'])
                                 if label=='codes':
                                     self.fields[label].widget = CodesWidget()
                     if self.data:
                         line_type = RCLineType.objects.get(pk=self.data['line_type'])
                         if 'code_id' in self.data:
                             model_initial = self.data['code_id']
                         else:
                             model_initial = 0
                         params = json.loads(line_type.params)
                         for label, value in self.extra_fields.items():
                             if label=='params':
                                 continue
                             if 'model' in params[label]:
                                 self.fields[label] = forms.ChoiceField(choices=create_choices_from_model(params[label]['model'],
                                                                                                          self.data['rc_configuration']),
                                                                        initial=model_initial)
                             else:
                                 if label=='codes' and 'code' in self.data:
                                     self.fields[label] = forms.CharField(initial=self.data['codes'])
                                 else:
                                     self.fields[label] = forms.CharField(initial=self.data[label])
                                 if label=='codes':
                                     self.fields[label].widget = CodesWidget()
                 class Meta:
                     model = RCLine
                     fields = ('rc_configuration', 'line_type', 'channel')
                     widgets = {
                         'channel': forms.HiddenInput(),
                     }
                 def clean(self):
                     form_data = self.cleaned_data
                     if 'code' in self.data and self.data['TX_ref']=="0":
                         self.add_error('TX_ref', 'Choose a valid TX reference')
                     if RCLineType.objects.get(pk=self.data['line_type']).name=='mix':
                         self.add_error('line_type', 'Invalid Line type')
                     return form_data
                 def save(self):
                     line = super(RCLineForm, self).save()
                     #auto add channel
                     line.channel = RCLine.objects.filter(rc_configuration=line.rc_configuration).count()-1
                     #auto add position for TX, TR & CODE
                     if line.line_type.name in ('tx', ):
                         line.position = RCLine.objects.filter(rc_configuration=line.rc_configuration, line_type=line.line_type).count()-1
                     #save extra fields in params
                     params = {}
                     for label, value in self.extra_fields.items():
                         if label=='params':
                             params['params'] = []
                         elif label=='codes':
                             params[label] = [s for s in self.data[label].split('\r\n') if s]
                         else:
                             params[label] = self.data[label]
                     line.params = json.dumps(params)
                     line.save()
                     return
             class RCLineViewForm(forms.Form):
                 def __init__(self, *args, **kwargs):
                     extra_fields = kwargs.pop('extra_fields')
                     line = kwargs.pop('line')
                     subform = kwargs.pop('subform', False)
                     super(RCLineViewForm, self).__init__(*args, **kwargs)
                     if subform:
                         params = json.loads(line.line_type.params)['params']
                     else:
                         params = json.loads(line.line_type.params)
                     for label, value in extra_fields.items():
                         if label=='params':
                             continue
                         if 'ref' in label:
                             if value in (0, '0'):
                                 value = 'All'
                             else:
                                 value = RCLine.objects.get(pk=value).get_name()
                         elif label=='code':
                             value = RCLineCode.objects.get(pk=value).name
                         self.fields[label] = forms.CharField(initial=value)
                         if 'widget' in params[label]:
                             km2unit = line.rc_configuration.km2unit
                             if params[label]['widget']=='km':
                                 self.fields[label].widget = KmUnitWidget(attrs={'line':line, 'km2unit':km2unit, 'disabled':True})
                             elif params[label]['widget']=='unit':
                                 self.fields[label].widget = UnitKmWidget(attrs={'line':line, 'km2unit':km2unit, 'disabled':True})
                             elif params[label]['widget']=='dc':
                                 self.fields[label].widget = KmUnitDcWidget(attrs={'line':line, 'km2unit':km2unit, 'disabled':True})
                             elif params[label]['widget']=='codes':
                                 self.fields[label].widget = CodesWidget(attrs={'line':line, 'km2unit':km2unit, 'disabled':True})
                         else:
                             self.fields[label].widget = DefaultWidget(attrs={'disabled':True})
             class RCLineEditForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     extra_fields = kwargs.pop('extra_fields', [])
                     conf = kwargs.pop('conf', False)
                     line = kwargs.pop('line')
                     subform = kwargs.pop('subform', False)
                     super(RCLineEditForm, self).__init__(*args, **kwargs)
                     if subform is not False:
                         params = json.loads(line.line_type.params)['params']
                         count = subform
                     else:
                         params = json.loads(line.line_type.params)
                         count = -1
                     for label, value in extra_fields.items():
                         if label in ('params',):
                             continue
                         if 'help' in params[label]:
                             help_text = params[label]['help']
                         else:
                             help_text = ''
                         if 'model' in params[label]:
                             if line.line_type.name=='tr':
                                 all_choice = True
                             else:
                                 all_choice = False
                             self.fields[label] = forms.ChoiceField(choices=create_choices_from_model(params[label]['model'], conf.id, all_choice=all_choice),
                                                         initial=value,
                                                         widget=forms.Select(attrs={'name':'%s|%s|%s' % (count, line.id, label)}),
                                                         help_text=help_text)
                         else:
                             self.fields[label] = forms.CharField(initial=value, help_text=help_text)
                             if label in ('code', ):
                                 self.fields[label].widget = HiddenWidget(attrs={'name':'%s|%s|%s' % (count, line.id, label)})
                             elif 'widget' in params[label]:
                                 km2unit = line.rc_configuration.km2unit
                                 if params[label]['widget']=='km':
                                     self.fields[label].widget = KmUnitWidget(attrs={'line':line, 'km2unit':km2unit, 'name':'%s|%s|%s' % (count, line.id, label)})
                                 elif params[label]['widget']=='unit':
                                     self.fields[label].widget = UnitKmWidget(attrs={'line':line, 'km2unit':km2unit, 'name':'%s|%s|%s' % (count, line.id, label)})
                                 elif params[label]['widget']=='dc':
                                     self.fields[label].widget = KmUnitDcWidget(attrs={'line':line, 'km2unit':km2unit, 'name':'%s|%s|%s' % (count, line.id, label)})
                                 elif params[label]['widget']=='codes':
                                     self.fields[label].widget = CodesWidget(attrs={'line':line, 'km2unit':km2unit, 'name':'%s|%s|%s' % (count, line.id, label)})
                             else:
                                 self.fields[label].widget = DefaultWidget(attrs={'line':line, 'name':'%s|%s|%s' % (count, line.id, label)})
                 class Meta:
                     model = RCLine
                     exclude = ('rc_configuration', 'line_type', 'channel', 'position', 'params', 'pulses')
             class RCSubLineEditForm(forms.Form):
                 def __init__(self, *args, **kwargs):
                     extra_fields = kwargs.pop('extra_fields')
                     count = kwargs.pop('count')
                     line = kwargs.pop('line')
                     super(RCSubLineEditForm, self).__init__(*args, **kwargs)
                     for label, value in extra_fields.items():
                         self.fields[label] = forms.CharField(initial=value,
                                                              widget=forms.TextInput(attrs={'name':'%s|%s|%s' % (count, line, label)}))
             class RCImportForm(forms.Form):
                 file_name = ExtFileField(extensions=['.racp', '.json', '.dat'])
             class RCLineCodesForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(RCLineCodesForm, self).__init__(*args, **kwargs)
                     if 'initial' in kwargs:
                         self.fields['code'] = forms.ChoiceField(choices=RCLineCode.objects.all().values_list('pk', 'name'),
                                                                 initial=kwargs['initial']['code'])
                     if 'instance' in kwargs:
                         self.fields['code'] = forms.ChoiceField(choices=RCLineCode.objects.all().values_list('pk', 'name'),
                                                                 initial=kwargs['instance'].pk)
                     self.fields['codes'].widget = CodesWidget()
                 class Meta:
                     model = RCLineCode
                     exclude = ('name',)
+            class RCClockForm(forms.ModelForm):
+                def __init__(self, *args, **kwargs):
+                    super(RCClockForm, self).__init__(*args, **kwargs)
+                    instance = getattr(self, 'instance', None)
+                    if instance is not None and instance.mode:
+                        self.fields['multiplier'].widget.attrs['readonly'] = True
+                        self.fields['divisor'].widget.attrs['readonly'] = True
+                        self.fields['reference'].widget.attrs['readonly'] = True
+                class Meta:
+                    model = RCClock
+                    exclude = ('rc_configuration',)
+                def clean(self):
+                    form_data = self.cleaned_data
+                    if form_data['mode'] is True and float(form_data['frequency']) not in (60., 55.):
+                        self.add_error('frequency', 'Only 60 and 55 are valid values in auto mode')
+                    elif form_data['mode'] is False:
+                        if form_data['reference']==0 and not 24<=form_data['multiplier']<=36:
+                            self.add_error('multiplier', 'For 25MHz, valid values are between 24 and 36')
+                        elif form_data['reference']==1 and not 60<=form_data['multiplier']<=90:
+                            self.add_error('multiplier', 'For 10MHz, valid values are between 60 and 90')
+                    return form_data
  No newline at end of file

apps/rc/models.py +23 0

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

apps/rc/static/js/cr.js +44 -3

             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 += ",";
               }
               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() {
+            function updateClock() {
-                $("#id_clock").val(parseFloat($('#id_clock_in').val())/parseFloat($('#id_clock_divider').val()));
+              if ($("#id_reference").val()==0){
+                var ref = 25;
+              }else{
+                var ref = 10;
+              }
+              $("#id_frequency").val(parseFloat($('#id_multiplier').val())*ref/parseFloat($('#id_divisor').val()));
+              $("#id_clock").val(parseFloat($('#id_frequency').val())/parseFloat($('#id_clock_divider').val()));
+              updateUnits();
+            }
+              $("#id_frequency").change(function() {
+                $("#id_clock").val(parseFloat($('#id_frequency').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()));
+                $("#id_clock").val(parseFloat($('#id_frequency').val())/parseFloat($('#id_clock_divider').val()));
                 updateUnits();
               });
+              $("#id_mode").change(function() {
+                if ($("#id_mode").val()=="False"){
+                  $('#id_multiplier').removeProp("readonly");
+                  $('#id_divisor').removeProp("readonly");
+                  $('#id_reference').removeProp("readonly");
+                  $('#id_frequency').prop("readonly", true);
+                  updateClock();
+                }else{
+                  $('#id_frequency').removeProp("readonly");
+                  $('#id_multiplier').prop("readonly", true);
+                  $('#id_divisor').prop("readonly", true);
+                  $('#id_reference').prop("readonly", true);
+                  $('#id_reference').val(1)
+                  $('#id_frequency').val(60);
+                  $("#id_clock").val(parseFloat($('#id_frequency').val())/parseFloat($('#id_clock_divider').val()));
+                }
+              });
+              $("#id_multiplier").change(function() {
+                updateClock();
+              });
+              $("#id_divisor").change(function() {
+                updateClock();
+              });
+              $("#id_reference").change(function() {
+                updateClock();
+              });
  No newline at end of file

apps/rc/templates/rc_conf.html +34 0

             {% 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 content-detail %}
+            <h2>Clock</h2>
+            <table class="table table-bordered">
+              <tr>
+                <th>Mode</th>
+                <td>{{clock.get_mode_display}}</td>
+              </tr>
+              <tr>
+                <th>Reference</th>
+                <td>{{clock.get_reference_display}}</td>
+              </tr>
+              <tr>
+                <th>Frequency</th>
+                <td>{{clock.frequency}}</td>
+              </tr>
+            </table>
+            <div class="clearfix"></div>
+            <h2>RC</h2>
+            <table class="table table-bordered">
+            	<tr>
+            		<th>Status</th>
+            		<td class="text-{{dev_conf.device.status_color}}"><strong>{{dev_conf.device.get_status_display}}</strong></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>
+            {% endblock %}
             {% block extra-content %}
             <div class="clearfix"></div>
             <h2>RC Lines</h2>
             <br>
             <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 %}

apps/rc/templates/rc_conf_edit.html +5 -1

             {% 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 %}
+              <h2>Clock</h2>
+              {% bootstrap_form form_clock layout='horizontal' size='medium' %}
+              <div style="clear: both;"></div>
+              <h2>RC</h2>
               {% bootstrap_form form layout='horizontal' size='medium' %}
               <div style="clear: both;"></div>
-              <h2>RC Lines</h2><hr>
+              <h2>RC Lines</h2>
               <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/views.py +16 -6

             import json
             from django.contrib import messages
             from django.utils.safestring import mark_safe
             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from django.contrib.auth.decorators import login_required
             from apps.main.models import Experiment, Device
             from apps.main.views import sidebar
-            from .models import RCConfiguration, RCLine, RCLineType, RCLineCode
+            from .models import RCConfiguration, RCLine, RCLineType, RCLineCode, RCClock
-            from .forms import RCConfigurationForm, RCLineForm, RCLineViewForm, RCLineEditForm, RCImportForm, RCLineCodesForm
+            from .forms import RCConfigurationForm, RCLineForm, RCLineViewForm, RCLineEditForm, RCImportForm, RCLineCodesForm, RCClockForm
             def conf(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 lines = RCLine.objects.filter(rc_configuration=conf).order_by('channel')
+                clk = RCClock.objects.get(rc_configuration=conf)
                 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['clock'] = clk
                 kwargs['dev_conf'] = conf
                 kwargs['rc_lines'] = lines
-                kwargs['dev_conf_keys'] = ['ipp_unit', 'ntx', 'clock_in', 'clock_divider', 'clock',
+                kwargs['dev_conf_keys'] = ['ipp_unit', 'ntx', 'clock_divider', 'clock',
                                            'time_before', 'time_after', 'sync', 'sampling_reference',
                                            'control_tx', 'control_sw']
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'Detail'
                 kwargs['button'] = 'Edit Configuration'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'rc_conf.html', kwargs)
             @login_required
             def conf_edit(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
+                clock = RCClock.objects.get(rc_configuration=conf)
                 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)
+                    form_clock = RCClockForm(instance=clock)
                 elif request.method=='POST':
                     line_data = {}
                     conf_data = {}
+                    clock_data = {}
                     extras = []
                     #classified post fields
                     for label,value in request.POST.items():
                         if label=='csrfmiddlewaretoken':
                             continue
                         if label.count('|')==0:
+                            if label in ('mode', 'multiplier', 'divisor', 'reference', 'frequency'):
+                                clock_data[label] = value
+                            else:
                                 conf_data[label] = value
                             continue
                         elif label.split('|')[0]!='-1':
                             extras.append(label)
                             continue
                         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_clock = RCClockForm(clock_data, instance=clock)
+                    form = RCConfigurationForm(conf_data, instance=conf)
+                    if form_clock.is_valid() and form.is_valid():
+                        form_clock.save()
                         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['form_clock'] = form_clock
                 kwargs['rc_lines'] = lines
                 kwargs['edit'] = True
                 kwargs['title'] = 'RC Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 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.decode('utf8')}
                     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:
                             data = conf.import_from_file(request.FILES['file_name'])
                             conf.dict_to_parms(data)
                             conf.update_pulses()
                             messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name'])
                             return redirect(conf.get_absolute_url_edit())
                         except Exception as e:
                             messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], repr(e)))
                 else:
                     messages.warning(request, 'Your current configuration will be replaced')
                     form = 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(km=km)
                 kwargs = {}
                 kwargs['no_sidebar'] = True
                 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)
             def plot_pulses2(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_pulses2(km=km)
                 kwargs = {}
                 kwargs['no_sidebar'] = True
                 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)
             def conf_raw(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 raw = conf.write_device(raw=True)
                 return HttpResponse(raw, content_type='application/json')

postgres/docker-entrypoint-initdb.d/create_db.sh +9 -5

@@ -1,5 +1,9
1	#!/bin/~~env~~ bash	1	#!/bin/bash
2	echo "Creating database..."	2	set -e
3	psql -U postgres -c "CREATE USER $POSTGRES_USER WITH PASSWORD '$POSTGRES_PASSWORD';"	3
4	psql -U postgres -c "CREATE DATABASE $POSTGRES_DB_NAME;"	4	echo "Creating database & user"
5	psql -U postgres -c "GRANT ALL PRIVILEGES ON DATABASE $POSTGRES_DB_NAME to $POSTGRES_USER;"	5	psql -v --username "postgres" --dbname "postgres" <<-EOSQL
		6	CREATE USER $DB_USER WITH PASSWORD '$DB_PASSWORD';
		7	CREATE DATABASE $DB_NAME;
		8	GRANT ALL PRIVILEGES ON DATABASE $DB_NAME TO $DB_USER;
		9	EOSQL

radarsys/settings.py +7 -7

             """
             Django settings for radarsys project.
             Generated by 'django-admin startproject' using Django 1.8.6.
             For more information on this file, see
             https://docs.djangoproject.com/en/1.8/topics/settings/
             For the full list of settings and their values, see
             https://docs.djangoproject.com/en/1.8/ref/settings/
             """
             # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
             import os
             BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
             # Quick-start development settings - unsuitable for production
             # See https://docs.djangoproject.com/en/1.8/howto/deployment/checklist/
             # SECURITY WARNING: keep the secret key used in production secret!
             SECRET_KEY = 'xshb$k5fc-+j16)cvyffj&9u__0q3$l!hieh#+tbzqg)*f^km0'
             # SECURITY WARNING: don't run with debug turned on in production!
             DEBUG = True
             ALLOWED_HOSTS = ['*']
             # Application definition
             INSTALLED_APPS = (
                 'django.contrib.admin',
                 'django.contrib.auth',
                 'django.contrib.contenttypes',
                 'django.contrib.sessions',
                 'django.contrib.messages',
                 'django.contrib.staticfiles',
                 'bootstrap3',
                 'polymorphic',
                 'apps.accounts',
                 'apps.main',
                 'apps.misc',
                 'apps.rc',
                 'apps.dds',
                 'apps.jars',
                 'apps.usrp',
                 'apps.abs',
                 'apps.cgs',
             )
             MIDDLEWARE_CLASSES = (
                 'django.contrib.sessions.middleware.SessionMiddleware',
                 'django.middleware.common.CommonMiddleware',
                 'django.middleware.csrf.CsrfViewMiddleware',
                 'django.contrib.auth.middleware.AuthenticationMiddleware',
                 'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
                 'django.contrib.messages.middleware.MessageMiddleware',
                 'django.middleware.clickjacking.XFrameOptionsMiddleware',
                 'django.middleware.security.SecurityMiddleware',
             )
             ROOT_URLCONF = 'radarsys.urls'
             TEMPLATES = [
                 {
                     'BACKEND': 'django.template.backends.django.DjangoTemplates',
                     'DIRS': [os.path.join(BASE_DIR, "templates").replace('\\', '/'),],
                     'APP_DIRS': True,
                     'OPTIONS': {
                         'context_processors': [
                             'django.template.context_processors.debug',
                             'django.template.context_processors.request',
                             'django.contrib.auth.context_processors.auth',
                             'django.contrib.messages.context_processors.messages',
                             'apps.main.processors.radarsys_globals',
                         ],
                     },
                 },
             ]
             WSGI_APPLICATION = 'radarsys.wsgi.application'
             # Database
             # https://docs.djangoproject.com/en/1.8/ref/settings/#databases
             DATABASES = {
                 # 'default': {
                 #     'ENGINE': 'django.db.backends.sqlite3',
                 #     'NAME': 'radarsys.sqlite',
                 # }
                 'default': {
                     'ENGINE': 'django.db.backends.postgresql_psycopg2',
-                    'NAME': os.environ.get('POSTGRES_DB_NAME', 'radarsys'),
+                    'NAME': os.environ.get('DB_NAME', 'radarsys'),
-                    'USER': os.environ.get('POSTGRES_USER', 'docker'),
+                    'USER': os.environ.get('DB_USER', 'docker'),
-                    'PASSWORD': os.environ.get('POSTGRES_PASSWORD', 'docker'),
+                    'PASSWORD': os.environ.get('DB_PASSWORD', 'docker'),
-                    'HOST': os.environ.get('POSTGRES_PORT_5432_TCP_ADDR', 'postgres'),
+                    'HOST': os.environ.get('POSTGRES_PORT_5432_TCP_ADDR', 'localhost'),
-                    'PORT': os.environ.get('POSTGRES_PORT_5432_TCP_PORT', ''),
+                    'PORT': os.environ.get('POSTGRES_PORT_5432_TCP_PORT', '5400'),
                 }
             }
             # Internationalization
             # https://docs.djangoproject.com/en/1.8/topics/i18n/
             LANGUAGE_CODE = 'en-us'
-            TIME_ZONE = os.environ.get('TZ', 'UTC')
+            TIME_ZONE = os.environ.get('TZ', 'America/Lima')
             USE_I18N = True
             USE_L10N = True
             USE_TZ = False
             # Static files (CSS, JavaScript, Images)
             # https://docs.djangoproject.com/en/1.8/howto/static-files/
             MEDIA_URL = '/media/'
             MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
             STATIC_URL = '/static/'
             STATIC_ROOT = os.path.join(BASE_DIR, 'static')
             STATICFILES_FINDERS = (
                 'django.contrib.staticfiles.finders.FileSystemFinder',
                 'django.contrib.staticfiles.finders.AppDirectoriesFinder',
             )
             # Celery stuff
             REDIS_HOST = os.environ.get('REDIS_HOST', '127.0.0.1')
-            REDIS_PORT = os.environ.get('REDIS_PORT', 6379)
+            REDIS_PORT = os.environ.get('REDIS_PORT', 6300)
             BROKER_TRANSPORT = 'redis'
             BROKER_URL = 'redis://{}:{}/0'.format(REDIS_HOST, REDIS_PORT)
             CELERY_RESULT_BACKEND = 'redis://{}:{}/0'.format(REDIS_HOST, REDIS_PORT)
             CELERY_BROKER_TRANSPORT = BROKER_URL
             CELERY_ACCEPT_CONTENT = ['application/json']
             CELERY_TASK_SERIALIZER = 'json'
             CELERY_RESULT_SERIALIZER = 'json'
             CELERY_ENABLE_UTC = False

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