radarsys_met Commit - r413:231bd42642ba

Create 'ip_address_rx', 'daughterboard_rx' and 'antenna_rx' parameters (USRP Rx) and Update models.py file (Pedestal)

eynilupu -

r413:231bd42642ba

parent child

Context file:

r413:231bd42642ba

volumes/sirm/apps/main/views.py +16 -4

             import ast
             import json
             import hashlib
             from datetime import datetime, timedelta
             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from django.utils.safestring import mark_safe
             from django.http import HttpResponseRedirect
             from django.urls import reverse
             from django.db.models import Q
             from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
             from django.contrib import messages
             from django.http.request import QueryDict
             from django.contrib.auth.decorators import login_required, user_passes_test
             from django.utils.timezone import is_aware
             try:
                 from urllib.parse import urlencode
             except ImportError:
                 from urllib import urlencode
             from .forms import ExperimentForm, ExperimentEditionForm, DeviceForm, ConfigurationForm, UploadFileForm, DownloadFileForm, NewForm
             from .forms import FilterForm, ChangeIpForm
             from apps.pedestal.forms import PedestalConfigurationForm, PedestalEditionForm
             from apps.generator.forms import GeneratorConfigurationForm
             from apps.usrp_rx.forms import USRPRXConfigurationForm, USRPRXEditionForm
             from apps.usrp_tx.forms import USRPTXConfigurationForm, USRPTXEditionForm
             from .utils import Params
             from .models              import Experiment, Device, Configuration, DEV_STATES
             from apps.pedestal.models       import PedestalConfiguration
             from apps.generator.models     import GeneratorConfiguration
             from apps.usrp_rx.models     import USRPRXConfiguration
             from apps.usrp_tx.models     import USRPTXConfiguration
             from apps.usrp_tx.validations import validation_usrp_tx_code
             #comentario test
             CONF_FORMS = {
                 'pedestal': PedestalConfigurationForm,
                 'generator': GeneratorConfigurationForm,
                 'usrp_rx': USRPRXConfigurationForm,
                 'usrp_tx': USRPTXConfigurationForm,
             }
             CONF_MODELS = {
                 'pedestal': PedestalConfiguration,
                 'generator': GeneratorConfiguration,
                 'usrp_rx': USRPRXConfiguration,
                 'usrp_tx': USRPTXConfiguration,
             }
             MIX_MODES = {
                 '0': 'P',
                 '1': 'S',
             }
             MIX_OPERATIONS = {
                 '0': 'OR',
                 '1': 'XOR',
                 '2': 'AND',
                 '3': 'NAND',
             }
             def is_developer(user):
                 groups = [str(g.name) for g in user.groups.all()]
                 return 'Developer' in groups or user.is_staff
             def is_operator(user):
                 groups = [str(g.name) for g in user.groups.all()]
                 return 'Operator' in groups or user.is_staff
             def has_been_modified(model):
                 prev_hash = model.hash
                 new_hash = hashlib.sha256(str(model.parms_to_dict).encode()).hexdigest()
                 if prev_hash != new_hash:
                     model.hash = new_hash
                     model.save()
                     return True
                 return False
             def index(request):
                 kwargs = {'no_sidebar': True}
                 return render(request, 'index.html', kwargs)
             def devices(request):
                 page = request.GET.get('page')
                 order = ('device_type',)
                 filters = request.GET.copy()
                 kwargs = get_paginator(Device, page, order, filters)
                 form = FilterForm(initial=request.GET, extra_fields=['tags'])
                 kwargs['keys'] = ['device_type',
                                   'ip_address', 'port_address', 'actions']
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'List'
                 kwargs['no_sidebar'] = True
                 kwargs['form'] = form
                 kwargs['add_url'] = reverse('url_add_device')
                 filters.pop('page', None)
                 kwargs['q'] = urlencode(filters)
                 kwargs['menu_devices'] = 'active'
                 return render(request, 'base_list.html', kwargs)
             def device(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 kwargs = {}
                 kwargs['device'] = device
                 kwargs['device_keys'] = ['device_type',
                                          'ip_address', 'port_address', 'description']
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'Details'
                 kwargs['menu_devices'] = 'active'
                 return render(request, 'device.html', kwargs)
             @login_required
             def device_new(request):
                 if request.method == 'GET':
                     form = DeviceForm()
                 if request.method == 'POST':
                     form = DeviceForm(request.POST)
                     if form.is_valid():
                         form.save()
                         return redirect('url_devices')
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'New'
                 kwargs['button'] = 'Create'
                 kwargs['menu_devices'] = 'active'
                 return render(request, 'base_edit.html', kwargs)
             @login_required
             def device_edit(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 if request.method == 'GET':
                     form = DeviceForm(instance=device)
                 if request.method == 'POST':
                     form = DeviceForm(request.POST, instance=device)
                     if form.is_valid():
                         form.save()
                         return redirect(device.get_absolute_url())
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Device'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 kwargs['menu_devices'] = 'active'
                 return render(request, 'base_edit.html', kwargs)
             @login_required
             def device_delete(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 if request.method == 'POST':
                     if is_developer(request.user):
                         device.delete()
                         return redirect('url_devices')
                     messages.error(request, 'Not enough permission to delete this object')
                     return redirect(device.get_absolute_url())
                 kwargs = {
                     'title': 'Delete',
                     'suptitle': 'Device',
                     'object': device,
                     'delete': True
                 }
                 kwargs['menu_devices'] = 'active'
                 return render(request, 'confirm.html', kwargs)
             @login_required
             def device_change_ip(request, id_dev):
                 device = get_object_or_404(Device, pk=id_dev)
                 if request.method == 'POST':
                     if is_developer(request.user):
                         device.change_ip(**request.POST.dict())
                         level, message = device.message.split('|')
                         messages.add_message(request, level, message)
                     else:
                         messages.error(
                             request, 'Not enough permission to delete this object')
                     return redirect(device.get_absolute_url())
                 kwargs = {
                     'title': 'Device',
                     'suptitle': 'Change IP',
                     'object': device,
                     'previous': device.get_absolute_url(),
                     'form': ChangeIpForm(initial={'ip_address': device.ip_address}),
                     'message': ' ',
                 }
                 kwargs['menu_devices'] = 'active'
                 return render(request, 'confirm.html', kwargs)
             def experiments(request):
                 page = request.GET.get('page')
                 order = ('id',)
                 filters = request.GET.copy()
                 if 'my experiments' in filters:
                     filters.pop('my experiments', None)
                     filters['mine'] = request.user.id
                 kwargs = get_paginator(Experiment, page, order, filters)
                 fields = ['tags']
                 if request.user.is_authenticated:
                     fields.append('my experiments')
                 form = FilterForm(initial=request.GET, extra_fields=fields)
                 kwargs['keys'] = ['name', 'pedestal', 'reception_rx', 'transmission_tx', 'actions']
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'List'
                 kwargs['no_sidebar'] = True
                 kwargs['form'] = form
                 kwargs['add_url'] = reverse('url_add_experiment')
                 filters = request.GET.copy()
                 filters.pop('page', None)
                 kwargs['q'] = urlencode(filters)
                 kwargs['menu_experiments'] = 'active'
                 return render(request, 'base_list.html', kwargs)
             def experiment(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 id_p = experiment.pedestal_id
                 id_rx = experiment.reception_rx_id
                 id_tx = experiment.transmission_tx_id
                 conf_pedestal = PedestalConfiguration.objects.get(id = id_p)
                 conf_rx = USRPRXConfiguration.objects.get(id = id_rx)
                 conf_tx = USRPTXConfiguration.objects.get(id = id_tx)
                 kwargs = {}
                 kwargs['experiment_keys'] = ['name', 'latitude', 'longitude', 'heading']
                 kwargs['experiment'] = experiment
-                kwargs['experiment_pedestal_keys'] = ['mode', 'axis', 'speed', 'angle']
+                if conf_pedestal.mode == 'position':
+                    kwargs['experiment_pedestal_keys'] = ['mode', 'axis', 'angle']
+                elif conf_pedestal.mode == 'speed':
+                    kwargs['experiment_pedestal_keys'] = ['mode', 'axis', 'speed']
+                else:
+                    kwargs['experiment_pedestal_keys'] = ['mode', 'axis', 'speed', 'angle', 'min_value', 'max_value']
                 kwargs['experiment_pedestal'] = conf_pedestal
-                kwargs['experiment_rx_keys'] = ['samplerate_rx', 'frequency_rx', 'datadir', 'clocksource', 'timesource', 'clockrate']
+                kwargs['experiment_rx_keys'] = ['ip_address_rx', 'daughterboard_rx', 'antenna_rx', 'samplerate_rx', 'frequency_rx', 'datadir', 'clocksource', 'timesource', 'clockrate']
                 kwargs['experiment_rx'] = conf_rx
-                kwargs['experiment_tx_keys'] = ['frequency', 'samplerate', 'ipp', 'delay', 'pulse_1', 'code_type_1', 'code_1', 'repetitions_1',
-                                                'enable_2', 'pulse_2', 'code_type_2', 'code_2', 'repetitions_2']
+                if not conf_tx.enable_2:
+                    kwargs['experiment_tx_keys'] = ['ip_address', 'daughterboard', 'antenna', 'frequency', 'samplerate', 'ipp', 'delay', 'pulse_1', 'code_type_1', 'code_1', 'repetitions_1']
+                else:
+                    kwargs['experiment_tx_keys'] = ['ip_address', 'daughterboard', 'antenna', 'frequency', 'samplerate', 'ipp', 'delay', 'pulse_1', 'code_type_1', 'code_1', 'repetitions_1',
+                                                'pulse_2', 'code_type_2', 'code_2', 'repetitions_2']
                 kwargs['experiment_tx'] = conf_tx
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Add Configuration'
                 kwargs['menu_experiments'] = 'active'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(confs=[conf_pedestal, conf_rx, conf_tx]))
                 return render(request, 'experiment.html', kwargs)
             @login_required
             def experiment_new(request, id_camp=None):
                 if not is_developer(request.user):
                     messages.error(
                         request, 'Developer required, to create new Experiments')
                     return redirect('index')
                 kwargs = {}
                 if request.method == 'GET':
                     kwargs['button'] = 'Create'
                     form = ExperimentForm()
                 if request.method == 'POST':
                     form = ExperimentForm(request.POST)
                     if form.is_valid():
                         experiment = form.save(commit=False)
                         experiment.author = request.user
                         experiment.save()
                         messages.success(request, 'Experiment configuration successfully created')
                         return redirect('url_experiment', id_exp=experiment.id)
                 kwargs['form'] = form
                 kwargs['title'] = 'Experiment'
                 kwargs['suptitle'] = 'New'
                 kwargs['menu_experiments'] = 'active'
                 return render(request, 'experiment_edit.html', kwargs)
             @login_required
             def experiment_edit(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 id_p = experiment.pedestal_id
                 id_rx = experiment.reception_rx_id
                 id_tx = experiment.transmission_tx_id
                 conf_pedestal = PedestalConfiguration.objects.get(id = id_p)
                 conf_rx = USRPRXConfiguration.objects.get(id = id_rx)
                 conf_tx = USRPTXConfiguration.objects.get(id = id_tx)
                 if request.method == 'GET':
                     form = ExperimentEditionForm(instance=experiment)
                     form_pedestal = PedestalEditionForm(instance=conf_pedestal)
                     form_rx = USRPRXEditionForm(instance=conf_rx)
                     form_tx = USRPTXEditionForm(instance=conf_tx)
                 if request.method == 'POST':
                     form = ExperimentEditionForm(request.POST, instance=experiment)
                     form_pedestal = PedestalEditionForm(request.POST, instance=conf_pedestal)
                     form_rx = USRPRXEditionForm(request.POST, instance=conf_rx)
                     form_tx = USRPTXEditionForm(request.POST, instance=conf_tx)
                     if form.is_valid() and form_pedestal.is_valid() and form_rx.is_valid() and form_tx.is_valid():
                         experiment = form.save(commit=False)
                         pedestal = form_pedestal.save(commit=False)
                         rx = form_rx.save(commit=False)
                         tx = form_tx.save(commit=False)
                         pedestal.save()
                         rx.save()
                         validation_usrp_tx_code(request, tx)
                         tx.save()
                         messages.success(request, 'Experiment configuration successfully updated')
                         return redirect('url_experiment', id_exp=experiment.id)
                 kwargs                     = {}
                 kwargs['form']             = form
                 kwargs['form_pedestal']    = form_pedestal
                 kwargs['form_rx']          = form_rx
                 kwargs['form_tx']          = form_tx
                 kwargs['title']            = 'Experiment'
                 kwargs['suptitle']         = 'Edit'
                 kwargs['button']           = 'Update'
                 kwargs['menu_experiments'] = 'active'
                 return render(request, 'experiment_edit.html', kwargs)
             @login_required
             def experiment_delete(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 if request.method == 'POST':
                     if is_developer(request.user):
                         #for conf in Configuration.objects.filter(experiment=experiment):
                             #conf.delete()
                         experiment.delete()
                         return redirect('url_experiments')
                     messages.error(request, 'Not enough permission to delete this object')
                     return redirect(experiment.get_absolute_url())
                 kwargs = {
                     'title': 'Delete',
                     'suptitle': 'Experiment',
                     'object': experiment,
                     'delete': True
                 }
                 return render(request, 'confirm.html', kwargs)
             @login_required
             def experiment_export(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 content = experiment.parms_to_dict()
                 content_type = 'application/json'
                 filename = '%s_%s.json' % (experiment.name, experiment.id)
                 response = HttpResponse(content_type=content_type)
                 response['Content-Disposition'] = 'attachment; filename="%s"' % filename
                 response.write(json.dumps(content, indent=2))
                 return response
             @login_required
             def experiment_import(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 configurations = Configuration.objects.filter(experiment=experiment)
                 if request.method == 'GET':
                     file_form = UploadFileForm()
                 if request.method == 'POST':
                     file_form = UploadFileForm(request.POST, request.FILES)
                     if file_form.is_valid():
                         new_exp = experiment.dict_to_parms(
                             json.load(request.FILES['file']), CONF_MODELS)
                         messages.success(
                             request, "Parameters imported from: '%s'." % request.FILES['file'].name)
                         return redirect(new_exp.get_absolute_url_edit())
                     messages.error(request, "Could not import parameters from file")
                 kwargs = {}
                 kwargs['title'] = 'Experiment'
                 kwargs['form'] = file_form
                 kwargs['suptitle'] = 'Importing file'
                 kwargs['button'] = 'Import'
                 kwargs['menu_experiments'] = 'active'
                 kwargs.update(sidebar(experiment=experiment))
                 return render(request, 'experiment_import.html', kwargs)
             @login_required
             def experiment_start(request, id_exp):
                 exp = get_object_or_404(Experiment, pk=id_exp)
                 exp.status = 0
                 if exp.status == 2:
                     messages.warning(request, 'Experiment {} already runnnig'.format(exp))
                 else:
                     exp.status = exp.start()
                     if exp.status == 0:
                         messages.error(request, 'Experiment {} not start'.format(exp))
                     if exp.status == 2:
                         messages.success(request, 'Experiment {} started'.format(exp))
                     exp.save()
                 return redirect(exp.get_absolute_url())
             @login_required
             def experiment_stop(request, id_exp):
                 exp = get_object_or_404(Experiment, pk=id_exp)
                 if exp.status == 2 or exp.status == 4:
                     exp.status = exp.stop()
                     exp.save()
                     messages.success(request, 'Experiment {} stopped'.format(exp))
                 else:
                     messages.error(request, 'Experiment {} not running'.format(exp))
                 return redirect(exp.get_absolute_url())
             def experiment_status(request, id_exp):
                 exp = get_object_or_404(Experiment, pk=id_exp)
                 exp.get_status()
                 return redirect(exp.get_absolute_url())
             def experiment_summary(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 configurations = Configuration.objects.filter(
                     experiment=experiment, type=0)
                 kwargs = {}
                 kwargs['experiment_keys'] = ['radar_system',
                                              'name', 'freq', 'start_time', 'end_time']
                 kwargs['experiment'] = experiment
                 kwargs['configurations'] = []
                 kwargs['title'] = 'Experiment Summary'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Verify Parameters'
                 c_vel = 3.0*(10**8)  # m/s
                 ope_freq = experiment.freq*(10**6)  # 1/s
                 radar_lambda = c_vel/ope_freq  # m
                 kwargs['radar_lambda'] = radar_lambda
                 ipp = None
                 nsa = 1
                 code_id = 0
                 tx_line = {}
                 for configuration in configurations.filter(device__device_type__name = 'pedestal'):
                     if configuration.mix:
                         continue
                     conf = {'conf': configuration}
                     conf['keys'] = []
                     conf['NTxs'] = configuration.ntx
                     conf['keys'].append('NTxs')
                     ipp = configuration.ipp
                     conf['IPP'] = ipp
                     conf['keys'].append('IPP')
                     lines = configuration.get_lines(line_type__name='tx')
                     for tx_line in lines:
                         tx_params = json.loads(tx_line.params)
                         conf[tx_line.get_name()] = '{} Km'.format(tx_params['pulse_width'])
                         conf['keys'].append(tx_line.get_name())
                         delays = tx_params['delays']
                         if delays not in ('', '0'):
                             n = len(delays.split(','))
                             taus = '{} Taus: {}'.format(n, delays)
                         else:
                             taus = '-'
                         conf['Taus ({})'.format(tx_line.get_name())] = taus
                         conf['keys'].append('Taus ({})'.format(tx_line.get_name()))
                         for code_line in configuration.get_lines(line_type__name='codes'):
                             code_params = json.loads(code_line.params)
                             code_id = code_params['code']
                             if tx_line.pk == int(code_params['TX_ref']):
                                 conf['Code ({})'.format(tx_line.get_name())] = '{}:{}'.format(RCLineCode.objects.get(pk=code_params['code']),
                                                                 '-'.join(code_params['codes']))
                                 conf['keys'].append('Code ({})'.format(tx_line.get_name()))
                         for windows_line in configuration.get_lines(line_type__name='windows'):
                             win_params = json.loads(windows_line.params)
                             if tx_line.pk == int(win_params['TX_ref']):
                                 windows = ''
                                 nsa = win_params['params'][0]['number_of_samples']
                                 for i, params in enumerate(win_params['params']):
                                     windows += 'W{}: Ho={first_height} km DH={resolution} km NSA={number_of_samples}<br>'.format(
                                         i, **params)
                                 conf['Window'] = mark_safe(windows)
                                 conf['keys'].append('Window')
                     kwargs['configurations'].append(conf)
                 for configuration in configurations.filter(device__device_type__name = 'jars'):
                     conf = {'conf': configuration}
                     conf['keys'] = []
                     conf['Type of Data'] = EXPERIMENT_TYPE[configuration.exp_type][1]
                     conf['keys'].append('Type of Data')
                     channels_number = configuration.channels_number
                     exp_type = configuration.exp_type
                     fftpoints = configuration.fftpoints
                     filter_parms = json.loads(configuration.filter_parms)
                     spectral_number = configuration.spectral_number
                     acq_profiles = configuration.acq_profiles
                     cohe_integr = configuration.cohe_integr
                     profiles_block = configuration.profiles_block
                     conf['Num of Profiles'] = acq_profiles
                     conf['keys'].append('Num of Profiles')
                     conf['Prof per Block'] = profiles_block
                     conf['keys'].append('Prof per Block')
                     conf['Blocks per File'] = configuration.raw_data_blocks
                     conf['keys'].append('Blocks per File')
                     if exp_type == 0:  # Short
                         bytes_ = 2
                         b = nsa*2*bytes_*channels_number
                     else:  # Float
                         bytes_ = 4
                         channels = channels_number + spectral_number
                         b = nsa*2*bytes_*fftpoints*channels
                     codes_num = 7
                     if code_id == 2:
                         codes_num = 7
                     elif code_id == 12:
                         codes_num = 15
                     #Jars filter values:
                     clock = float(filter_parms['clock'])
                     filter_2 = int(filter_parms['cic_2'])
                     filter_5 = int(filter_parms['cic_5'])
                     filter_fir = int(filter_parms['fir'])
                     Fs_MHz = clock/(filter_2*filter_5*filter_fir)
                     #Jars values:
                     if ipp is not None:
                         IPP_units = ipp/0.15*Fs_MHz
                         IPP_us = IPP_units / Fs_MHz
                         IPP_s = IPP_units / (Fs_MHz * (10**6))
                         Ts = 1/(Fs_MHz*(10**6))
                         Va = radar_lambda/(4*Ts*cohe_integr)
                         rate_bh = ((nsa-codes_num)*channels_number*2 *
                                     bytes_/IPP_us)*(36*(10**8)/cohe_integr)
                         rate_gh = rate_bh/(1024*1024*1024)
                         conf['Time per Block'] = IPP_s * profiles_block * cohe_integr
                         conf['keys'].append('Time per Block')
                         conf['Acq time'] = IPP_s * acq_profiles
                         conf['keys'].append('Acq time')
                         conf['Data rate'] = str(rate_gh)+" (GB/h)"
                         conf['keys'].append('Data rate')
                         conf['Va (m/s)'] = Va
                         conf['keys'].append('Va (m/s)')
                         conf['Vrange (m/s)'] = 3/(2*IPP_s*cohe_integr)
                         conf['keys'].append('Vrange (m/s)')
                     kwargs['configurations'].append(conf)
                 kwargs['menu_experiments'] = 'active'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(experiment=experiment))
                 return render(request, 'experiment_summary.html', kwargs)
             @login_required
             def experiment_verify(request, id_exp):
                 experiment = get_object_or_404(Experiment, pk=id_exp)
                 experiment_data = experiment.parms_to_dict()
                 configurations = Configuration.objects.filter(
                     experiment=experiment, type=0)
                 kwargs = {}
                 kwargs['experiment_keys'] = ['name', 'start_time', 'end_time']
                 kwargs['experiment'] = experiment
                 kwargs['configuration_keys'] = ['name', 'device__ip_address',
                                                 'device__port_address', 'device__status']
                 kwargs['configurations'] = configurations
                 kwargs['experiment_data'] = experiment_data
                 kwargs['title'] = 'Verify Experiment'
                 kwargs['suptitle'] = 'Parameters'
                 kwargs['button'] = 'Update'
                 jars_conf = False
                 rc_conf = False
                 dds_conf = False
                 for configuration in configurations:
                     #-------------------- JARS -----------------------:
                     if configuration.device.device_type.name == 'jars':
                         jars_conf = True
                         jars = configuration
                         kwargs['jars_conf'] = jars_conf
                         filter_parms = json.loads(jars.filter_parms)
                         kwargs['filter_parms'] = filter_parms
                         #--Sampling Frequency
                         clock = filter_parms['clock']
                         filter_2 = filter_parms['cic_2']
                         filter_5 = filter_parms['cic_5']
                         filter_fir = filter_parms['fir']
                         samp_freq_jars = clock/filter_2/filter_5/filter_fir
                         kwargs['samp_freq_jars'] = samp_freq_jars
                         kwargs['jars'] = configuration
                     #--------------------- RC ----------------------:
                     if configuration.device.device_type.name == 'pedestal' and not configuration.mix:
                         rc_conf = True
                         rc = configuration
                         rc_parms = configuration.parms_to_dict()
                         win_lines = rc.get_lines(line_type__name='windows')
                         if win_lines:
                             dh = json.loads(win_lines[0].params)['params'][0]['resolution']
                             #--Sampling Frequency
                             samp_freq_rc = 0.15/dh
                             kwargs['samp_freq_rc'] = samp_freq_rc
                             kwargs['rc_conf'] = rc_conf
                             kwargs['rc'] = configuration
                     #-------------------- DDS ----------------------:
                     if configuration.device.device_type.name == 'dds':
                         dds_conf = True
                         dds = configuration
                         dds_parms = configuration.parms_to_dict()
                         kwargs['dds_conf'] = dds_conf
                         kwargs['dds'] = configuration
                 #------------Validation------------:
                 #Clock
                 if dds_conf and rc_conf and jars_conf:
                     if float(filter_parms['clock']) != float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) and float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) != float(dds_parms['configurations']['byId'][str(dds.pk)]['clock']):
                         messages.warning(request, "Devices don't have the same clock.")
                 elif rc_conf and jars_conf:
                     if float(filter_parms['clock']) != float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']):
                         messages.warning(request, "Devices don't have the same clock.")
                 elif rc_conf and dds_conf:
                     if float(rc_parms['configurations']['byId'][str(rc.pk)]['clock_in']) != float(dds_parms['configurations']['byId'][str(dds.pk)]['clock']):
                         messages.warning(request, "Devices don't have the same clock.")
                     if float(samp_freq_rc) != float(dds_parms['configurations']['byId'][str(dds.pk)]['frequencyA']):
                         messages.warning(
                             request, "Devices don't have the same Frequency A.")
                 #------------POST METHOD------------:
                 if request.method == 'POST':
                     if request.POST['suggest_clock']:
                         try:
                             suggest_clock = float(request.POST['suggest_clock'])
                         except:
                             messages.warning(request, "Invalid value in CLOCK IN.")
                             return redirect('url_verify_experiment', id_exp=experiment.id)
                     else:
                         suggest_clock = ""
                     if suggest_clock:
                         if rc_conf:
                             rc.clock_in = suggest_clock
                             rc.save()
                         if jars_conf:
                             filter_parms = jars.filter_parms
                             filter_parms = ast.literal_eval(filter_parms)
                             filter_parms['clock'] = suggest_clock
                             jars.filter_parms = json.dumps(filter_parms)
                             jars.save()
                             kwargs['filter_parms'] = filter_parms
                         if dds_conf:
                             dds.clock = suggest_clock
                             dds.save()
                     if request.POST['suggest_frequencyA']:
                         try:
                             suggest_frequencyA = float(request.POST['suggest_frequencyA'])
                         except:
                             messages.warning(request, "Invalid value in FREQUENCY A.")
                             return redirect('url_verify_experiment', id_exp=experiment.id)
                     else:
                         suggest_frequencyA = ""
                     if suggest_frequencyA:
                         if jars_conf:
                             filter_parms = jars.filter_parms
                             filter_parms = ast.literal_eval(filter_parms)
                             filter_parms['fch'] = suggest_frequencyA
                             jars.filter_parms = json.dumps(filter_parms)
                             jars.save()
                             kwargs['filter_parms'] = filter_parms
                         if dds_conf:
                             dds.frequencyA_Mhz = request.POST['suggest_frequencyA']
                             dds.save()
                 kwargs['menu_experiments'] = 'active'
                 kwargs.update(sidebar(experiment=experiment))
                 return render(request, 'experiment_verify.html', kwargs)
             def dev_confs(request):
                 page = request.GET.get('page')
                 order = ('-programmed_date', )
                 filters = request.GET.copy()
                 if 'my configurations' in filters:
                     filters.pop('my configurations', None)
                     filters['mine'] = request.user.id
                 kwargs = get_paginator(Configuration, page, order, filters)
                 fields = ['tags', 'historical']
                 if request.user.is_authenticated:
                     fields.append('my configurations')
                 form = FilterForm(initial=request.GET, extra_fields=fields)
                 kwargs['keys'] = ['name', 'device',
                                   'type', 'programmed_date', 'actions']
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'List'
                 kwargs['no_sidebar'] = True
                 kwargs['form'] = form
                 kwargs['add_url'] = reverse('url_add_dev_conf', args=[0])
                 filters = request.GET.copy()
                 filters.pop('page', None)
                 kwargs['q'] = urlencode(filters)
                 kwargs['menu_configurations'] = 'active'
                 return render(request, 'base_list.html', kwargs)
             def dev_conf(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 return redirect(conf.get_absolute_url())
             @login_required
             def dev_conf_new(request, id_exp=0, id_dev=0):
                 if not is_developer(request.user):
                     messages.error(
                         request, 'Developer required, to create new configurations')
                     return redirect('index')
                 initial = {}
                 kwargs = {}
                 if id_exp != 0:
                     initial['experiment'] = id_exp
                 if id_dev != 0:
                     initial['device'] = id_dev
                 if request.method == 'GET':
                     if id_dev:
                         kwargs['button'] = 'Create'
                         device = Device.objects.get(pk=id_dev)
                         DevConfForm = CONF_FORMS[device.device_type.name]
                         initial['name'] = request.GET['name']
                         form = DevConfForm(initial=initial)
                     else:
                         kwargs['button'] = 'Create'
                         form = ConfigurationForm(initial=initial)
                 if request.method == 'POST':
                     device = Device.objects.get(pk=request.POST['device'])
                     DevConfForm = CONF_FORMS[device.device_type.name]
                     form = DevConfForm(request.POST)
                     kwargs['button'] = 'Create'
                     if form.is_valid():
                         conf = form.save(commit=False)
                         if device.device_type.name == 'usrp_tx':
                             validation_usrp_tx_code(request, conf)
                         conf.save()
                         conf.author = request.user
                         messages.success(request,  device.device_type.name + ' configuration successfully created')
                         return redirect('url_dev_conf', id_conf=conf.pk)
                 kwargs['id_exp'] = id_exp
                 kwargs['form'] = form
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'New'
                 kwargs['menu_configurations'] = 'active'
                 if id_dev != 0:
                     device = Device.objects.get(pk=id_dev)
                     kwargs['device'] = device.device_type.name
                 return render(request, 'dev_conf_edit.html', kwargs)
             @login_required
             def dev_conf_edit(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfForm = CONF_FORMS[conf.device.device_type.name]
                 if request.method == 'GET':
                     form = DevConfForm(instance=conf)
                 if request.method == 'POST':
                     form = DevConfForm(request.POST, instance=conf)
                     if form.is_valid():
                         form.save()
                         return redirect('url_dev_conf', id_conf=id_conf)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 kwargs['menu_configurations'] = 'active'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
             @login_required
             def dev_conf_start(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if conf.start_device():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 #conf.status_device()
                 return redirect(conf.get_absolute_url())
             @login_required
             def dev_conf_stop(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if conf.stop_device():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 #conf.status_device()
                 return redirect(conf.get_absolute_url())
             @login_required
             def dev_conf_status(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 conf_active = Configuration.objects.filter(pk=conf.device.conf_active).first()
                 if conf_active!=conf:
                     url = '#' if conf_active is None else conf_active.get_absolute_url()
                     label = 'None' if conf_active is None else conf_active.label
                     messages.warning(
                         request,
                         mark_safe('The current configuration has not been written to device, the active configuration is <a href="{}">{}</a>'.format(
                             url,
                             label
                             ))
                         )
                     return redirect(conf.get_absolute_url())
                 if conf.status_device():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 return redirect(conf.get_absolute_url())
             @login_required
             def dev_conf_reset(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if conf.reset_device():
                     messages.success(request, conf.message)
                 else:
                     messages.error(request, conf.message)
                 return redirect(conf.get_absolute_url())
             @login_required
             def dev_conf_write(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if request.method == 'POST':
                     if conf.write_device():
                         conf.device.conf_active = conf.pk
                         conf.device.save()
                         messages.success(request, conf.message)
                         if has_been_modified(conf):
                             conf.clone(type=1)
                     else:
                         messages.error(request, conf.message)
                     return redirect(get_object_or_404(Configuration, pk=id_conf).get_absolute_url())
                 kwargs = {
                     'title': 'Write Configuration',
                     'suptitle': conf.label,
                     'message': 'Are you sure yo want to write this {} configuration?'.format(conf.device),
                     'delete': False
                 }
                 kwargs['menu_configurations'] = 'active'
                 return render(request, 'confirm.html', kwargs)
             @login_required
             def dev_conf_read(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfForm = CONF_FORMS[conf.device.device_type.name]
                 if request.method == 'GET':
                     parms = conf.read_device()
                     #conf.status_device()
                     if not parms:
                         messages.error(request, conf.message)
                         return redirect(conf.get_absolute_url())
                     form = DevConfForm(initial=parms, instance=conf)
                 if request.method == 'POST':
                     form = DevConfForm(request.POST, instance=conf)
                     if form.is_valid():
                         form.save()
                         return redirect(conf.get_absolute_url())
                     messages.error(request, "Parameters could not be saved")
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['form'] = form
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Parameters read from device'
                 kwargs['button'] = 'Save'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
             @login_required
             def dev_conf_import(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 DevConfForm = CONF_FORMS[conf.device.device_type.name]
                 if request.method == 'GET':
                     file_form = UploadFileForm()
                 if request.method == 'POST':
                     file_form = UploadFileForm(request.POST, request.FILES)
                     if file_form.is_valid():
                         data = conf.import_from_file(request.FILES['file'])
                         parms = Params(data=data).get_conf(
                             dtype=conf.device.device_type.name)
                         if parms:
                             form = DevConfForm(initial=parms, instance=conf)
                             kwargs = {}
                             kwargs['id_dev'] = conf.id
                             kwargs['form'] = form
                             kwargs['title'] = 'Device Configuration'
                             kwargs['suptitle'] = 'Parameters imported'
                             kwargs['button'] = 'Save'
                             kwargs['action'] = conf.get_absolute_url_edit()
                             kwargs['previous'] = conf.get_absolute_url()
                             ###### SIDEBAR ######
                             kwargs.update(sidebar(conf=conf))
                             messages.success(
                                 request, "Parameters imported from: '%s'." % request.FILES['file'].name)
                             return render(request, '%s_conf_edit.html' % conf.device.device_type.name, kwargs)
                     messages.error(request, "Could not import parameters from file")
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['title'] = 'Device Configuration'
                 kwargs['form'] = file_form
                 kwargs['suptitle'] = 'Importing file'
                 kwargs['button'] = 'Import'
                 kwargs['menu_configurations'] = 'active'
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'dev_conf_import.html', kwargs)
             @login_required
             def dev_conf_export(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if request.method == 'GET':
                     file_form = DownloadFileForm(conf.device.device_type.name)
                 if request.method == 'POST':
                     file_form = DownloadFileForm(
                         conf.device.device_type.name, request.POST)
                     if file_form.is_valid():
                         fields = conf.export_to_file(
                             format=file_form.cleaned_data['format'])
                         if not fields['content']:
                             messages.error(request, conf.message)
                             return redirect(conf.get_absolute_url_export())
                         response = HttpResponse(content_type=fields['content_type'])
                         response['Content-Disposition'] = 'attachment; filename="%s"' % fields['filename']
                         response.write(fields['content'])
                         return response
                     messages.error(request, "Could not export parameters")
                 kwargs = {}
                 kwargs['id_dev'] = conf.id
                 kwargs['title'] = 'Device Configuration'
                 kwargs['form'] = file_form
                 kwargs['suptitle'] = 'Exporting file'
                 kwargs['button'] = 'Export'
                 kwargs['menu_configurations'] = 'active'
                 return render(request, 'dev_conf_export.html', kwargs)
             @login_required
             def dev_conf_delete(request, id_conf):
                 conf = get_object_or_404(Configuration, pk=id_conf)
                 if request.method == 'POST':
                     if is_developer(request.user):
                         try:
                             conf.delete()
                         except Exception as e:
                             messages.error(request, "The device configuration is protected")
                         return redirect('url_dev_confs')
                     messages.error(request, 'Not enough permission to delete this object')
                     return redirect(conf.get_absolute_url())
                 kwargs = {
                     'title': 'Delete',
                     'suptitle': 'Configuration',
                     'object': conf,
                     'delete': True
                 }
                 kwargs['menu_configurations'] = 'active'
                 return render(request, 'confirm.html', kwargs)
             def sidebar(**kwargs):
                 side_data = {}
                 conf = kwargs.get('conf', None)
                 confs = kwargs.get('confs', None)
                 experiment = kwargs.get('experiment', None)
                 if confs:
                     side_data['side_configurations'] = confs
                 if experiment:
                     side_data['experiment'] = experiment
                     experiments = [experiment]
                     #configurations = experiment.configuration_set.filter(type=0)
                     side_data['side_experiments'] = experiments
                     #side_data['side_configurations'] = configurations.order_by('device__device_type__name')
                 return side_data
             def get_paginator(model, page, order, filters={}, n=8):
                 kwargs = {}
                 query = Q()
                 if isinstance(filters, QueryDict):
                     filters = filters.dict()
                 [filters.pop(key) for key in list(filters) if filters[key] in ('', ' ')]
                 filters.pop('page', None)
                 fields = [f.name for f in model._meta.get_fields()]
                 if 'historical' in filters:
                     filters.pop('historical')
                     filters['type'] = 1
                 elif 'type' in fields:
                     filters['type'] = 0
                 if 'start_date' in filters:
                     filters['start_date__gte'] = filters.pop('start_date')
                 if 'end_date' in filters:
                     filters['start_date__lte'] = filters.pop('end_date')
                 if 'tags' in filters:
                     tags = filters.pop('tags')
                     if 'tags' in fields:
                         query = query | Q(tags__icontains=tags)
                     if 'label' in fields:
                         query = query | Q(label__icontains=tags)
                     if 'device' in fields:
                         query = query | Q(device__device_type__name__icontains=tags)
                     if 'device_type' in fields:
                         query = query | Q(device_type__name__icontains=tags)
                 if 'mine' in filters:
                     filters['author_id'] = filters['mine']
                     filters.pop('mine')
                 object_list = model.objects.filter(query, **filters).order_by(*order)
                 paginator = Paginator(object_list, n)
                 try:
                     objects = paginator.page(page)
                 except PageNotAnInteger:
                     objects = paginator.page(1)
                 except EmptyPage:
                     objects = paginator.page(paginator.num_pages)
                 kwargs['objects'] = objects
                 kwargs['offset'] = (int(page)-1)*n if page else 0
                 return kwargs
             @login_required
             def revoke_tasks(request, id_camp):
                 i         = app.control.inspect()
                 scheduled = list(i.scheduled().values())[0]
                 revoked   = list(i.revoked().values())[0]
                 for t in scheduled:
                     if t['request']['id'] in revoked:
                         continue
                     app.control.revoke(t['request']['id'])
                     exp  = Experiment.objects.get(pk=eval(str(t['request']['args']))[0])
                     eta  = t['eta']
                     task = t['request']['name'].split('.')[-1]
                     messages.warning(request, 'Scheduled {} at {} for experiment {} revoked'.format(task, eta, exp.name))
                 return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
             @login_required
             def show_tasks(request, id_camp):
                 i         = app.control.inspect()
                 scheduled = list(i.scheduled().values())[0]
                 revoked   = list(i.revoked().values())[0]
                 for t in scheduled:
                     if t['request']['id'] in revoked:
                         continue
                     exp = Experiment.objects.get(pk=eval(str(t['request']['args']))[0])
                     eta = t['eta']
                     task = t['request']['name'].split('.')[-1]
                     messages.success(request, 'Task {} scheduled at {} for experiment {}'.format(task, eta, exp.name))
                 return HttpResponseRedirect(reverse('url_operation', args=[id_camp]))
             def real_time(request):
                 graphic_path = "/home/fiorella/Pictures/catwbeanie.jpg"
                 kwargs = {}
                 kwargs['title'] = 'CLAIRE'
                 kwargs['suptitle'] = 'Real Time'
                 kwargs['no_sidebar'] = True
                 kwargs['graphic_path'] = graphic_path
                 kwargs['graphic1_path'] = 'http://www.bluemaize.net/im/girls-accessories/shark-beanie-11.jpg'
                 return render(request, 'real_time.html', kwargs)
             def theme(request, theme):
                 user = request.user
                 user.profile.theme = theme
                 user.save()
                 return redirect('index')

volumes/sirm/apps/pedestal/models.py +4 0

             import ast
             import json
             import requests
             import base64
             import struct
             from struct import pack
             import time
             from django.contrib import messages
             from django.db import models
             from django.urls import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from apps.main.models import Configuration
             MODE_VALUE = (
                     ('position', 'Position'),
                     ('speed', 'Speed'),
                     ('table', 'Table')
                 )
             class PedestalConfiguration(Configuration):
                 mode = models.CharField(
                     verbose_name='Mode',
                     max_length=10,
                     choices=MODE_VALUE,
                     null=False,
                     blank=False
                 )
                 axis = models.CharField(
                     verbose_name="Axis",
                     max_length=100,
                     blank=False,
                     null=False,
                     help_text="Please separate the values with commas when using table mode"
                 )
                 speed = models.CharField(
                     verbose_name='Speed',
                     max_length=100,
                     blank=True,
                     null=True
                 )
                 angle = models.CharField(
                     verbose_name="Angle(s)",
                     max_length=100,
                     blank=True,
                     null=True,
                     help_text="Please separate the values with commas when using table mode"
                 )
                 min_value = models.FloatField(
                     verbose_name='Min angle',
                     validators=[MinValueValidator(-5), MaxValueValidator(185)],
                     blank=True,
                     null=True
                 )
                 max_value = models.FloatField(
                     verbose_name='Max angle',
                     validators=[MinValueValidator(-5), MaxValueValidator(185)],
                     blank=True,
                     null=True
                 )
                 class Meta:
                     db_table = 'pedestal_configurations'
                 def __str__(self):
                     if self.mode=='position':
                         return u'Position: {}º {}'.format(self.angle, self.axis.upper())
                     if self.mode=='speed':
                         return u'Speed: {}º/s {}'.format(self.speed, self.axis.upper())
                     if self.mode=='table':
                         axis = [x.strip().upper() for x in self.axis.split(',')]
                         speeds = [float(x.strip()) for x in self.speed.split(',')]
                         table = [float(x.strip()) for x in self.angle.split(',')]
                         return u'Table: Axis {}, Speed {}º/s, Steps {}'.format(axis, speeds, table)
                 @property
                 def label(self):
                     return str(self)
                 def get_absolute_url_plot(self):
                     return reverse('url_plot_pedestal_pulses', args=[str(self.id)])
                 def request(self, cmd, method='get', **kwargs):
                     req = getattr(requests, method)(self.device.url(cmd), **kwargs)
                     payload = req.json()
                     return payload
                 def status_device(self):
                     try:
                         payload = requests.get(self.device.url())
                         if payload:
                             self.device.status = 1
                         elif payload['status']=='disable':
                             self.device.status = 2
                         else:
                             self.device.status = 1
                             self.device.save()
                             self.message = 'Pedestal status: {}'.format(payload['status'])
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         self.device.save()
                         self.message = 'Pedestal status: {}'.format(str(e))
                         return False
                     self.device.save()
                     return True
                 def reset_device(self, axi, angle):
                     try:
                         url = self.device.url() + "position?params="
                         payload_el = {'axis': 'elevation'}
                         payload_az = {'axis': 'azimuth'}
                         if axi == 'elevation':
                             payload_az['position'] = angle
                             payload_el['position'] = 0
                         elif axi == 'azimuth':
                             payload_el['position'] = angle
                             payload_az['position'] = 0
                         else:
                             payload_el['position'] = 0
                             payload_az['position'] = 0
                         json_data_el = json.dumps(payload_el)
                         json_data_az = json.dumps(payload_az)
                         base64_table_el = base64.standard_b64encode(json_data_el.encode('ascii'))
                         base64_table_az = base64.standard_b64encode(json_data_az.encode('ascii'))
                         time.sleep(0.1)
                         r = requests.get(url + base64_table_el.decode('ascii'))
                         time.sleep(0.1)
                         r = requests.get(url + base64_table_az.decode('ascii'))
                         if r:
                             self.device.status = 3
                             self.device.save()
                             self.message = 'Pedestal reset'
                         else:
                             return False
                     except Exception as e:
                         self.message = 'Pedestal reset: {}'.format(str(e))
                         return False
                     return True
                 def stop_device(self):
                     try:
                         command = self.device.url() + "stop"
                         r = requests.get(command)
                         if self.mode == 'table':
                             AX = {'az':'azimuth', 'el':'elevation'}
                             axis = [AX[x.lower().strip()] for x in self.axis.split(',')]
                             list_of_floats = [float(x.strip()) for x in self.angle.split(",")]
                             self.reset_device(axis[0], list_of_floats[0])
                         if r:
                             self.device.status = 4
                             self.device.save()
                             self.message = 'Pedestal stopped'
                         else:
                             self.device.status = 4
                             self.device.save()
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         #self.message = 'Pedestal stop: {}'.format(str(e))
                         self.message = "Pedestal can't start, please check network/device connection or IP address/port configuration"
                         self.device.save()
                         return False
                     return True
                 def start_device(self):
                     if self.mode == 'table':
                         if len(self.angle.split(',')) > 1:
                             list_speed = []
                             list_axis = []
                             for _ in range(len(self.angle.split(','))):
                                 list_axis.append(self.axis)
                                 list_speed.append(self.speed)
                             if len(self.axis.split(',')) == 1:
                                 self.axis = ",".join(map(str, list_axis))
                             if len(self.speed.split(',')) == 1:
                                 self.speed = ",".join(map(str, list_speed))
                     AX = {'az':'azimuth', 'el':'elevation'}
                     axis = [AX[x.lower().strip()] for x in self.axis.split(',')]
                     if len(axis)==1:
                         axis = axis[0]
                     try:
                         if self.mode == 'position':
                             url = self.device.url() + "position?params="
                             payload = {'axis': axis, 'position': float(self.angle)}
                         elif self.mode == 'speed':
                             url = self.device.url() + "speed?params="
                             payload = {'axis': axis, 'speed': float(self.speed)}
                         elif self.mode == 'table':
                             url = self.device.url() + "combinedtable?params="
                             list_of_floats = [float(x.strip()) for x in self.angle.split(",")]
                             byte_table = []
                             for x in list_of_floats:
                                 temp = bytearray(struct.pack("f", x))
                                 byte_table.append(temp[3])
                                 byte_table.append(temp[2])
                                 byte_table.append(temp[1])
                                 byte_table.append(temp[0])
                             coded_table = base64.standard_b64encode(bytes(byte_table))
                             coded_table_ascii = coded_table.decode('ascii')
                             speed = [float(x.strip()) for x in self.speed.split(',')]
+                            if isinstance(axis, str):
+                                axis = [axis]
                             payload = {
                                 'arraylength': len(speed),
                                 'axis': axis,
                                 'speed': speed,
                                 'bottom': self.min_value,
                                 'top': self.max_value,
                                 'table': coded_table_ascii
                                 }
                         json_data = json.dumps(payload)
                         print(json_data)
                         base64_table = base64.standard_b64encode(json_data.encode('ascii'))
                         url += base64_table.decode('ascii')
                         print(url)
                         r = requests.get(url)
                         if self.mode == 'table':
                             payload['table'] = list_of_floats
                         if r:
                             self.device.status = 3
                             self.device.save()
                             self.message = 'Pedestal configured and started'
                         else:
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         #self.message = 'Pedestal start: {}'.format(str(e))
                         self.message = "Pedestal can't start, please check network/device connection or IP address/port configuration"
                         self.device.save()
                         return False
                     return payload
                 def get_absolute_url_import(self):
                     return reverse('url_import_pedestal_conf', args=[str(self.id)])

volumes/sirm/apps/usrp_rx/forms.py +1 -1

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

volumes/sirm/apps/usrp_rx/models.py +9 -9

             import ast
             import json
             import requests
             import base64
             from struct import pack
             from django.db import models
             from django.urls import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from apps.main.models import Configuration
             BOARD_VALUE = (
                     ('1', 'A:AB'),
                     ('2', 'AB'),
                     ('3', 'A:A A:B'),
                 )
             ANT_VALUE = (
                     ('1', 'RX'),
                     ('2', 'TX')
                 )
             CLK_VALUE = (
                     ('1', 'internal'),
                     ('2', 'external')
                 )
             TIME_VALUE = (
                     ('1', 'internal'),
                     ('2', 'external')
                 )
             class USRPRXConfiguration(Configuration):
-                ip_address = models.GenericIPAddressField(
+                ip_address_rx = models.GenericIPAddressField(
                     verbose_name = 'IP address',
                     protocol='IPv4',
                     default='0.0.0.0')
-                daughterboard = models.CharField(
+                daughterboard_rx = models.CharField(
                     verbose_name='Daughterboard',
                     max_length=3,
                     choices=BOARD_VALUE,
                     null=False,
                     blank=False
                 )
-                antenna = models.CharField(
+                antenna_rx = models.CharField(
                     verbose_name='Antenna',
                     max_length=3,
                     choices=ANT_VALUE,
                     null=False,
                     blank=False
                 )
                 samplerate_rx = models.FloatField(
-                    verbose_name='Sample Rate',
+                    verbose_name='Sample Rate [MHz]',
                     validators=[MinValueValidator(0.01), MaxValueValidator(10.00)],
                     blank=False,
                     null=False,
                     help_text='Introduce the value in MHz (10^6)'
                 )
                 frequency_rx = models.FloatField(
-                    verbose_name='Frequency',
+                    verbose_name='Frequency [MHz]',
                     validators=[MinValueValidator(0.01)],
                     blank=False,
                     null=False,
                     help_text='Introduce the value in MHz (10^6)'
                 )
                 datadir = models.CharField(
                     verbose_name="Data Directory",
                     max_length=100,
                     default='',
                     blank=False,
                     null=False,
                     help_text='Fill with a directory. Example: /media/soporte/DATA'
                 )
                 clocksource = models.CharField(
                     verbose_name='Clock Source',
                     max_length=3,
                     choices=CLK_VALUE,
                     null=False,
                     blank=False
                 )
                 timesource = models.CharField(
                     verbose_name='Time Source',
                     max_length=3,
                     choices=TIME_VALUE,
                     null=False,
                     blank=False
                 )
                 clockrate = models.FloatField(
-                    verbose_name='Clock Rate',
+                    verbose_name='Clock Rate [MHz]',
                     blank=False,
                     null=False,
                     help_text='Introduce the value in MHz (10^6)'
                 )
                 class Meta:
                     db_table = 'usrp_rx_configurations'
                 def __str__(self):
                     return u'RX at {} MHz @ {} MHz'.format(self.frequency_rx, self.samplerate_rx)
                 def get_absolute_url_plot(self):
                     return reverse('url_plot_usrp_rx_pulses', args=[str(self.id)])
                 def request(self, cmd, method='get', **kwargs):
                     req = getattr(requests, method)(self.device.url(cmd), **kwargs)
                     payload = req.json()
                     return payload
                 def status_device(self):
                     try:
                         #self.device.status = 0
                         #payload = self.request('status')
                         payload = requests.get(self.device.url())
                         if payload:
                             self.device.status = 1
                         elif payload['status']=='disable':
                             self.device.status = 2
                         else:
                             self.device.status = 1
                             self.device.save()
                             self.message = 'USRP Rx Dev status: {}'.format(payload['status'])
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         self.device.save()
                         self.message = 'USRP Rx status: {}'.format(str(e))
                         return False
                     self.device.save()
                     return True
                 def reset_device(self):
                     try:
                         payload = self.request('reset', 'post')
                         if payload['reset']=='ok':
                             self.message = 'USRP Rx restarted OK'
                             self.device.status = 2
                             self.device.save()
                         else:
                             self.message = 'USRP Rx restart fail'
                             self.device.status = 4
                             self.device.save()
                     except Exception as e:
                         self.message = 'USRP Rx reset: {}'.format(str(e))
                         return False
                     return True
                 def stop_device(self):
                     try:
                         command = self.device.url() + "stoprx"
                         r = requests.get(command)
                         if r:
                             self.device.status = 4
                             self.device.save()
                             self.message = 'USRP stopped'
                         else:
                             self.device.status = 4
                             self.device.save()
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         #self.message = 'USRP Rx stop: {}'.format(str(e))
                         self.message = "USRP Rx can't start, please check network/device connection or IP address/port configuration"
                         self.device.save()
                         return False
                     return True
                 def start_device(self):
                     try:
                         usrp = USRPRXConfiguration.objects.get(pk=self)
-                        usrp_daughterboard = usrp.get_daughterboard_display()
+                        usrp_daughterboard_rx = usrp.get_daughterboard_rx_display()
-                        usrp_antenna = usrp.get_antenna_display()
+                        usrp_antenna_rx = usrp.get_antenna_rx_display()
                         usrp_clocksource = usrp.get_clocksource_display()
                         usrp_timesource = usrp.get_timesource_display()
-                        payload = {'ip_address': usrp.ip_address, 'daughterboard': usrp_daughterboard, 'antenna': usrp_antenna, 'sample_rate': usrp.samplerate_rx, 'frequency': usrp.frequency_rx,
+                        payload = {'ip_address': usrp.ip_address_rx, 'daughterboard': usrp_daughterboard_rx, 'antenna': usrp_antenna_rx, 'sample_rate': usrp.samplerate_rx, 'frequency': usrp.frequency_rx,
                                 'datadir': usrp.datadir, 'clock_source': usrp_clocksource, 'time_source': usrp_timesource, 'clock_rate':usrp.clockrate}
                         r = requests.post(self.device.url("usrprx"), json=payload)
                         if r:
                             self.device.status = 3
                             self.device.save()
                             self.message = 'USRP Rx configured and started'
                         else:
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         #self.message = 'USRP Rx start: {}'.format(str(e))
                         self.message = "USRP Rx can't start, please check network/device connection or IP address/port configuration"
                         self.device.save()
                         return False
                     return payload
                 def get_absolute_url_import(self):
                     return reverse('url_import_usrp_rx_conf', args=[str(self.id)])

volumes/sirm/apps/usrp_rx/views.py +1 -1

             import json
             from django.contrib import messages
             from django.utils.safestring import mark_safe
             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from django.contrib.auth.decorators import login_required
             from apps.main.models import Experiment, Device
             from apps.main.views import sidebar
             from .models import USRPRXConfiguration
             from .forms import USRPRXConfigurationForm, USRPRXImportForm
             def conf(request, conf_id):
                 conf = get_object_or_404(USRPRXConfiguration, pk=conf_id)
                 kwargs = {}
                 kwargs['dev_conf'] = conf
-                kwargs['dev_conf_keys'] = ['ip_address', 'daughterboard', 'antenna', 'samplerate_rx', 'frequency_rx', 'datadir', 'clocksource', 'timesource', 'clockrate']
+                kwargs['dev_conf_keys'] = ['ip_address_rx', 'daughterboard_rx', 'antenna_rx', 'samplerate_rx', 'frequency_rx', 'datadir', 'clocksource', 'timesource', 'clockrate']
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'Detail'
                 kwargs['button'] = 'Edit Configuration'
                 conf.status_device()
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'usrp_rx_conf.html', kwargs)
             @login_required
             def conf_edit(request, conf_id):
                 conf = get_object_or_404(USRPRXConfiguration, pk=conf_id)
                 if request.method=='GET':
                     form = USRPRXConfigurationForm(instance=conf)
                 elif request.method=='POST':
                     line_data = {}
                     conf_data = {}
                     clock_data = {}
                     extras = []
                     #classified post fields
                     for label,value in request.POST.items():
                         if label=='csrfmiddlewaretoken':
                             continue
                         if label.count('|')==0:
                             if label in ('mode', 'multiplier', 'divisor', 'reference'):
                                 clock_data[label] = value
                             else:
                                 conf_data[label] = value
                             continue
                         elif label.split('|')[0]!='-1':
                             extras.append(label)
                             continue
                         x, pk, name = label.split('|')
                         if name=='codes':
                             value = [s for s in value.split('\r\n') if s]
                         if pk in line_data:
                             line_data[pk][name] = value
                         else:
                             line_data[pk] = {name:value}
                     form = USRPRXConfigurationForm(conf_data, instance=conf)
                     if form.is_valid():
                         form.save()
                         messages.success(request, 'USRP Rx configuration successfully updated')
                         return redirect(conf.get_absolute_url())
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 kwargs['form'] = form
                 kwargs['edit'] = True
                 kwargs['title'] = 'USRP Rx Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 return render(request, 'usrp_rx_conf_edit.html', kwargs)
             def import_file(request, conf_id):
                 conf = get_object_or_404(USRPRXConfiguration, pk=conf_id)
                 if request.method=='POST':
                     form = USRPRXImportForm(request.POST, request.FILES)
                     if form.is_valid():
                         try:
                             data = conf.import_from_file(request.FILES['file_name'])
                             conf.dict_to_parms(data)
                             conf.update_pulses()
                             messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name'])
                             return redirect(conf.get_absolute_url_edit())
                         except Exception as e:
                             messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], repr(e)))
                 else:
                     messages.warning(request, 'Your current configuration will be replaced')
                     form = USRPRXImportForm()
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'USRP Rx Configuration'
                 kwargs['suptitle'] = 'Import file'
                 kwargs['button'] = 'Upload'
                 kwargs['previous'] = conf.get_absolute_url()
                 return render(request, 'usrp_rx_import.html', kwargs)
             def conf_raw(request, conf_id):
                 conf = get_object_or_404(USRPRXConfiguration, pk=conf_id)
                 raw = conf.write_device(raw=True)
                 return HttpResponse(raw, content_type='application/json')

volumes/sirm/apps/usrp_tx/forms.py +1 -1

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

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