radarsys Commit - r238:3478b6e05998 · Jicamarca Repository

Fix Mix RC configurations...

Juan C. Espinoza -

r238:3478b6e05998

parent child

Context file:

r238:3478b6e05998

Collapse all files

apps/main/views.py +2 -2

              from datetime import datetime
              from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
              from django.utils.safestring import mark_safe
              from django.http import HttpResponseRedirect
              from django.core.urlresolvers import reverse
              from django.db.models import Q
              from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
              from django.contrib import messages
              from django.http.request import QueryDict
              try:
                  from urllib.parse import urlencode
              except ImportError:
                  from urllib import urlencode
              from .forms import CampaignForm, ExperimentForm, DeviceForm, ConfigurationForm, LocationForm, UploadFileForm, DownloadFileForm, OperationForm, NewForm
              from .forms import OperationSearchForm, FilterForm, ChangeIpForm
              from .tasks import task_start, task_stop
-             from apps.rc.forms import RCConfigurationForm, RCLineCode
+             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 .models import Campaign, Experiment, Device, Configuration, Location, RunningExperiment
              from apps.cgs.models import CGSConfiguration
              from apps.jars.models import JARSConfiguration, EXPERIMENT_TYPE
              from apps.usrp.models import USRPConfiguration
              from apps.abs.models import ABSConfiguration
              from apps.rc.models import RCConfiguration, RCLine, RCLineType
              from apps.dds.models import DDSConfiguration
              from django.contrib.auth.decorators import login_required
              from django.contrib.auth.decorators import user_passes_test
              from django.contrib.admin.views.decorators import staff_member_required
              import ast
              CONF_FORMS = {
                  'rc': RCConfigurationForm,
                  'dds': DDSConfigurationForm,
                  'jars': JARSConfigurationForm,
                  'cgs': CGSConfigurationForm,
                  'abs': ABSConfigurationForm,
                  'usrp': USRPConfigurationForm,
              }
              CONF_MODELS = {
                  'rc': RCConfiguration,
                  'dds': DDSConfiguration,
                  'jars': JARSConfiguration,
                  'cgs': CGSConfiguration,
                  'abs': ABSConfiguration,
                  'usrp': USRPConfiguration,
              }
              MIX_MODES = {
                  '0': 'P',
                  '1': 'S',
              }
              MIX_OPERATIONS = {
                  '0': 'OR',
                  '1': 'XOR',
                  '2': 'AND',
                  '3': 'NAND',
              }
              def index(request):
                  kwargs = {'no_sidebar':True}
                  return render(request, 'index.html', kwargs)
              def locations(request):
                  page = request.GET.get('page')
                  order = ('name',)
                  kwargs = get_paginator(Location, page, order)
                  kwargs['keys'] = ['name', 'description']
                  kwargs['title'] = 'Radar System'
                  kwargs['suptitle'] = 'List'
                  kwargs['no_sidebar'] = True
                  return render(request, 'base_list.html', kwargs)
              def location(request, id_loc):
                  location = get_object_or_404(Location, pk=id_loc)
                  kwargs = {}
                  kwargs['location'] = location
                  kwargs['location_keys'] = ['name', 'description']
                  kwargs['title'] = 'Location'
                  kwargs['suptitle'] = 'Details'
                  return render(request, 'location.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def location_new(request):
                  if request.method == 'GET':
                      form = LocationForm()
                  if request.method == 'POST':
                      form = LocationForm(request.POST)
                      if form.is_valid():
                          form.save()
                          return redirect('url_locations')
                  kwargs = {}
                  kwargs['form'] = form
                  kwargs['title'] = 'Radar System'
                  kwargs['suptitle'] = 'New'
                  kwargs['button'] = 'Create'
                  return render(request, 'base_edit.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def location_edit(request, id_loc):
                  location = get_object_or_404(Location, pk=id_loc)
                  if request.method=='GET':
                      form = LocationForm(instance=location)
                  if request.method=='POST':
                      form = LocationForm(request.POST, instance=location)
                      if form.is_valid():
                          form.save()
                          return redirect('url_locations')
                  kwargs = {}
                  kwargs['form'] = form
                  kwargs['title'] = 'Location'
                  kwargs['suptitle'] = 'Edit'
                  kwargs['button'] = 'Update'
                  return render(request, 'base_edit.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def location_delete(request, id_loc):
                  location = get_object_or_404(Location, pk=id_loc)
                  if request.method=='POST':
                      if request.user.is_staff:
                          location.delete()
                          return redirect('url_locations')
                      messages.error(request, 'Not enough permission to delete this object')
                      return redirect(location.get_absolute_url())
                  kwargs = {
                            'title': 'Delete',
                            'suptitle': 'Location',
                            'object': location,
                            'previous': location.get_absolute_url(),
                            'delete': True
                            }
                  return render(request, 'confirm.html', kwargs)
              def devices(request):
                  page = request.GET.get('page')
                  order = ('device_type', 'name')
                  kwargs = get_paginator(Device, page, order)
                  kwargs['keys'] = ['name', 'ip_address', 'port_address', 'device_type']
                  kwargs['title'] = 'Device'
                  kwargs['suptitle'] = 'List'
                  kwargs['no_sidebar'] = True
                  return render(request, 'base_list.html', kwargs)
              def device(request, id_dev):
                  device = get_object_or_404(Device, pk=id_dev)
                  kwargs = {}
                  kwargs['device'] = device
                  kwargs['device_keys'] = ['device_type', 'name', 'ip_address', 'port_address', 'description']
                  kwargs['title'] = 'Device'
                  kwargs['suptitle'] = 'Details'
                  return render(request, 'device.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def device_new(request):
                  if request.method == 'GET':
                      form = DeviceForm()
                  if request.method == 'POST':
                      form = DeviceForm(request.POST)
                      if form.is_valid():
                          form.save()
                          return redirect('url_devices')
                  kwargs = {}
                  kwargs['form'] = form
                  kwargs['title'] = 'Device'
                  kwargs['suptitle'] = 'New'
                  kwargs['button'] = 'Create'
                  return render(request, 'base_edit.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def device_edit(request, id_dev):
                  device = get_object_or_404(Device, pk=id_dev)
                  if request.method=='GET':
                      form = DeviceForm(instance=device)
                  if request.method=='POST':
                      form = DeviceForm(request.POST, instance=device)
                      if form.is_valid():
                          form.save()
                          return redirect(device.get_absolute_url())
                  kwargs = {}
                  kwargs['form'] = form
                  kwargs['title'] = 'Device'
                  kwargs['suptitle'] = 'Edit'
                  kwargs['button'] = 'Update'
                  return render(request, 'base_edit.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def device_delete(request, id_dev):
                  device = get_object_or_404(Device, pk=id_dev)
                  if request.method=='POST':
                      if request.user.is_staff:
                          device.delete()
                          return redirect('url_devices')
                      messages.error(request, 'Not enough permission to delete this object')
                      return redirect(device.get_absolute_url())
                  kwargs = {
                            'title': 'Delete',
                            'suptitle': 'Device',
                            'object': device,
                            'previous': device.get_absolute_url(),
                            'delete': True
                            }
                  return render(request, 'confirm.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def device_change_ip(request, id_dev):
                  device = get_object_or_404(Device, pk=id_dev)
                  if request.method=='POST':
                      if request.user.is_staff:
                          device.change_ip(**request.POST.dict())
                          level, message = device.message.split('|')
                          messages.add_message(request, level, message)
                      else:
                          messages.error(request, 'Not enough permission to delete this object')
                      return redirect(device.get_absolute_url())
                  kwargs = {
                            'title': 'Device',
                            'suptitle': 'Change IP',
                            'object': device,
                            'previous': device.get_absolute_url(),
                            'form': ChangeIpForm(initial={'ip_address':device.ip_address}),
                            'message' : ' ',
                            }
                  return render(request, 'confirm.html', kwargs)
              def campaigns(request):
                  page = request.GET.get('page')
                  order = ('start_date',)
                  filters = request.GET.copy()
                  kwargs = get_paginator(Campaign, page, order, filters)
                  form = FilterForm(initial=request.GET, extra_fields=['range_date', 'tags','template'])
                  kwargs['keys'] = ['name', 'start_date', 'end_date']
                  kwargs['title'] = 'Campaign'
                  kwargs['suptitle'] = 'List'
                  kwargs['no_sidebar'] = True
                  kwargs['form'] = form
                  filters.pop('page', None)
                  kwargs['q'] = urlencode(filters)
                  return render(request, 'base_list.html', kwargs)
              def campaign(request, id_camp):
                  campaign = get_object_or_404(Campaign, pk=id_camp)
                  experiments = Experiment.objects.filter(campaign=campaign)
                  form = CampaignForm(instance=campaign)
                  kwargs = {}
                  kwargs['campaign'] = campaign
                  kwargs['campaign_keys'] = ['template', 'name', 'start_date', 'end_date', 'tags', 'description']
                  kwargs['experiments'] = experiments
                  kwargs['experiment_keys'] = ['name', 'radar_system', 'start_time', 'end_time']
                  kwargs['title'] = 'Campaign'
                  kwargs['suptitle'] = 'Details'
                  kwargs['form'] = form
                  kwargs['button'] = 'Add Experiment'
                  return render(request, 'campaign.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def campaign_new(request):
                  kwargs = {}
                  if request.method == 'GET':
                      if 'template' in request.GET:
                          if request.GET['template']=='0':
                              form = NewForm(initial={'create_from':2},
                                             template_choices=Campaign.objects.filter(template=True).values_list('id', 'name'))
                          else:
                              kwargs['button'] = 'Create'
                              kwargs['experiments'] = Configuration.objects.filter(experiment=request.GET['template'])
                              kwargs['experiment_keys'] = ['name', 'start_time', 'end_time']
                              camp = Campaign.objects.get(pk=request.GET['template'])
                              form = CampaignForm(instance=camp,
                                                  initial={'name':'{} [{:%Y/%m/%d}]'.format(camp.name, datetime.now()),
                                                           'template':False})
                      elif 'blank' in request.GET:
                          kwargs['button'] = 'Create'
                          form = CampaignForm()
                      else:
                          form = NewForm()
                  if request.method == 'POST':
                      kwargs['button'] = 'Create'
                      post = request.POST.copy()
                      experiments = []
                      for id_exp in post.getlist('experiments'):
                          exp = Experiment.objects.get(pk=id_exp)
                          new_exp = exp.clone(template=False)
                          experiments.append(new_exp)
                      post.setlist('experiments', [])
                      form = CampaignForm(post)
                      if form.is_valid():
                          campaign = form.save()
                          for exp in experiments:
                              campaign.experiments.add(exp)
                          campaign.save()
                          return redirect('url_campaign', id_camp=campaign.id)
                  kwargs['form'] = form
                  kwargs['title'] = 'Campaign'
                  kwargs['suptitle'] = 'New'
                  return render(request, 'campaign_edit.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def campaign_edit(request, id_camp):
                  campaign = get_object_or_404(Campaign, pk=id_camp)
                  if request.method=='GET':
                      form = CampaignForm(instance=campaign)
                  if request.method=='POST':
                      exps = campaign.experiments.all().values_list('pk', flat=True)
                      post = request.POST.copy()
                      new_exps = post.getlist('experiments')
                      post.setlist('experiments', [])
                      form = CampaignForm(post, instance=campaign)
                      if form.is_valid():
                          camp = form.save()
                          for id_exp in new_exps:
                              if int(id_exp) in exps:
                                  exps.pop(id_exp)
                              else:
                                  exp = Experiment.objects.get(pk=id_exp)
                                  if exp.template:
                                      camp.experiments.add(exp.clone(template=False))
                                  else:
                                      camp.experiments.add(exp)
                          for id_exp in exps:
                              camp.experiments.remove(Experiment.objects.get(pk=id_exp))
                          return redirect('url_campaign', id_camp=id_camp)
                  kwargs = {}
                  kwargs['form'] = form
                  kwargs['title'] = 'Campaign'
                  kwargs['suptitle'] = 'Edit'
                  kwargs['button'] = 'Update'
                  return render(request, 'campaign_edit.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def campaign_delete(request, id_camp):
                  campaign = get_object_or_404(Campaign, pk=id_camp)
                  if request.method=='POST':
                      if request.user.is_staff:
                          for exp in campaign.experiments.all():
                              for conf in Configuration.objects.filter(experiment=exp):
                                  conf.delete()
                              exp.delete()
                          campaign.delete()
                          return redirect('url_campaigns')
                      messages.error(request, 'Not enough permission to delete this object')
                      return redirect(campaign.get_absolute_url())
                  kwargs = {
                            'title': 'Delete',
                            'suptitle': 'Campaign',
                            'object': campaign,
                            'previous': campaign.get_absolute_url(),
                            'delete': True
                            }
                  return render(request, 'confirm.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def campaign_export(request, id_camp):
                  campaign = get_object_or_404(Campaign, pk=id_camp)
                  content = campaign.parms_to_dict()
                  content_type = 'application/json'
                  filename     =  '%s_%s.json' %(campaign.name, campaign.id)
                  response = HttpResponse(content_type=content_type)
                  response['Content-Disposition'] = 'attachment; filename="%s"' %filename
                  response.write(content)
                  return response
              @user_passes_test(lambda u:u.is_staff)
              def campaign_import(request, id_camp):
                  campaign = get_object_or_404(Campaign, pk=id_camp)
                  if request.method == 'GET':
                      file_form = UploadFileForm()
                  if request.method == 'POST':
                      file_form = UploadFileForm(request.POST, request.FILES)
                      if file_form.is_valid():
                          parms = campaign.import_from_file(request.FILES['file'])
                          if parms:
                              parms['name'] = parms['campaign']
                              new_camp = campaign.dict_to_parms(parms, CONF_MODELS)
                              messages.success(request, "Parameters imported from: '%s'." %request.FILES['file'].name)
                              return redirect(new_camp.get_absolute_url_edit())
                      messages.error(request, "Could not import parameters from file")
                  kwargs = {}
                  kwargs['title'] = 'Campaign'
                  kwargs['form'] = file_form
                  kwargs['suptitle'] = 'Importing file'
                  kwargs['button'] = 'Import'
                  return render(request, 'campaign_import.html', kwargs)
              def experiments(request):
                  page = request.GET.get('page')
                  order = ('location',)
                  filters = request.GET.copy()
                  kwargs = get_paginator(Experiment, page, order, filters)
                  form = FilterForm(initial=request.GET, extra_fields=['tags','template'])
                  kwargs['keys'] = ['name', 'radar_system', 'start_time', 'end_time']
                  kwargs['title'] = 'Experiment'
                  kwargs['suptitle'] = 'List'
                  kwargs['no_sidebar'] = True
                  kwargs['form'] = form
                  filters.pop('page', None)
                  kwargs['q'] = urlencode(filters)
                  return render(request, 'base_list.html', kwargs)
              def experiment(request, id_exp):
                  experiment = get_object_or_404(Experiment, pk=id_exp)
                  configurations = Configuration.objects.filter(experiment=experiment, type=0)
                  kwargs = {}
                  kwargs['experiment_keys'] = ['template', 'radar_system', 'name', 'start_time', 'end_time']
                  kwargs['experiment'] = experiment
                  kwargs['configuration_keys'] = ['name', 'device__ip_address', 'device__port_address', 'device__status']
                  kwargs['configurations'] = configurations
                  kwargs['title'] = 'Experiment'
                  kwargs['suptitle'] = 'Details'
                  kwargs['button'] = 'Add Configuration'
                  ###### SIDEBAR ######
                  kwargs.update(sidebar(experiment=experiment))
                  return render(request, 'experiment.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def experiment_new(request, id_camp=None):
                  kwargs = {}
                  if request.method == 'GET':
                      if 'template' in request.GET:
                          if request.GET['template']=='0':
                              form = NewForm(initial={'create_from':2},
                                             template_choices=Experiment.objects.filter(template=True).values_list('id', 'name'))
                          else:
                              kwargs['button'] = 'Create'
                              kwargs['configurations'] = Configuration.objects.filter(experiment=request.GET['template'])
                              kwargs['configuration_keys'] = ['name', 'device__name', 'device__ip_address', 'device__port_address']
                              exp=Experiment.objects.get(pk=request.GET['template'])
                              form = ExperimentForm(instance=exp,
                                                    initial={'name': '{} [{:%Y/%m/%d}]'.format(exp.name, datetime.now()),
                                                             'template': False})
                      elif 'blank' in request.GET:
                          kwargs['button'] = 'Create'
                          form = ExperimentForm()
                      else:
                          form = NewForm()
                  if request.method == 'POST':
                      form = ExperimentForm(request.POST)
                      if form.is_valid():
                          experiment = form.save()
                          if 'template' in request.GET:
                              configurations = Configuration.objects.filter(experiment=request.GET['template'], type=0)
                              for conf in configurations:
                                  conf.clone(experiment=experiment, template=False)
                          return redirect('url_experiment', id_exp=experiment.id)
                  kwargs['form'] = form
                  kwargs['title'] = 'Experiment'
                  kwargs['suptitle'] = 'New'
                  return render(request, 'experiment_edit.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def experiment_edit(request, id_exp):
                  experiment = get_object_or_404(Experiment, pk=id_exp)
                  if request.method == 'GET':
                      form = ExperimentForm(instance=experiment)
                  if request.method=='POST':
                      form = ExperimentForm(request.POST, instance=experiment)
                      if form.is_valid():
                          experiment = form.save()
                          return redirect('url_experiment', id_exp=experiment.id)
                  kwargs = {}
                  kwargs['form'] = form
                  kwargs['title'] = 'Experiment'
                  kwargs['suptitle'] = 'Edit'
                  kwargs['button'] = 'Update'
                  return render(request, 'experiment_edit.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def experiment_delete(request, id_exp):
                  experiment = get_object_or_404(Experiment, pk=id_exp)
                  if request.method=='POST':
                      if request.user.is_staff:
                          for conf in Configuration.objects.filter(experiment=experiment):
                              conf.delete()
                          experiment.delete()
                          return redirect('url_experiments')
                      messages.error(request, 'Not enough permission to delete this object')
                      return redirect(experiment.get_absolute_url())
                  kwargs = {
                            'title': 'Delete',
                            'suptitle': 'Experiment',
                            'object': experiment,
                            'previous': experiment.get_absolute_url(),
                            'delete': True
                            }
                  return render(request, 'confirm.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def experiment_export(request, id_exp):
                  experiment = get_object_or_404(Experiment, pk=id_exp)
                  content = experiment.parms_to_dict()
                  content_type = 'application/json'
                  filename     =  '%s_%s.json' %(experiment.name, experiment.id)
                  response = HttpResponse(content_type=content_type)
                  response['Content-Disposition'] = 'attachment; filename="%s"' %filename
                  response.write(content)
                  return response
              @user_passes_test(lambda u:u.is_staff)
              def experiment_import(request, id_exp):
                  experiment     = get_object_or_404(Experiment, pk=id_exp)
                  configurations = Configuration.objects.filter(experiment=experiment)
                  if request.method == 'GET':
                      file_form = UploadFileForm()
                  if request.method == 'POST':
                      file_form = UploadFileForm(request.POST, request.FILES)
                      if file_form.is_valid():
                          parms = experiment.import_from_file(request.FILES['file'])
                          if parms:
                              new_exp = experiment.dict_to_parms(parms, CONF_MODELS)
                              messages.success(request, "Parameters imported from: '%s'." %request.FILES['file'].name)
                              return redirect(new_exp.get_absolute_url_edit())
                      messages.error(request, "Could not import parameters from file")
                  kwargs = {}
                  kwargs['title'] = 'Experiment'
                  kwargs['form'] = file_form
                  kwargs['suptitle'] = 'Importing file'
                  kwargs['button'] = 'Import'
                  kwargs.update(sidebar(experiment=experiment))
                  return render(request, 'experiment_import.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def experiment_mix(request, id_exp):
                  experiment = get_object_or_404(Experiment, pk=id_exp)
                  rc_confs = [conf for conf in RCConfiguration.objects.filter(experiment=id_exp,
                                                                              mix=False)]
                  if len(rc_confs)<2:
                      messages.warning(request, 'You need at least two RC Configurations to make a mix')
                      return redirect(experiment.get_absolute_url())
                  mix_confs = RCConfiguration.objects.filter(experiment=id_exp, mix=True)
                  if mix_confs:
                      mix = mix_confs[0]
                  else:
                      mix = RCConfiguration(experiment=experiment,
                                            device=rc_confs[0].device,
                                            ipp=rc_confs[0].ipp,
                                            clock_in=rc_confs[0].clock_in,
                                            clock_divider=rc_confs[0].clock_divider,
                                            mix=True,
                                            parameters='')
                      mix.save()
                      line_type = RCLineType.objects.get(name='mix')
                      for i in range(len(rc_confs[0].get_lines())):
                          line = RCLine(rc_configuration=mix, line_type=line_type, channel=i)
                          line.save()
                  initial = {'name': mix.name,
                             'result': parse_mix_result(mix.parameters),
                             'delay': 0,
                             'mask': [0,1,2,3,4,5,6,7]
                             }
                  if request.method=='GET':
                      form = RCMixConfigurationForm(confs=rc_confs, initial=initial)
                  if request.method=='POST':
                      result = mix.parameters
                      if '{}|'.format(request.POST['experiment']) in result:
                          messages.error(request, 'Configuration already added')
                      else:
                          if 'operation' in request.POST:
                              operation = MIX_OPERATIONS[request.POST['operation']]
                          else:
                              operation = '   '
                          mode = MIX_MODES[request.POST['mode']]
                          if result:
                              result = '{}-{}|{}|{}|{}|{}'.format(mix.parameters,
                                                          request.POST['experiment'],
                                                          mode,
                                                          operation,
                                                          float(request.POST['delay']),
                                                          parse_mask(request.POST.getlist('mask'))
                                                          )
                          else:
                              result = '{}|{}|{}|{}|{}'.format(request.POST['experiment'],
                                                      mode,
                                                      operation,
                                                      float(request.POST['delay']),
                                                      parse_mask(request.POST.getlist('mask'))
                                                      )
                          mix.parameters = result
                          mix.name = request.POST['name']
                          mix.save()
                          mix.update_pulses()
                      initial['result'] = parse_mix_result(result)
                      initial['name'] = mix.name
                      form = RCMixConfigurationForm(initial=initial, confs=rc_confs)
                  kwargs = {
                            'title': 'Experiment',
                            'suptitle': 'Mix Configurations',
                            'form' : form,
                            'extra_button': 'Delete',
                            'button': 'Add',
                            'cancel': 'Back',
                            'previous': experiment.get_absolute_url(),
                            'id_exp':id_exp,
                            }
                  return render(request, 'experiment_mix.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def experiment_mix_delete(request, id_exp):
                  conf = RCConfiguration.objects.get(experiment=id_exp, mix=True)
                  values = conf.parameters.split('-')
                  conf.parameters = '-'.join(values[:-1])
                  conf.save()
                  return redirect('url_mix_experiment', id_exp=id_exp)
              def experiment_summary(request, id_exp):
                  import json
                  import ast
                  experiment      = get_object_or_404(Experiment, pk=id_exp)
                  experiment_data = json.loads(experiment.parms_to_dict())
                  configurations  = Configuration.objects.filter(experiment=experiment, type=0)
                  kwargs = {}
                  kwargs['experiment_keys'] = ['radar_system', 'name', 'start_time', 'end_time']
                  kwargs['experiment'] = experiment
                  kwargs['configuration_keys'] = ['name', 'device__ip_address', 'device__port_address', 'device__status']
                  kwargs['configurations'] = configurations
                  kwargs['experiment_data'] = experiment_data
                  kwargs['title'] = 'Experiment Summary'
                  kwargs['suptitle'] = 'Details'
                  kwargs['button'] = 'Verify Parameters'
                  jars_conf = False
                  rc_conf   = False
                  for configuration in configurations:
                      #-------------------- JARS -----------------------:
                      if configuration.device.device_type.name == 'jars':
                          jars_conf = True
                          kwargs['jars_conf'] = jars_conf
                          kwargs['exp_type']  = EXPERIMENT_TYPE[configuration.exp_type][1]
                          channels_number     = configuration.channels_number
                          exp_type            = configuration.exp_type
                          fftpoints           = configuration.fftpoints
                          filter_parms        = configuration.filter_parms
                          filter_parms        = ast.literal_eval(filter_parms)
                          spectral_number     = configuration.spectral_number
                      #--------------------- RC ----------------------:
                      if configuration.device.device_type.name == 'rc':
                          rc_conf = True
                          kwargs['rc_conf'] = rc_conf
                          rc_lines = experiment_data['configurations']['rc']['lines']
                          ipp = configuration.ipp
                          if experiment_data['configurations']['rc']['mix'] == 'True':
                              code = ''
                          else:
                              code = rc_lines[3]['code']
                          kwargs['code'] = code
                          #---Jueves 01-12-2016---
                          lines = configuration.get_lines()
                          if lines:
                              #TX Delays (TAU)
                              rc_delays_num = 0
                              rc_delays = ''
                              tx_lines = configuration.get_lines(line_type__name='tx')
                              for tx_line in tx_lines:
                                  if len(tx_lines) < 2:
                                      rc_delay = json.loads(tx_line.params)
                                      rc_delays = rc_delays+tx_line.get_name()+': '+rc_delay['delays']+'\n'
                                      delay = ast.literal_eval(rc_delay['delays'])
                                      if isinstance(delay,int):
                                          rc_delays_num += 1
                                      else:
                                          rc_delays_num += len(delay)
                                  else:
                                      rc_delay = json.loads(tx_line.params)
                                      rc_delays = rc_delays+tx_line.get_name()+': '+rc_delay['delays']+'\n'
                                      delay = ast.literal_eval(rc_delay['delays'])
                                      if isinstance(delay,int):
                                          rc_delays_num += 1
                                      else:
                                          rc_delays_num += len(delay)
                              #TX: TXA - TXB...
                              for tx_line in tx_lines:
                                  tx_line.name  = tx_line.get_name()
                                  tx_line_parameters = json.loads(tx_line.params)
                                  tx_line.parameters = tx_line_parameters
                              #WINDOWS
                              windows_lines = configuration.get_lines(line_type__name='windows')
                              for windows_line in windows_lines:
                                  windows_line.name  = windows_line.get_name()
                                  windows_data        = json.loads(windows_line.params)
                                  windows_params      = windows_data['params'][0]
                                  h0  = str(windows_params['first_height'])
                                  dh  = str(windows_params['resolution'])
                                  nsa = str(windows_params['number_of_samples'])
                                  windows_line.parameters = 'Ho=' + h0 +'km\nDH=' + dh +'km\nNSA=' + nsa
                              #CODES
                              code_lines = configuration.get_lines(line_type__name='codes')
                              for code_line in code_lines:
                                  code_line.name = code_line.get_name()
                                  line_params    = json.loads(code_line.params)
                                  rccode         = RCLineCode.objects.get(pk=int(line_params['code']))
                                  code_line.code_name = rccode.name
                              #PROG_PULSES
                              progpulses_lines = configuration.get_lines(line_type__name='prog_pulses')
                              for progpulses_line in progpulses_lines:
                                  progpulses_line.name = progpulses_line.get_name()
                                  progpulses_parameters = json.loads(progpulses_line.params)
                                  progpulses_parameters = progpulses_parameters['params'][0]
                                  progpulses_line.parameters = 'Begin: '+str(progpulses_parameters['begin'])+' (Units)\nEnd: '+str(progpulses_parameters['end'])+' (Units)'
                              #kwargs['kwargs_channels'] = sorted(kwargs_channels, reverse=True)
                              kwargs['lines'] = sorted(lines, reverse=True)
                              kwargs['rc_delays'] = rc_delays
                              kwargs['rc_delays_num'] = rc_delays_num
                              kwargs['tx_lines']      = tx_lines
                              kwargs['windows_lines'] = windows_lines
                              kwargs['code_lines']    = code_lines
                              kwargs['progpulses_lines']    = progpulses_lines
                          #--FIN: Jueves 01-12-2016---
                      #-------------------- DDS -----------------------:
                      if configuration.device.device_type.name == 'dds':
                          dds_conf = True
                          kwargs['dds_conf'] = dds_conf
                      #------ RC & JARS ------:
                      ipp = 937.5 #
                      nsa = 200#
                      dh = 1.5             #
                      channels_number = 5 #
                      if rc_conf and jars_conf:
                          if exp_type  == 0: #Short
                              bytes    = 2
                              b        = nsa*2*bytes*channels_number
                          else:              #Float
                              bytes    = 4
                              channels = channels_number + spectral_number
                              b        = nsa*2*bytes*fftpoints*channels
                          ipps           = (ipp*pow(10,-6))/0.15
                          GB             = 1048576.0*1024.0
                          Hour           = 3600
                          rate           = b/ipps
                          rate           = rate *(1/GB)*(Hour)
                          kwargs['rate'] = str(rate)+" GB/h"
                      else:
                          kwargs['rate'] = ''
                  ###### SIDEBAR ######
                  kwargs.update(sidebar(experiment=experiment))
                  return render(request, 'experiment_summary.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def experiment_verify(request, id_exp):
                  import json
                  import ast
                  experiment      = get_object_or_404(Experiment, pk=id_exp)
                  experiment_data = json.loads(experiment.parms_to_dict())
                  configurations  = Configuration.objects.filter(experiment=experiment, type=0)
                  kwargs = {}
                  kwargs['experiment_keys'] = ['template', 'radar_system', 'name', 'start_time', 'end_time']
                  kwargs['experiment'] = experiment
                  kwargs['configuration_keys'] = ['name', 'device__ip_address', 'device__port_address', 'device__status']
                  kwargs['configurations'] = configurations
                  kwargs['experiment_data'] = experiment_data
                  kwargs['title'] = 'Verify Experiment'
                  kwargs['suptitle'] = 'Parameters'
                  kwargs['button'] = 'Update'
                  jars_conf = False
                  rc_conf   = False
                  dds_conf   = False
                  for configuration in configurations:
                      #-------------------- JARS -----------------------:
                      if configuration.device.device_type.name == 'jars':
                          jars_conf = True
                          jars = configuration
                          kwargs['jars_conf']    = jars_conf
                          filter_parms           = configuration.filter_parms
                          filter_parms           = ast.literal_eval(filter_parms)
                          kwargs['filter_parms'] = filter_parms
                          #--Sampling Frequency
                          clock          = filter_parms['clock']
                          filter_2       = filter_parms['filter_2']
                          filter_5       = filter_parms['filter_5']
                          filter_fir     = filter_parms['filter_fir']
                          samp_freq_jars = clock/filter_2/filter_5/filter_fir
                          kwargs['samp_freq_jars'] = samp_freq_jars
                          kwargs['jars']           = configuration
                      #--------------------- RC ----------------------:
                      if configuration.device.device_type.name == 'rc':
                          rc_conf = True
                          rc = configuration
                          rc_parms = configuration.parms_to_dict()
                          if rc_parms['mix'] == 'True':
                              pass
                          else:
                              rc_lines     = rc_parms['lines']
                              dh           = rc_lines[6]['params'][0]['resolution']
                              #--Sampling Frequency
                              samp_freq_rc = 0.15/dh
                              kwargs['samp_freq_rc'] = samp_freq_rc
                          kwargs['rc_conf'] = rc_conf
                          kwargs['rc']      = configuration
                      #-------------------- DDS ----------------------:
                      if configuration.device.device_type.name == 'dds':
                          dds_conf = True
                          dds = 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['clock_in']) and float(rc_parms['clock_in']) != float(dds_parms['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['clock_in']):
                          messages.warning(request, "Devices don't have the same clock.")
                  elif rc_conf and dds_conf:
                      if float(rc_parms['clock_in']) != float(dds_parms['clock']):
                          messages.warning(request, "Devices don't have the same clock.")
                      if float(samp_freq_rc) != float(dds_parms['frequencyA']):
                          messages.warning(request, "Devices don't have the same Frequency A.")
                  #------------POST METHOD------------:
                  if request.method == 'POST':
                      if request.POST['suggest_clock']:
                          try:
                              suggest_clock = float(request.POST['suggest_clock'])
                          except:
                              messages.warning(request, "Invalid value in CLOCK IN.")
                              return redirect('url_verify_experiment', id_exp=experiment.id)
                      else:
                          suggest_clock = ""
                      if suggest_clock:
                          if rc_conf:
                              rc.clock_in = suggest_clock
                              rc.save()
                          if jars_conf:
                              filter_parms           = jars.filter_parms
                              filter_parms           = ast.literal_eval(filter_parms)
                              filter_parms['clock'] = suggest_clock
                              jars.filter_parms = json.dumps(filter_parms)
                              jars.save()
                              kwargs['filter_parms'] = filter_parms
                          if dds_conf:
                              dds.clock = suggest_clock
                              dds.save()
                      if request.POST['suggest_frequencyA']:
                          try:
                              suggest_frequencyA = float(request.POST['suggest_frequencyA'])
                          except:
                              messages.warning(request, "Invalid value in FREQUENCY A.")
                              return redirect('url_verify_experiment', id_exp=experiment.id)
                      else:
                          suggest_frequencyA = ""
                      if suggest_frequencyA:
                          if jars_conf:
                              filter_parms           = jars.filter_parms
                              filter_parms           = ast.literal_eval(filter_parms)
                              filter_parms['fch'] = suggest_frequencyA
                              jars.filter_parms = json.dumps(filter_parms)
                              jars.save()
                              kwargs['filter_parms'] = filter_parms
                          if dds_conf:
                              dds.frequencyA_Mhz = request.POST['suggest_frequencyA']
                              dds.save()
                  ###### SIDEBAR ######
                  kwargs.update(sidebar(experiment=experiment))
                  return render(request, 'experiment_verify.html', kwargs)
-             @user_passes_test(lambda u:u.is_staff)
+             #@user_passes_test(lambda u:u.is_staff)
              def parse_mix_result(s):
                  values = s.split('-')
                  html = 'EXP                MOD OPE DELAY         MASK\r\n'
                  if not values or values[0] in ('', ' '):
                      return mark_safe(html)
                  for i, value in enumerate(values):
                      if not value:
                          continue
                      pk, mode, operation, delay, mask = value.split('|')
                      conf = RCConfiguration.objects.get(pk=pk)
                      if i==0:
                          html += '{:20.18}{:3}{:4}{:9}km{:>6}\r\n'.format(
                                              conf.name,
                                              mode,
                                              '   ',
                                              delay,
                                              mask)
                      else:
                          html += '{:20.18}{:3}{:4}{:9}km{:>6}\r\n'.format(
                                              conf.name,
                                              mode,
                                              operation,
                                              delay,
                                              mask)
                  return mark_safe(html)
              def parse_mask(l):
                  values = []
                  for x in range(8):
                      if '{}'.format(x) in l:
                          values.append(1)
                      else:
                          values.append(0)
                  values.reverse()
                  return int(''.join([str(x) for x in values]), 2)
              def dev_confs(request):
                  page = request.GET.get('page')
                  order = ('type', 'device__device_type', 'experiment')
                  filters = request.GET.copy()
                  kwargs = get_paginator(Configuration, page, order, filters)
                  form = FilterForm(initial=request.GET, extra_fields=['tags','template'])
                  kwargs['keys'] = ['name', 'experiment', 'type', 'programmed_date']
                  kwargs['title'] = 'Configuration'
                  kwargs['suptitle'] = 'List'
                  kwargs['no_sidebar'] = True
                  kwargs['form'] = form
                  filters.pop('page', None)
                  kwargs['q'] = urlencode(filters)
                  return render(request, 'base_list.html', kwargs)
              def dev_conf(request, id_conf):
                  conf = get_object_or_404(Configuration, pk=id_conf)
                  return redirect(conf.get_absolute_url())
              @user_passes_test(lambda u:u.is_staff)
              def dev_conf_new(request, id_exp=0, id_dev=0):
                  initial = {}
                  kwargs = {}
                  if id_exp!=0:
                      initial['experiment'] = id_exp
                  if id_dev!=0:
                      initial['device'] = id_dev
                  if request.method == 'GET':
                      if id_dev:
                          kwargs['button'] = 'Create'
                          device = Device.objects.get(pk=id_dev)
                          DevConfForm = CONF_FORMS[device.device_type.name]
                          initial['name'] = request.GET['name']
                          form = DevConfForm(initial=initial)
                      else:
                          if 'template' in request.GET:
                              if request.GET['template']=='0':
                                  choices = [(conf.pk, '{}'.format(conf)) for conf in Configuration.objects.filter(template=True)]
                                  form = NewForm(initial={'create_from':2},
                                                 template_choices=choices)
                              else:
                                  kwargs['button'] = 'Create'
                                  conf = Configuration.objects.get(pk=request.GET['template'])
                                  id_dev = conf.device.pk
                                  DevConfForm = CONF_FORMS[conf.device.device_type.name]
                                  form = DevConfForm(instance=conf,
                                                     initial={'name': '{} [{:%Y/%m/%d}]'.format(conf.name, datetime.now()),
                                                              'template': False,
                                                              'experiment':id_exp})
                          elif 'blank' in request.GET:
                              kwargs['button'] = 'Create'
                              form = ConfigurationForm(initial=initial)
                          else:
                              form = NewForm()
                  if request.method == 'POST':
                      device = Device.objects.get(pk=request.POST['device'])
                      DevConfForm = CONF_FORMS[device.device_type.name]
                      form = DevConfForm(request.POST)
                      kwargs['button'] = 'Create'
                      if form.is_valid():
                          conf = form.save()
                          if 'template' in request.GET and conf.device.device_type.name=='rc':
                              lines = RCLine.objects.filter(rc_configuration=request.GET['template'])
                              for line in lines:
                                  line.clone(rc_configuration=conf)
                          if conf.device.device_type.name=='jars':
                              conf.add_parms_to_filter()
                          return redirect('url_dev_conf', id_conf=conf.pk)
                  kwargs['id_exp'] = id_exp
                  kwargs['form'] = form
                  kwargs['title'] = 'Configuration'
                  kwargs['suptitle'] = 'New'
                  if id_dev != 0:
                      device = Device.objects.get(pk=id_dev)
                      kwargs['device'] = device.device_type.name
                  return render(request, 'dev_conf_edit.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def dev_conf_edit(request, id_conf):
                  conf = get_object_or_404(Configuration, pk=id_conf)
                  DevConfForm = CONF_FORMS[conf.device.device_type.name]
                  if request.method=='GET':
                      form = DevConfForm(instance=conf)
                  if request.method=='POST':
                      form = DevConfForm(request.POST, instance=conf)
                      if form.is_valid():
                          form.save()
                          return redirect('url_dev_conf', id_conf=id_conf)
                  kwargs = {}
                  kwargs['form'] = form
                  kwargs['title'] = 'Device Configuration'
                  kwargs['suptitle'] = 'Edit'
                  kwargs['button'] = 'Update'
                  ###### SIDEBAR ######
                  kwargs.update(sidebar(conf=conf))
                  return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def dev_conf_start(request, id_conf):
                  conf = get_object_or_404(Configuration, pk=id_conf)
                  if conf.start_device():
                      messages.success(request, conf.message)
                  else:
                      messages.error(request, conf.message)
                  #conf.status_device()
                  return redirect(conf.get_absolute_url())
              @user_passes_test(lambda u:u.is_staff)
              def dev_conf_stop(request, id_conf):
                  conf = get_object_or_404(Configuration, pk=id_conf)
                  if conf.stop_device():
                      messages.success(request, conf.message)
                  else:
                      messages.error(request, conf.message)
                  #conf.status_device()
                  return redirect(conf.get_absolute_url())
              def dev_conf_status(request, id_conf):
                  conf = get_object_or_404(Configuration, pk=id_conf)
                  if conf.status_device():
                      messages.success(request, conf.message)
                  else:
                      messages.error(request, conf.message)
                  return redirect(conf.get_absolute_url())
              @user_passes_test(lambda u:u.is_staff)
              def dev_conf_write(request, id_conf):
                  conf = get_object_or_404(Configuration, pk=id_conf)
                  if conf.write_device():
                      messages.success(request, conf.message)
                      conf.clone(type=1, template=False)
                  else:
                      messages.error(request, conf.message)
                  return redirect(conf.get_absolute_url())
              @user_passes_test(lambda u:u.is_staff)
              def dev_conf_read(request, id_conf):
                  conf = get_object_or_404(Configuration, pk=id_conf)
                  DevConfForm = CONF_FORMS[conf.device.device_type.name]
                  if request.method=='GET':
                      parms = conf.read_device()
                      #conf.status_device()
                      if not parms:
                          messages.error(request, conf.message)
                          return redirect(conf.get_absolute_url())
                      form = DevConfForm(initial=parms, instance=conf)
                  if request.method=='POST':
                      form = DevConfForm(request.POST, instance=conf)
                      if form.is_valid():
                          form.save()
                          return redirect(conf.get_absolute_url())
                      messages.error(request, "Parameters could not be saved")
                  kwargs = {}
                  kwargs['id_dev'] = conf.id
                  kwargs['form'] = form
                  kwargs['title'] = 'Device Configuration'
                  kwargs['suptitle'] = 'Parameters read from device'
                  kwargs['button'] = 'Save'
                  ###### SIDEBAR ######
                  kwargs.update(sidebar(conf=conf))
                  return render(request, '%s_conf_edit.html' %conf.device.device_type.name, kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def dev_conf_import(request, id_conf):
                  conf = get_object_or_404(Configuration, pk=id_conf)
                  DevConfForm = CONF_FORMS[conf.device.device_type.name]
                  if request.method == 'GET':
                      file_form = UploadFileForm()
                  if request.method == 'POST':
                      file_form = UploadFileForm(request.POST, request.FILES)
                      if file_form.is_valid():
                          parms = conf.import_from_file(request.FILES['file'])
                          if parms:
                              messages.success(request, "Parameters imported from: '%s'." %request.FILES['file'].name)
                              form = DevConfForm(initial=parms, instance=conf)
                              kwargs = {}
                              kwargs['id_dev'] = conf.id
                              kwargs['form'] = form
                              kwargs['title'] = 'Device Configuration'
                              kwargs['suptitle'] = 'Parameters imported'
                              kwargs['button'] = 'Save'
                              kwargs['action'] = conf.get_absolute_url_edit()
                              kwargs['previous'] = conf.get_absolute_url()
                              ###### SIDEBAR ######
                              kwargs.update(sidebar(conf=conf))
                              return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
                      messages.error(request, "Could not import parameters from file")
                  kwargs = {}
                  kwargs['id_dev'] = conf.id
                  kwargs['title'] = 'Device Configuration'
                  kwargs['form'] = file_form
                  kwargs['suptitle'] = 'Importing file'
                  kwargs['button'] = 'Import'
                  kwargs.update(sidebar(conf=conf))
                  return render(request, 'dev_conf_import.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def dev_conf_export(request, id_conf):
                  conf = get_object_or_404(Configuration, pk=id_conf)
                  if request.method == 'GET':
                      file_form = DownloadFileForm(conf.device.device_type.name)
                  if request.method == 'POST':
                      file_form = DownloadFileForm(conf.device.device_type.name, request.POST)
                      if file_form.is_valid():
                          fields = conf.export_to_file(format = file_form.cleaned_data['format'])
                          response = HttpResponse(content_type=fields['content_type'])
                          response['Content-Disposition'] = 'attachment; filename="%s"' %fields['filename']
                          response.write(fields['content'])
                          return response
                      messages.error(request, "Could not export parameters")
                  kwargs = {}
                  kwargs['id_dev'] = conf.id
                  kwargs['title'] = 'Device Configuration'
                  kwargs['form'] = file_form
                  kwargs['suptitle'] = 'Exporting file'
                  kwargs['button'] = 'Export'
                  return render(request, 'dev_conf_export.html', kwargs)
              @user_passes_test(lambda u:u.is_staff)
              def dev_conf_delete(request, id_conf):
                  conf = get_object_or_404(Configuration, pk=id_conf)
                  if request.method=='POST':
                      if request.user.is_staff:
                          conf.delete()
                          return redirect('url_dev_confs')
                      messages.error(request, 'Not enough permission to delete this object')
                      return redirect(conf.get_absolute_url())
                  kwargs = {
                            'title': 'Delete',
                            'suptitle': 'Experiment',
                            'object': conf,
                            'previous': conf.get_absolute_url(),
                            'delete': True
                            }
                  return render(request, 'confirm.html', kwargs)
              def sidebar(**kwargs):
                  side_data = {}
                  conf = kwargs.get('conf', None)
                  experiment = kwargs.get('experiment', None)
                  if not experiment:
                      experiment = conf.experiment
                  if experiment:
                      side_data['experiment'] = experiment
                      campaign = experiment.campaign_set.all()
                      if campaign:
                          side_data['campaign'] = campaign[0]
                          experiments = campaign[0].experiments.all()
                      else:
                          experiments = [experiment]
                      configurations = experiment.configuration_set.filter(type=0)
                      side_data['side_experiments'] = experiments
                      side_data['side_configurations'] = configurations
                  return side_data
              def get_paginator(model, page, order, filters={}, n=10):
                  kwargs = {}
                  query = Q()
                  if isinstance(filters, QueryDict):
                      filters = filters.dict()
                  [filters.pop(key) for key in filters.keys() if filters[key] in ('', ' ')]
                  filters.pop('page', None)
                  if 'template' in filters:
                      filters['template'] = True
                  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')
                      fields = [f.name for f in model._meta.get_fields()]
                      if 'tags' in fields:
                          query = query | Q(tags__icontains=tags)
                      if 'name' in fields:
                          query = query | Q(name__icontains=tags)
                      if 'location' in fields:
                          query = query | Q(location__name__icontains=tags)
                      if 'device' in fields:
                          query = query | Q(device__device_type__name__icontains=tags)
                  object_list = model.objects.filter(query, **filters).order_by(*order)
                  paginator = Paginator(object_list, n)
                  try:
                      objects = paginator.page(page)
                  except PageNotAnInteger:
                      objects = paginator.page(1)
                  except EmptyPage:
                      objects = paginator.page(paginator.num_pages)
                  kwargs['objects'] = objects
                  kwargs['offset'] = (int(page)-1)*n if page else 0
                  return kwargs
              def operation(request, id_camp=None):
                  kwargs = {}
                  kwargs['title'] = 'Radars Operation'
                  kwargs['no_sidebar'] = True
                  campaigns = Campaign.objects.filter(start_date__lte=datetime.now(),
                                                      end_date__gte=datetime.now()).order_by('-start_date')
                  if id_camp:
                      campaign = get_object_or_404(Campaign, pk = id_camp)
                      form = OperationForm(initial={'campaign': campaign.id}, campaigns=campaigns)
                      kwargs['campaign'] = campaign
                  else:
                      form = OperationForm(campaigns=campaigns)
                      kwargs['form'] = form
                      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.utcnow()
                  for exp in experiments:
                      date = datetime.combine(datetime.now().date(), exp.start_time)
                      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 date>campaign.end_date or date<campaign.start_date:
                          messages.warning(request, 'Experiment {} out of date'.format(exp))
                          continue
                      if now>=date:
                          task = task_start.delay(exp.pk)
                          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=date)
                          exp.status = 3
                          messages.success(request, 'Experiment {} programmed to start at {}'.format(exp, date))
                      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.status == 2:
                          task = task_stop.delay(exp.pk)
                          exp.status = task.wait()
                          messages.warning(request, 'Experiment {} stopped'.format(exp))
                          exp.save()
                      else:
                          messages.error(request, 'Experiment {} not running'.format(exp))
                  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]))

apps/rc/models.py +2 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 devices.rc import api
              from .utils import RCFile
              # Create your models here.
              LINE_TYPES = (
                  ('none', 'Not used'),
                  ('tr', 'Transmission/reception selector signal'),
                  ('tx', 'A modulating signal (Transmission pulse)'),
                  ('codes', 'BPSK modulating signal'),
                  ('windows', 'Sample window signal'),
                  ('sync', 'Synchronizing signal'),
                  ('flip', 'IPP related periodic signal'),
                  ('prog_pulses', 'Programmable pulse'),
                  ('mix', 'Mixed line'),
                  )
              SAMPLING_REFS = (
                  ('none', 'No Reference'),
                  ('begin_baud', 'Begin of the first baud'),
                  ('first_baud', 'Middle of the first baud'),
                  ('sub_baud', 'Middle of the sub-baud')
                               )
              DAT_CMDS = {
                      # Pulse Design commands
                      'DISABLE' : 0, # Disables pulse generation
                      'ENABLE' : 24, # Enables pulse generation
                      'DELAY_START' : 40, # Write delay status to memory
                      'FLIP_START' : 48, # Write flip status to memory
                      'SAMPLING_PERIOD' : 64, # Establish Sampling Period
                      'TX_ONE' : 72, # Output '0' in line TX
                      'TX_ZERO' : 88, # Output '0' in line TX
                      'SW_ONE' : 104, # Output '0' in line SW
                      'SW_ZERO' : 112, # Output '1' in line SW
                      'RESTART': 120, # Restarts CR8 Firmware
                      'CONTINUE' : 253, # Function Unknown
                      # Commands available to new controllers
                      # In Pulse Design Executable, the clock divisor code is written as 12 at the start, but it should be written as code 22(below) just before the final enable.
                      'CLOCK_DIVISOR_INIT' : 12, # Specifies Clock Divisor. Legacy command, ignored in the actual .dat conversion
                      'CLOCK_DIVISOR_LAST' : 22, # Specifies Clock Divisor (default 60 if not included) syntax: 255,22 254,N-1.
                      'CLOCK_DIVIDER' : 8,
                          }
              class RCConfiguration(Configuration):
                  ipp = models.FloatField(verbose_name='IPP [Km]', validators=[MinValueValidator(1), MaxValueValidator(9000)], default=300)
                  ntx = models.PositiveIntegerField(verbose_name='Number of TX', validators=[MinValueValidator(1), MaxValueValidator(400)], default=1)
                  clock_in = models.FloatField(verbose_name='Clock in [MHz]', validators=[MinValueValidator(1), MaxValueValidator(80)], default=1)
                  clock_divider = models.PositiveIntegerField(verbose_name='Clock divider', validators=[MinValueValidator(1), MaxValueValidator(256)], default=1)
                  clock = models.FloatField(verbose_name='Clock Master [MHz]', blank=True, default=1)
                  time_before = models.PositiveIntegerField(verbose_name='Time before [&mu;S]', default=12)
                  time_after = models.PositiveIntegerField(verbose_name='Time after [&mu;S]', default=1)
                  sync = models.PositiveIntegerField(verbose_name='Synchro delay', default=0)
                  sampling_reference = models.CharField(verbose_name='Sampling Reference', choices=SAMPLING_REFS, default='none', max_length=40)
                  control_tx = models.BooleanField(verbose_name='Control Switch TX', default=False)
                  control_sw = models.BooleanField(verbose_name='Control Switch SW', default=False)
                  total_units = models.PositiveIntegerField(default=0)
                  mix = models.BooleanField(default=False)
                  class Meta:
                      db_table = 'rc_configurations'
                  def get_absolute_url_plot(self):
                      return reverse('url_plot_rc_pulses', args=[str(self.id)])
                  def get_absolute_url_import(self):
                      return reverse('url_import_rc_conf', args=[str(self.id)])
                  @property
                  def ipp_unit(self):
                      return '{} ({})'.format(self.ipp, int(self.ipp*self.km2unit))
                  @property
                  def us2unit(self):
                      return self.clock_in/self.clock_divider
                  @property
                  def km2unit(self):
                      return 20./3*(self.clock_in/self.clock_divider)
                  def clone(self, **kwargs):
                      lines = self.get_lines()
                      self.pk = None
                      self.id = None
                      for attr, value in kwargs.items():
                          setattr(self, attr, value)
                      self.save()
                      for line in lines:
                          line.clone(rc_configuration=self)
                      return self
                  def get_lines(self, **kwargs):
                      '''
                      Retrieve configuration lines
                      '''
                      return RCLine.objects.filter(rc_configuration=self.pk, **kwargs)
                  def clean_lines(self):
                      '''
                      '''
                      empty_line = RCLineType.objects.get(name='none')
                      for line in self.get_lines():
                          line.line_type = empty_line
                          line.params = '{}'
                          line.save()
                  def parms_to_dict(self):
                      '''
                      '''
                      ignored = ('parameters', 'type', 'polymorphic_ctype', 'configuration_ptr',
                                 'created_date', 'programmed_date')
                      data = {}
                      for field in self._meta.fields:
                          if field.name in ignored:
                              continue
                          data[field.name] = '{}'.format(field.value_from_object(self))
                      data['device_id'] = data.pop('device')
                      data['lines'] = []
                      for line in self.get_lines():
                          line_data = json.loads(line.params)
                          if 'TX_ref' in line_data and line_data['TX_ref'] not in (0, '0'):
                              line_data['TX_ref'] = RCLine.objects.get(pk=line_data['TX_ref']).get_name()
                          if 'code' in line_data:
                              line_data['code'] = RCLineCode.objects.get(pk=line_data['code']).name
                          line_data['type'] = line.line_type.name
                          line_data['name'] = line.get_name()
                          data['lines'].append(line_data)
                      data['delays'] = self.get_delays()
                      data['pulses'] = self.get_pulses()
                      return data
                  def dict_to_parms(self, data):
                      '''
                      '''
                      self.name = data['name']
                      self.ipp = float(data['ipp'])
                      self.ntx = int(data['ntx'])
                      self.clock_in = float(data['clock_in'])
                      self.clock_divider = int(data['clock_divider'])
                      self.clock = float(data['clock'])
                      self.time_before = data['time_before']
                      self.time_after = data['time_after']
                      self.sync = data['sync']
                      self.sampling_reference = data['sampling_reference']
                      self.total_units = self.ipp*self.ntx*self.km2unit
                      self.save()
                      self.clean_lines()
                      lines = []
                      positions = {'tx':0, 'tr':0}
                      for i, line_data in enumerate(data['lines']):
                          name = line_data.pop('name', '')
                          line_type = RCLineType.objects.get(name=line_data.pop('type'))
                          if line_type.name=='codes':
                              code = RCLineCode.objects.get(name=line_data['code'])
                              line_data['code'] = code.pk
                          line = RCLine.objects.filter(rc_configuration=self, channel=i)
                          if line:
                              line = line[0]
                              line.line_type = line_type
                              line.params = json.dumps(line_data)
                          else:
                              line = RCLine(rc_configuration=self, line_type=line_type,
                                            params=json.dumps(line_data),
                                            channel=i)
                          if line_type.name=='tx':
                              line.position = positions['tx']
                              positions['tx'] += 1
                          if line_type.name=='tr':
                              line.position = positions['tr']
                              positions['tr'] += 1
                          line.save()
                          lines.append(line)
                      for line, line_data in zip(lines, data['lines']):
                          if 'TX_ref' in line_data:
                              params = json.loads(line.params)
                              if line_data['TX_ref'] in (0, '0'):
                                  params['TX_ref'] = '0'
                              else:
                                  params['TX_ref'] = [l.pk for l in lines if l.line_type.name=='tx' and line_data['TX_ref'] in l.get_name()][0]
                              line.params = json.dumps(params)
                              line.save()
                  def get_delays(self):
                      pulses = [line.pulses_as_points() for line in self.get_lines()]
                      points = [tup for tups in pulses for tup in tups]
                      points = set([x for tup in points for x in tup])
                      points = list(points)
                      points.sort()
                      if points[0]!=0:
                          points.insert(0, 0)
                      return [points[i+1]-points[i] for i in range(len(points)-1)]
                  def get_pulses(self, binary=True):
                      pulses = [line.pulses_as_points() for line in self.get_lines()]
                      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]
                              dws = [tup[1] for tup in tups]
                              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=False)
                      for flips, delay in zip(states, delays):
                          flips.reverse()
                          flip = int(''.join([str(x) for x in flips]), 2)
                          data.extend(self.add_data(flip+1))
                          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_from_file(self, filename):
                      '''
                      Update instance from file
                      '''
                      f = RCFile(filename)
                      self.dict_to_parms(f.data)
                      self.update_pulses()
                  def update_pulses(self):
                      for line in self.get_lines():
                          line.update_pulses()
                  def plot_pulses2(self, km=False):
                      import matplotlib.pyplot as plt
                      from bokeh.resources import CDN
                      from bokeh.embed import components
                      from bokeh.mpl import to_bokeh
                      from bokeh.models.tools import WheelZoomTool, ResetTool, PanTool, 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 status_device(self):
                      try:
                          self.device.status = 0
                          req = requests.get(self.device.url('status'))
                          payload = req.json()
                          if payload['status']=='enabled':
                              self.device.status = 3
                          elif payload['status']=='disabled':
                              self.device.status = 2
                          else:
                              self.device.status = 1
                              self.device.save()
                              self.message = 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 = str(e)
                          return False
                      self.device.save()
                      return True
                  def reset_device(self):
                      try:
                          req = requests.post(self.device.url('reset'))
                          payload = req.json()
                          if payload['reset']=='ok':
                              self.message = 'RC restarted'
                          else:
                              self.message = 'RC restart not ok'
                              self.device.status = 4
                              self.device.save()
                      except Exception as e:
                          self.message = str(e)
                          return False
                      return True
                  def stop_device(self):
                      try:
                          req = requests.post(self.device.url('stop'))
                          payload = req.json()
                          if payload['stop']=='ok':
                              self.device.status = 2
                              self.device.save()
                              self.message = 'RC stopped'
                          else:
                              self.message = 'RC stop not ok'
                              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 = str(e)
                          self.device.save()
                          return False
                      return True
                  def start_device(self):
                      try:
                          req = requests.post(self.device.url('start'))
                          payload = req.json()
                          if payload['start']=='ok':
                              self.device.status = 3
                              self.device.save()
                              self.message = 'RC running'
                          else:
                              self.message = 'RC start not ok'
                              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 = str(e)
                          self.device.save()
                          return False
                      return True
                  def write_device(self):
                      values = zip(self.get_pulses(),
                                   [x-1 for x in self.get_delays()])
                      data = bytearray()
                      #reset
                      data.extend((128, 0))
                      #disable
                      data.extend((129, 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))
                      try:
                          req = requests.post(self.device.url('write'), data=b64encode(data))
                          payload = req.json()
                          if payload['write']=='ok':
                              self.device.status = 2
                              self.device.save()
                              self.message = 'RC configured'
                          else:
                              self.device.status = 1
                              self.device.save()
                              self.message = 'RC write not ok'
                              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 = str(e)
                          self.device.save()
                          return False
                      return True
              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'%s - %s' % (self.rc_configuration, self.get_name())
                  def clone(self, **kwargs):
                      self.pk = None
                      for attr, value in kwargs.items():
                          setattr(self, attr, value)
                      self.save()
                      return self
                  def get_name(self, 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:
                              tr_params = json.loads(self.get_lines(line_type__name='tr')[0].params)
                              tr_ranges = tr_params['range'].split(',')
                              for p in params['params']:
                                  y_win = self.points(ntx, ipp_u,
                                                      p['resolution']*p['number_of_samples']*km2unit,
                                                      before=int(self.rc_configuration.time_before*us2unit),
                                                      sync=self.rc_configuration.sync+self.get_win_ref(p, params['TX_ref'], km2unit))
                                  if len(tr_ranges)>0 and tr_ranges[0]!='0':
                                      y_win = self.mask_ranges(y_win, tr_ranges)
                                  y.extend(y_win)
                      elif self.line_type.name=='mix':
                          values = self.rc_configuration.parameters.split('-')
                          confs = [RCConfiguration.objects.get(pk=value.split('|')[0]) for value in values]
                          modes = [value.split('|')[1] for value in values]
                          ops = [value.split('|')[2] for value in values]
                          delays = [value.split('|')[3] for value in values]
                          masks = [value.split('|')[4] for value in values]
                          mask = list('{:8b}'.format(int(masks[0])))
                          mask.reverse()
                          if mask[self.channel] in ('0', '', ' '):
                              y = np.zeros(confs[0].total_units, dtype=np.int8)
                          else:
                              y = confs[0].get_lines(channel=self.channel)[0].pulses_as_array()
                          for i in range(1, len(values)):
                              mask = list('{:8b}'.format(int(masks[i])))
                              mask.reverse()
                              if mask[self.channel] in ('0', '', ' '):
                                  continue
                              Y = confs[i].get_lines(channel=self.channel)[0].pulses_as_array()
                              delay = float(delays[i])*km2unit
                              if modes[i]=='P':
                                  if delay>0:
                                      if delay<self.rc_configuration.ipp*km2unit and len(Y)==len(y):
                                          y_temp = np.empty_like(Y)
                                          y_temp[:delay] = 0
                                          y_temp[delay:] = Y[:-delay]
                                      elif delay+len(Y)>len(y):
                                          y_new = np.zeros(delay+len(Y), dtype=np.int8)
                                          y_new[:len(y)] = y
                                          y = y_new
                                          y_temp = np.zeros(delay+len(Y), dtype=np.int8)
                                          y_temp[-len(Y):] = Y
                                      elif delay+len(Y)==len(y):
                                          y_temp = np.zeros(delay+len(Y))
                                          y_temp[-len(Y):] = Y
                                      elif delay+len(Y)<len(y):
                                          y_temp = np.zeros(len(y), dtype=np.int8)
                                          y_temp[delay:delay+len(Y)] = Y
+                                 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):
                      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

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