radarsys Commit - r345:cf456d2fb627 · Jicamarca Repository

App JARS funcional

gonzalesluisfrancisco -

r345:cf456d2fb627

parent child

Context file:

r345:cf456d2fb627

Collapse all files

apps/jars/templates/jars_new_filter.html created 644 +2 0

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

README.md +1 -2

             The Integrated Radar System (SIR) is a web application that allows the configuration of the radar devices as required by the experiment,
             This app allows the creation of Campaigns, Experiment and Device Configurations.
-            For the python3.0 update please check the requeriments vrsion for each package. It depends on the python 3.7 or 3.8 version.
+            For the python3.0 update please check the requeriments vrsion for each package. It depends on the python 3.7 or 3.8 version. Special attention with the bokeh version.
-            Special attention with the bokeh version.
             For more information visit: http://jro-dev.igp.gob.pe:3000/projects/sistema-integrado-de-radar/wiki
             ## Installation

apps/abs/views.py +16 -17

             from .utils.overJroShow import overJroShow
             #from .utils.OverJRO import OverJRO
-            # Create your views here.
+            #Create your views here.
             import json, ast
                     beam_data = get_values_from_form(request.POST)
                     new_beam = ABSBeam(
-                               name = beam_data['name'],
+                               name     = beam_data['name'],
-                               antenna = json.dumps(beam_data['antenna']),
+                               antenna  = json.dumps(beam_data['antenna']),
                                abs_conf = conf,
-                               tx = json.dumps(beam_data['tx']),
+                               tx       = json.dumps(beam_data['tx']),
-                               rx = json.dumps(beam_data['rx']),
+                               rx       = json.dumps(beam_data['rx']),
-                               ues = json.dumps(beam_data['ues']),
+                               ues      = json.dumps(beam_data['ues']),
-                               only_rx = json.dumps(beam_data['only_rx'])
+                               only_rx  = json.dumps(beam_data['only_rx'])
                                )
                     new_beam.save()
                     messages.success(request, 'Beam: "%s" has been added.'  % new_beam.name)
                 ###### SIDEBAR ######
                 kwargs = {}
-                #kwargs['dev_conf'] = conf.device
+                #kwargs['dev_conf']  = conf.device
-                #kwargs['id_dev'] = conf.device
+                #kwargs['id_dev']    = conf.device
-                kwargs['id_conf'] = conf.id
+                #kwargs['previous']  = conf.get_absolute_url_edit()
-                kwargs['form'] = form
+                kwargs['id_conf']    = conf.id
-                kwargs['title'] = 'ABS Beams'
+                kwargs['form']       = form
-                kwargs['suptitle'] = 'Add Beam'
+                kwargs['title']      = 'ABS Beams'
-                kwargs['button'] = 'Add'
+                kwargs['suptitle']   = 'Add Beam'
+                kwargs['button']     = 'Add'
                 kwargs['no_sidebar'] = True
+                kwargs['edit']       = True
-                #kwargs['previous'] = conf.get_absolute_url_edit()
-                kwargs['edit'] = True
                 return render(request, 'abs_add_beam.html', kwargs)

apps/jars/forms.py +11 -2

                 #instance = globals()[model]
                 choices = model.objects.all().values_list('pk', 'name')
-                choices = add_empty_choice(choices)
+                choices = add_empty_choice(choices,label="New Choice")
                 return choices
             class JARSConfigurationForm(forms.ModelForm):
                     if 'initial' in kwargs:
                         self.fields['filter_template'] = forms.ChoiceField(
-                            choices=create_choices_from_model(JARSFilter),
+                            choices = create_choices_from_model(JARSFilter),
                             initial = kwargs['initial']['id']
                         )
                         # self.fields['name'].initial = kwargs['initial']['id']
                     model = JARSFilter
                     exclude = ('name', )
+            class JARSFilterFormNew(forms.ModelForm):
+                def __init__(self, *args, **kwargs):
+                    super(JARSFilterFormNew, self).__init__(*args, **kwargs)
+                    self.fields['f_decimal'].widget.attrs['readonly'] = True
+                class Meta:
+                    model = JARSFilter
+                    exclude = ()
             class ExtFileField(forms.FileField):
                 """

apps/jars/models.py +89 -74

             class JARSFilter(models.Model):
-                JARS_NBITS = 32
+                JARS_NBITS  = 32
-                name = models.CharField(verbose_name='Name', max_length=60, unique=True, default='')
+                name        = models.CharField(verbose_name='Name', max_length=60, unique=True, default='')
-                clock = models.FloatField(verbose_name='Clock In (MHz)', validators=[
+                clock       = models.FloatField(verbose_name='Clock In (MHz)', validators=[
                                           MinValueValidator(5), MaxValueValidator(75)], null=True, default=60)
-                multiplier = models.PositiveIntegerField(verbose_name='Multiplier', validators=[
+                multiplier  = models.PositiveIntegerField(verbose_name='Multiplier', validators=[
                                                          MinValueValidator(1), MaxValueValidator(20)], default=5)
-                frequency = models.FloatField(verbose_name='Frequency (MHz)', validators=[
+                frequency   = models.FloatField(verbose_name='Frequency (MHz)', validators=[
                                               MaxValueValidator(150)], null=True, default=49.9200)
-                f_decimal = models.BigIntegerField(verbose_name='Frequency (Decimal)', validators=[
+                f_decimal   = models.BigIntegerField(verbose_name='Frequency (Decimal)', validators=[
                                                    MinValueValidator(-9223372036854775808), MaxValueValidator(2**JARS_NBITS-1)], null=True, default=721554505)
-                cic_2 = models.PositiveIntegerField(verbose_name='CIC2', validators=[
+                cic_2       = models.PositiveIntegerField(verbose_name='CIC2', validators=[
                                                     MinValueValidator(2), MaxValueValidator(100)], default=10)
                 scale_cic_2 = models.PositiveIntegerField(verbose_name='Scale CIC2', validators=[
                                                           MinValueValidator(0), MaxValueValidator(6)], default=1)
-                cic_5 = models.PositiveIntegerField(verbose_name='CIC5', validators=[
+                cic_5       = models.PositiveIntegerField(verbose_name='CIC5', validators=[
                                                     MinValueValidator(1), MaxValueValidator(100)], default=1)
                 scale_cic_5 = models.PositiveIntegerField(verbose_name='Scale CIC5', validators=[
                                                           MinValueValidator(0), MaxValueValidator(20)], default=5)
-                fir = models.PositiveIntegerField(verbose_name='FIR', validators=[
+                fir         = models.PositiveIntegerField(verbose_name='FIR', validators=[
                                                   MinValueValidator(1), MaxValueValidator(100)], default=6)
-                scale_fir = models.PositiveIntegerField(verbose_name='Scale FIR', validators=[
+                scale_fir   = models.PositiveIntegerField(verbose_name='Scale FIR', validators=[
                                                         MinValueValidator(0), MaxValueValidator(7)], default=3)
                 number_taps = models.PositiveIntegerField(verbose_name='Number of taps', validators=[
                                                           MinValueValidator(1), MaxValueValidator(256)], default=4)
-                taps = models.CharField(verbose_name='Taps', max_length=1600, default='0')
+                taps        = models.CharField(verbose_name='Taps', max_length=1600, default='0')
                 class Meta:
                     db_table = 'jars_filters'
                 def jsonify(self):
-                    data = {}
+                    data    = {}
                     ignored = ()
                     for field in self._meta.fields:
                     parameters = {}
-                    parameters['name'] = self.name
+                    parameters['name']       = self.name
-                    parameters['clock'] = float(self.clock)
+                    parameters['clock']      = float(self.clock)
                     parameters['multiplier'] = int(self.multiplier)
-                    parameters['frequency'] = float(self.frequency)
+                    parameters['frequency']  = float(self.frequency)
-                    parameters['f_decimal'] = int(self.frequency)
+                    parameters['f_decimal']  = int(self.frequency)
-                    parameters['fir'] = int(self.fir)
+                    parameters['fir']        = int(self.fir)
-                    parameters['cic_2'] = int(self.cic_2)
+                    parameters['cic_2']      = int(self.cic_2)
-                    parameters['cic_5'] = int(self.cic_5)
+                    parameters['cic_5']      = int(self.cic_5)
                     return parameters
                 def dict_to_parms(self, parameters):
-                    self.name = parameters['name']
+                    self.name       = parameters['name']
-                    self.clock = parameters['clock']
+                    self.clock      = parameters['clock']
                     self.multiplier = parameters['multiplier']
-                    self.frequency = parameters['frequency']
+                    self.frequency  = parameters['frequency']
-                    self.f_decimal = parameters['f_decimal']
+                    self.f_decimal  = parameters['f_decimal']
-                    self.fir = parameters['fir']
+                    self.fir        = parameters['fir']
-                    self.cic_2 = parameters['cic_2']
+                    self.cic_2      = parameters['cic_2']
-                    self.cic_5 = parameters['cic_5']
+                    self.cic_5      = parameters['cic_5']
+                def dict_to_parms_new(self, parameters):
+                    self.name        = parameters['name']
+                    self.clock       = parameters['clock']
+                    self.multiplier  = parameters['multiplier']
+                    self.frequency   = parameters['frequency']
+                    self.f_decimal   = parameters['f_decimal']
+                    self.fir         = parameters['fir']
+                    self.cic_2       = parameters['cic_2']
+                    self.cic_5       = parameters['cic_5']
+                    self.scale_fir   = parameters['scale_fir']
+                    self.scale_cic_2 = parameters['scale_cic_2']
+                    self.scale_cic_5 = parameters['scale_cic_5']
+                    self.number_taps = parameters['number_taps']
+                    self.taps        = parameters['taps']
             class JARSConfiguration(Configuration):
-                ADC_RESOLUTION = 8
+                ADC_RESOLUTION   = 8
                 PCI_DIO_BUSWIDTH = 32
-                HEADER_VERSION = 1103
+                HEADER_VERSION   = 1103
-                BEGIN_ON_START = True
+                BEGIN_ON_START   = True
-                REFRESH_RATE = 1
+                REFRESH_RATE     = 1
-                exp_type = models.PositiveIntegerField(
+                exp_type         = models.PositiveIntegerField(
                     verbose_name='Experiment Type', choices=EXPERIMENT_TYPE, default=0)
-                cards_number = models.PositiveIntegerField(verbose_name='Number of Cards', validators=[
+                cards_number     = models.PositiveIntegerField(verbose_name='Number of Cards', validators=[
                                                            MinValueValidator(1), MaxValueValidator(4)], default=1)
-                channels_number = models.PositiveIntegerField(verbose_name='Number of Channels', validators=[
+                channels_number  = models.PositiveIntegerField(verbose_name='Number of Channels', validators=[
                                                               MinValueValidator(1), MaxValueValidator(8)], default=5)
-                channels = models.CharField(
+                channels         = models.CharField(
                     verbose_name='Channels', max_length=15, default='1,2,3,4,5')
-                data_type = models.PositiveIntegerField(
+                data_type        = models.PositiveIntegerField(
                     verbose_name='Data Type', choices=DATA_TYPE, default=0)
-                raw_data_blocks = models.PositiveIntegerField(
+                raw_data_blocks  = models.PositiveIntegerField(
                     verbose_name='Raw Data Blocks', validators=[MaxValueValidator(5000)], default=60)
-                profiles_block = models.PositiveIntegerField(
+                profiles_block   = models.PositiveIntegerField(
                     verbose_name='Profiles Per Block', default=400)
-                acq_profiles = models.PositiveIntegerField(
+                acq_profiles     = models.PositiveIntegerField(
                     verbose_name='Acquired Profiles', default=400)
-                ftp_interval = models.PositiveIntegerField(
+                ftp_interval     = models.PositiveIntegerField(
                     verbose_name='FTP Interval', default=60)
-                fftpoints = models.PositiveIntegerField(
+                fftpoints        = models.PositiveIntegerField(
                     verbose_name='FFT Points', default=16)
-                cohe_integr_str = models.PositiveIntegerField(
+                cohe_integr_str  = models.PositiveIntegerField(
                     verbose_name='Coh. Int. Stride', validators=[MinValueValidator(1)], default=30)
-                cohe_integr = models.PositiveIntegerField(
+                cohe_integr      = models.PositiveIntegerField(
                     verbose_name='Coherent Integrations', validators=[MinValueValidator(1)], default=30)
-                incohe_integr = models.PositiveIntegerField(
+                incohe_integr    = models.PositiveIntegerField(
                     verbose_name='Incoherent Integrations', validators=[MinValueValidator(1)], default=30)
-                decode_data = models.PositiveIntegerField(
+                decode_data      = models.PositiveIntegerField(
                     verbose_name='Decode Data', choices=DECODE_TYPE, default=0)
-                post_coh_int = models.BooleanField(
+                post_coh_int     = models.BooleanField(
                     verbose_name='Post Coherent Integration', default=False)
-                spectral_number = models.PositiveIntegerField(
+                spectral_number  = models.PositiveIntegerField(
                     verbose_name='# Spectral Combinations', validators=[MinValueValidator(1)], default=1)
-                spectral = models.CharField(
+                spectral         = models.CharField(
                     verbose_name='Combinations', max_length=5000, default='[0, 0],')
                 create_directory = models.BooleanField(
                     verbose_name='Create Directory Per Day', default=True)
-                include_expname = models.BooleanField(
+                include_expname  = models.BooleanField(
                     verbose_name='Experiment Name in Directory', default=False)
                 #view_raw_data    = models.BooleanField(verbose_name='View Raw Data', default=True)
-                save_ch_dc = models.BooleanField(
+                save_ch_dc       = models.BooleanField(
                     verbose_name='Save Channels DC', default=True)
-                save_data = models.BooleanField(verbose_name='Save Data', default=True)
+                save_data        = models.BooleanField(verbose_name='Save Data', default=True)
-                filter_parms = models.CharField(
+                filter_parms     = models.CharField(
                     max_length=10000, default=FILTER)
-                filter = models.ForeignKey(
+                filter           = models.ForeignKey(
                     'JARSFilter', verbose_name='Filter', null=True, blank=True, on_delete=models.CASCADE)
                 class Meta:
                 def filter_resolution(self):
                     filter_parms = json.loads(self.filter_parms)
-                    clock = float(filter_parms['clock'])
+                    clock        = float(filter_parms['clock'])
-                    cic_2 = filter_parms['cic_2']
+                    cic_2        = filter_parms['cic_2']
-                    cic_5 = filter_parms['cic_5']
+                    cic_5        = filter_parms['cic_5']
-                    fir = filter_parms['fir']
+                    fir          = filter_parms['fir']
-                    resolution = round((clock/(cic_2*cic_5*fir)), 2)
+                    resolution   = round((clock/(cic_2*cic_5*fir)), 2)
                     return resolution
                 def dict_to_parms(self, params, id=None):
                     self.exp_type = data['exp_type']
                     #----PDATA----
                     if self.exp_type == 1:
-                        self.incohe_integr = data['incohe_integr']
+                        self.incohe_integr   = data['incohe_integr']
                         self.spectral_number = data['spectral_number']
-                        self.spectral = data['spectral']
+                        self.spectral        = data['spectral']
-                        self.fftpoints = data['fftpoints']
+                        self.fftpoints       = data['fftpoints']
-                        self.save_ch_dc = data['save_ch_dc']
+                        self.save_ch_dc      = data['save_ch_dc']
                     else:
                         self.raw_data_blocks = data['raw_data_blocks']
                     #----PDATA----
-                    self.cards_number = data['cards_number']
+                    self.cards_number    = data['cards_number']
                     self.channels_number = data['channels_number']
-                    self.channels = data['channels']
+                    self.channels        = data['channels']
-                    self.data_type = data['data_type']
+                    self.data_type       = data['data_type']
-                    self.profiles_block = data['profiles_block']
+                    self.profiles_block  = data['profiles_block']
-                    self.acq_profiles = data['acq_profiles']
+                    self.acq_profiles    = data['acq_profiles']
-                    self.ftp_interval = data['ftp_interval']
+                    self.ftp_interval    = data['ftp_interval']
                     self.cohe_integr_str = data['cohe_integr_str']
-                    self.cohe_integr = data['cohe_integr']
+                    self.cohe_integr     = data['cohe_integr']
                     #----DECODE----
-                    self.decode_data = data['decode_data']
+                    self.decode_data  = data['decode_data']
                     self.post_coh_int = data['post_coh_int']
                     #----DECODE----
                     self.create_directory = data['create_directory']
-                    self.include_expname = data['include_expname']
+                    self.include_expname  = data['include_expname']
-                    self.save_data = data['save_data']
+                    self.save_data        = data['save_data']
-                    self.filter_parms = json.dumps(data['filter_parms'])
+                    self.filter_parms     = json.dumps(data['filter_parms'])
                     self.save()
                         return False
                     data = self.experiment.parms_to_dict()
+                    #print(data)
                     for key in data['configurations']['allIds']:
                         if data['configurations']['byId'][key]['device_type'] in ('dds', 'cgs'):
                             data['configurations']['allIds'].remove(key)

apps/jars/templates/jars.html +1 -1

             {% extends "base.html" %}
-            {% load bootstrap3 %}
+            {% load bootstrap4 %}
             {% block mainactive %}active{% endblock %}
             {% block content-title %}Acquisition System{% endblock %}

apps/jars/templates/jars_conf.html +1 -1

             {% extends "dev_conf.html" %}
             {% load static %}
-            {% load bootstrap3 %}
+            {% load bootstrap4 %}
             {% load main_tags %}
             {% block extra-menu-actions %}

apps/jars/templates/jars_conf_edit.html +5 -2

             {% extends "dev_conf_edit.html" %}
-            {% load bootstrap3 %}
+            {% load bootstrap4 %}
             {% load static %}
             {% load main_tags %}
               });
               $("#id_filter_template").change(function () {
-                document.location = "{% url 'url_change_jars_filter' id_dev %}" + $("#id_filter_template").val();
+                if($("#id_filter_template").val()!=0)
+                  document.location = "{% url 'url_change_jars_filter' id_dev %}" + $("#id_filter_template").val();
+                else
+                  document.location = "{% url 'url_new_jars_filter' id_dev %}"
               });
             </script>

apps/jars/urls.py +1 0

                 path('<int:id_conf>/edit/', views.jars_conf_edit, name='url_edit_jars_conf'),
                 path('<int:conf_id>/change_filter/', views.change_filter, name='url_change_jars_filter'),
                 path('<int:conf_id>/change_filter/<int:filter_id>/', views.change_filter, name='url_change_jars_filter'),
+                path('<int:conf_id>/new_filter/', views.new_filter, name='url_new_jars_filter'),
                 path('<int:conf_id>/import/', views.import_file, name='url_import_jars_conf'),
                 path('<int:conf_id>/read/', views.read_conf, name='url_read_jars_conf'),
                 path('<int:conf_id>/get_log/', views.get_log, name='url_get_jars_log'),

apps/jars/views.py +56 -29

             from apps.main.views import sidebar
             from .models import JARSConfiguration, JARSFilter
-            from .forms import JARSConfigurationForm, JARSFilterForm, JARSImportForm
+            from .forms import JARSConfigurationForm, JARSFilterForm, JARSImportForm,JARSFilterFormNew
             import json
             # Create your views here.
                 filter_parms = json.loads(conf.filter_parms)
                 kwargs = {}
-                kwargs['filter'] = filter_parms
+                kwargs['filter']       = filter_parms
-                kwargs['filter_obj'] = JARSFilter.objects.get(pk=1)
+                kwargs['filter_obj']   = JARSFilter.objects.get(pk=1)
                 kwargs['filter_keys']  = ['clock', 'multiplier', 'frequency', 'f_decimal',
                                           'cic_2', 'scale_cic_2', 'cic_5', 'scale_cic_5', 'fir',
                                           'scale_fir', 'number_taps', 'taps']
-                filter_resolution = conf.filter_resolution()
+                filter_resolution      = conf.filter_resolution()
-                kwargs['resolution'] = '{} (MHz)'.format(filter_resolution)
+                kwargs['resolution']   = '{} (MHz)'.format(filter_resolution)
                 if filter_resolution < 1:
                     kwargs['resolution'] = '{} (kHz)'.format(filter_resolution*1000)
-                kwargs['status'] = conf.device.get_status_display()
+                kwargs['status']        = conf.device.get_status_display()
-                kwargs['dev_conf'] = conf
+                kwargs['dev_conf']      = conf
                 kwargs['dev_conf_keys'] = ['cards_number', 'channels_number', 'channels',
                                            'ftp_interval', 'data_type','acq_profiles',
                                            'profiles_block', 'raw_data_blocks', 'ftp_interval',
             def jars_conf_edit(request, id_conf):
-                conf = get_object_or_404(JARSConfiguration, pk=id_conf)
+                conf         = get_object_or_404(JARSConfiguration, pk=id_conf)
                 filter_parms = json.loads(conf.filter_parms)
                 if request.method=='GET':
-                    form = JARSConfigurationForm(instance=conf)
+                    form        = JARSConfigurationForm(instance=conf)
                     filter_form = JARSFilterForm(initial=filter_parms)
                 if request.method=='POST':
-                    form = JARSConfigurationForm(request.POST, instance=conf)
+                    form        = JARSConfigurationForm(request.POST, instance=conf)
                     filter_form = JARSFilterForm(request.POST)
                     if filter_form.is_valid():
-                       jars_filter = filter_form.cleaned_data
+                       jars_filter       = filter_form.cleaned_data
                        jars_filter['id'] = request.POST['filter_template']
                     else:
                        messages.error(request, filter_form.errors)
                     if form.is_valid():
-                        conf = form.save(commit=False)
+                        conf              = form.save(commit=False)
                         conf.filter_parms = json.dumps(jars_filter)
                         conf.save()
                         return redirect('url_jars_conf', id_conf=conf.id)
                 kwargs = {}
-                kwargs['id_dev'] = conf.id
+                kwargs['id_dev']      = conf.id
-                kwargs['form'] = form
+                kwargs['form']        = form
                 kwargs['filter_form'] = filter_form
                 kwargs['filter_name'] = JARSFilter.objects.get(pk=filter_parms['id']).name
-                kwargs['title'] = 'Device Configuration'
+                kwargs['title']       = 'Device Configuration'
-                kwargs['suptitle'] = 'Edit'
+                kwargs['suptitle']    = 'Edit'
-                kwargs['button'] = 'Save'
+                kwargs['button']      = 'Save'
                 return render(request, 'jars_conf_edit.html', kwargs)
                     form = JARSImportForm()
                 kwargs = {}
-                kwargs['form'] = form
+                kwargs['form']     = form
-                kwargs['title'] = 'JARS Configuration'
+                kwargs['title']    = 'JARS Configuration'
                 kwargs['suptitle'] = 'Import file'
-                kwargs['button'] = 'Upload'
+                kwargs['button']   = 'Upload'
                 kwargs['previous'] = conf.get_absolute_url()
                 return render(request, 'jars_import.html', kwargs)
                     messages.error(request, "Parameters could not be saved")
                 kwargs = {}
-                kwargs['id_dev'] = conf.id
+                kwargs['id_dev']    = conf.id
                 kwargs['filter_id'] = conf.filter.id
-                kwargs['form'] = form
+                kwargs['form']      = form
-                kwargs['title'] = 'Device Configuration'
+                kwargs['title']     = 'Device Configuration'
-                kwargs['suptitle'] = 'Parameters read from device'
+                kwargs['suptitle']  = 'Parameters read from device'
-                kwargs['button'] = 'Save'
+                kwargs['button']    = 'Save'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'jars_conf_edit.html', kwargs)
+            def new_filter(request, conf_id):
+                conf         = get_object_or_404(JARSConfiguration, pk=conf_id)
+                form         = JARSFilterFormNew()
+                if request.method=='POST':
+                    filter_form = JARSFilterFormNew(request.POST)
+                    if filter_form.is_valid():
+                       jars_filter       = filter_form.cleaned_data
+                       jars_filter['id'] = request.POST['name']
+                    else:
+                       messages.error(request, filter_form.errors)
+                    #print(json.dumps(jars_filter))
+                    jars_filter_obj       = JARSFilter()
+                    jars_filter_obj.dict_to_parms_new(request.POST)
+                    jars_filter_obj.save()
+                    return redirect('url_edit_jars_conf', id_conf=conf.id)
+                kwargs = {}
+                kwargs['id_dev']    = conf.id
+                kwargs['form']      = form
+                kwargs['title']     = 'New JARS Filter'
+                kwargs['suptitle']  = 'Parameters'
+                kwargs['button']    = 'Save'
+                return render(request, 'jars_new_filter.html', kwargs)
             def change_filter(request, conf_id, filter_id):
-                conf = get_object_or_404(JARSConfiguration, pk=conf_id)
+                conf              = get_object_or_404(JARSConfiguration, pk=conf_id)
-                filter = get_object_or_404(JARSFilter, pk=filter_id)
+                filter            = get_object_or_404(JARSFilter, pk=filter_id)
                 conf.filter_parms = json.dumps(filter.jsonify())
                 conf.save()
                     messages.error(request, message)
                     return redirect('url_jars_conf', id_conf=conf.id)
                 except Exception as e:
-                    message = 'Restarting Report.txt has been downloaded successfully.'
+                    message = 'Restarting Report.txt has been downloaded successfully.'+e
                 content = response
                 filename     =  'Log_%s_%s.txt' %(conf.experiment.name, conf.experiment.id)

apps/jars/widgets.py +2 -2

             class SpectralWidget(forms.widgets.TextInput):
-                def render(self, label, value, attrs=None):
+                def render(self, name, value, attrs=None, renderer=None):
+                    label = name
                     readonly = 'readonly' if attrs.get('readonly', False) else ''
                     name = attrs.get('name', label)
                     if value == None:

apps/main/models.py +8 0

                         data['phaseA'] = dds_data.phase_to_binary(data['phaseA_degrees'])
                         data['phaseB'] = dds_data.phase_to_binary(data['phaseB_degrees'])
+                    elif self.device.device_type.name == 'dds_rest':
+                        data['frequencyA_Mhz'] = float(data['frequencyA_Mhz'])
+                        data['frequencyB_Mhz'] = float(data['frequencyB_Mhz'])
+                        data['phaseA'] = dds_data.phase_to_binary(data['phaseA_degrees'])
+                        data['phaseB'] = dds_data.phase_to_binary(data['phaseB_degrees'])
+                        data['delta_frequency_Mhz'] = float(data['delta_frequency_Mhz'] or 0.00)
+                        data['update_clock_Mhz']    = float(data['update_clock_Mhz'] or 0.00)
+                        data['ramp_rate_clock_Mhz'] = float(data['ramp_rate_clock_Mhz'] or 0.0)
                     return data
                 def clone(self, **kwargs):

apps/rc/widgets.py 0 -2

                     else:
                         return mark_safe(html+script)
                     return mark_safe(html)

radarsys/settings.py +6 -6

             REDIS_PORT = os.environ.get('REDIS_PORT', 6300)
             BROKER_TRANSPORT = 'redis'
-            BROKER_URL = 'redis://{}:{}/0'.format(REDIS_HOST, REDIS_PORT)
+            BROKER_URL       = 'redis://{}:{}/0'.format(REDIS_HOST, REDIS_PORT)
-            CELERY_RESULT_BACKEND = 'redis://{}:{}/0'.format(REDIS_HOST, REDIS_PORT)
+            CELERY_RESULT_BACKEND    = 'redis://{}:{}/0'.format(REDIS_HOST, REDIS_PORT)
-            CELERY_BROKER_TRANSPORT = BROKER_URL
+            CELERY_BROKER_TRANSPORT  = BROKER_URL
-            CELERY_ACCEPT_CONTENT = ['application/json']
+            CELERY_ACCEPT_CONTENT    = ['application/json']
-            CELERY_TASK_SERIALIZER = 'json'
+            CELERY_TASK_SERIALIZER   = 'json'
             CELERY_RESULT_SERIALIZER = 'json'
-            CELERY_ENABLE_UTC = False
+            CELERY_ENABLE_UTC        = False

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages