radarsys Commit - r209:90fa9a52ca2f · Jicamarca Repository

Standardize jars functions: start, stop, write, read, status...

Fiorella Quino -

r209:90fa9a52ca2f

parent child

Context file:

r209:90fa9a52ca2f

Collapse all files

apps/jars/models.py +70 -20

             from django.db import models
             from apps.main.models import Configuration
             from django.core.validators import MinValueValidator, MaxValueValidator
             from django.core.urlresolvers import reverse
             from devices.jars import api
             from apps.rc.models import RCConfiguration
             import json
             # Create your models here.
             EXPERIMENT_TYPE = (
                                (0, 'RAW_DATA'),
                                (1, 'PDATA'),
                                )
             DATA_TYPE = (
                          (0, 'SHORT'),
                          (1, 'FLOAT'),
                          )
             class JARSfilter(models.Model):
                 JARS_NBITS = 32
                 name        = models.CharField(max_length=60, unique=True, default='')
                 clock       = models.FloatField(verbose_name='Clock In (MHz)',validators=[MinValueValidator(5), MaxValueValidator(75)], null=True, default=60)
                 mult        = models.PositiveIntegerField(verbose_name='Multiplier',validators=[MinValueValidator(1), MaxValueValidator(20)], default=5)
                 fch         = models.DecimalField(verbose_name='Frequency (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=19, decimal_places=16, null=True, default=49.9200)
                 fch_decimal = models.BigIntegerField(verbose_name='Frequency (Decimal)',validators=[MinValueValidator(0), MaxValueValidator(2**JARS_NBITS-1)], null=True, default=721554505)
                 filter_fir  = models.PositiveIntegerField(verbose_name='FIR Filter',validators=[MinValueValidator(1), MaxValueValidator(20)], default = 6)
                 filter_2    = models.PositiveIntegerField(verbose_name='Filter 2',validators=[MinValueValidator(1), MaxValueValidator(20)], default = 10)
                 filter_5    = models.PositiveIntegerField(verbose_name='Filter 5',validators=[MinValueValidator(1), MaxValueValidator(20)], default = 1)
                 speed       = models.PositiveIntegerField(verbose_name='Speed',validators=[MinValueValidator(0), MaxValueValidator(100000)], default = 0)
                 class Meta:
                     db_table = 'jars_filters'
                 def __unicode__(self):
                     return u'%s' % (self.name)
                 def parms_to_dict(self):
                     parameters = {}
                     parameters['name']        = self.name
                     parameters['clock']       = float(self.clock)
                     parameters['mult']        = int(self.mult)
                     parameters['fch']         = float(self.fch)
                     parameters['fch_decimal'] = int(self.fch)
                     parameters['filter_fir']  = int(self.filter_fir)
                     parameters['filter_2']    = int(self.filter_2)
                     parameters['filter_5']    = int(self.filter_5)
                     parameters['speed']       = int(self.speed)
                     return parameters
                 def dict_to_parms(self, parameters):
                     self.name        = parameters['name']
                     self.clock       = parameters['clock']
                     self.mult        = parameters['mult']
                     self.fch         = parameters['fch']
                     self.fch_decimal = parameters['fch_decimal']
                     self.filter_fir  = parameters['filter_fir']
                     self.filter_2    = parameters['filter_2']
                     self.filter_5    = parameters['filter_5']
                     self.speed       = parameters['speed']
             class JARSConfiguration(Configuration):
                 ADC_RESOLUTION   = 8
                 PCI_DIO_BUSWIDTH = 32
                 HEADER_VERSION   = 1103
                 BEGIN_ON_START   = True
                 REFRESH_RATE     = 1
                 #rc               = models.ForeignKey(RCConfiguration, on_delete=models.CASCADE, null=True)
                 exp_type         = models.PositiveIntegerField(verbose_name='Experiment Type', choices=EXPERIMENT_TYPE, default=0)
                 cards_number     = models.PositiveIntegerField(verbose_name='Number of Cards', validators=[MinValueValidator(1), MaxValueValidator(4)], default = 1)
                 channels_number  = models.PositiveIntegerField(verbose_name='Number of Channels', validators=[MinValueValidator(1), MaxValueValidator(8)], default = 5)
                 channels         = models.CharField(verbose_name='Channels', max_length=15, default = '1,2,3,4,5')
                 rd_directory     = models.CharField(verbose_name='Raw Data Directory', max_length=200, default='', blank=True, null=True)
                 pd_directory     = models.CharField(verbose_name='Process Data Directory', max_length=200, default='', blank=True, null=True)
                 #raw_data_blocks  = models.PositiveIntegerField(verbose_name='Raw Data Blocks', validators=[MaxValueValidator(5000)], default=120)
                 data_type        = models.PositiveIntegerField(verbose_name='Data Type', choices=DATA_TYPE, default=0)
                 acq_profiles     = models.PositiveIntegerField(verbose_name='Acquired Profiles', validators=[MaxValueValidator(5000)], default=400)
                 profiles_block   = models.PositiveIntegerField(verbose_name='Profiles Per Block', validators=[MaxValueValidator(5000)], default=400)
                 ftp_interval     = models.PositiveIntegerField(verbose_name='FTP Interval', default=60)
                 fftpoints        = models.PositiveIntegerField(verbose_name='FFT Points',default=16)
                 cohe_integr_str  = models.PositiveIntegerField(verbose_name='Coh. Int. Stride',validators=[MinValueValidator(1)], default=30)
                 cohe_integr      = models.PositiveIntegerField(verbose_name='Coherent Integrations',validators=[MinValueValidator(1)], default=30)
                 incohe_integr    = models.PositiveIntegerField(verbose_name='Incoherent Integrations',validators=[MinValueValidator(1)], default=30)
                 filter           = models.ForeignKey(JARSfilter, on_delete=models.CASCADE, null=True)
                 spectral_number  = models.PositiveIntegerField(verbose_name='# Spectral Combinations',validators=[MinValueValidator(1)], default=1)
                 spectral         = models.CharField(verbose_name='Combinations', max_length=5000, default = '[0, 0],')
                 create_directory = models.BooleanField(verbose_name='Create Directory Per Day', default=True)
                 include_expname  = models.BooleanField(verbose_name='Experiment Name in Directory', default=True)
                 #acq_link         = models.BooleanField(verbose_name='Acquisition Link', default=True)
                 #view_raw_data    = models.BooleanField(verbose_name='View Raw Data', default=True)
                 save_ch_dc       = models.BooleanField(verbose_name='Save Channels DC', default=True)
                 save_data        = models.BooleanField(verbose_name='Save Data', default=True)
                 filter_parms     = models.CharField(max_length=10000, default='{}')
                 class Meta:
                     db_table = 'jars_configurations'
                 def parms_to_dict(self):
                     parameters = {}
                     parameters['device_id']        = self.device.id
                     parameters['name']             = self.name
                     #parameters['rc']               = self.rc.name
                     parameters['exp_type']         = self.exp_type
                     parameters['exptype']          = EXPERIMENT_TYPE[self.exp_type][1]
                     parameters['cards_number']     = self.cards_number
                     parameters['channels_number']  = self.channels_number
                     parameters['channels']         = self.channels
                     parameters['rd_directory']     = self.rd_directory
                     #parameters['raw_data_blocks']  = self.raw_data_blocks
                     parameters['data_type']        = self.data_type
                     parameters['cohe_integr_str']  = self.cohe_integr_str
                     parameters['acq_profiles']     = self.acq_profiles
                     parameters['profiles_block']   = self.profiles_block
                     parameters['ftp_interval']     = self.ftp_interval
                     parameters['fftpoints']        = self.fftpoints
                     parameters['cohe_integr']      = self.cohe_integr
                     #parameters['incohe_integr']    = self.incohe_integr
                     parameters['filter']           = self.filter.name
                     parameters['filter_parms']     = self.filter_parms
                     #parameters['spectral_number']  = self.spectral_number
                     #parameters['spectral']         = self.spectral
                     parameters['create_directory'] = bool(self.create_directory)
                     parameters['include_expname']  = bool(self.include_expname)
                     #parameters['acq_link']         = bool(self.acq_link)
                     #parameters['view_raw_data']    = bool(self.view_raw_data)
                     parameters['save_ch_dc']       = bool(self.save_ch_dc)
                     parameters['save_data']        = bool(self.save_data)
                     if parameters['exptype'] == 'PDATA':
                         parameters['incohe_integr']    = self.incohe_integr
                         parameters['spectral_number']  = self.spectral_number
                         parameters['spectral']         = self.spectral
                         parameters['pd_directory']     = self.pd_directory
                     return parameters
                 def add_parms_to_filter(self):
                     self.filter_parms = self.filter.parms_to_dict()
                     self.save()
                 def dict_to_parms(self, parameters):
                     self.name           = parameters['name']
                     self.device.id       = int(parameters['device_id'])
                     self.exp_type        = int(parameters['exp_type'])
                     if parameters['exptype'] == 'PDATA':
                         self.incohe_integr   = parameters['incohe_integr']
                         self.spectral_number = parameters['spectral_number']
                         self.spectral        = parameters['spectral']
                         self.pd_directory    = parameters['pd_directory']
                     self.cards_number    = int(parameters['cards_number'])
                     self.channels_number = int(parameters['channels_number'])
                     self.channels        = parameters['channels']
                     self.rd_directory    = parameters['rd_directory']
                     #self.raw_data_blocks = parameters['raw_data_blocks']
                     self.data_type       = parameters['data_type']
                     self.cohe_integr_str = parameters['cohe_integr_str']
                     self.acq_profiles    = parameters['acq_profiles']
                     self.profiles_block  = parameters['profiles_block']
                     self.ftp_interval    = parameters['ftp_interval']
                     self.fftpoints       = parameters['fftpoints']
                     self.cohe_integr     = parameters['cohe_integr']
                     filter_name       = parameters['filter']
                     self.filter    = JARSfilter.objects.get(name=filter_name)
                     self.add_parms_to_filter()
                     self.filter_parms = parameters['filter_parms']
                     self.create_directory = bool(parameters['create_directory'])
                     self.include_expname  = bool(parameters['include_expname'])
                     #self.acq_link         = bool(parameters['acq_link'])
                     #self.view_raw_data    = bool(parameters['view_raw_data'])
                     self.save_ch_dc       = bool(parameters['save_ch_dc'])
                     self.save_data        = bool(parameters['save_data'])
                 def status_device(self):
-                    answer = api.status(self.device.ip_address,self.device.port_address)
+                    try:
-                    self.device.status = int(answer[0])
+                        answer = api.status(self.device.ip_address,self.device.port_address)
-                    self.message = answer[2:]
+                        self.device.status = int(answer[0])
-                    self.device.save()
+                        self.device.save()
+                        self.message = answer[2:]
+                        if self.device.status == 0:
+                            return False
-                    return self.device.status
+                    except Exception as e:
+                        self.device.status = 0
+                        self.message = str(e)
+                        self.device.save()
+                        return False
+                    return True
                 def stop_device(self):
-                    answer = api.stop(self.device.ip_address,self.device.port_address)
+                    try:
-                    self.device.status = int(answer[0])
+                        answer = api.stop(self.device.ip_address,self.device.port_address)
-                    self.message = answer[2:]
+                        self.device.status = int(answer[0])
-                    self.device.save()
+                        self.message = answer[2:]
+                        self.device.save()
+                        if self.device.status == 0 or self.device.status == 1:
+                            return False
-                    return self.device.status
+                    except Exception as e:
+                        self.device.status = 0
+                        self.message = str(e)
+                        self.device.save()
+                        return False
+                    return True
                 def read_device(self):
-                    answer = api.read(self.device.ip_address,self.device.port_address)
-                    self.device.status = int(answer[0])
                     try:
+                        answer = api.read(self.device.ip_address,self.device.port_address)
+                        self.device.status = int(answer[0])
+                        self.device.save()
+                        self.message = answer[2:]
+                        if self.device.status == 1:
+                            return False
                         data = json.loads(answer[2:])
                         parms = data['configurations']['jars']
                     except:
                         self.device.status = 0
                         self.device.save()
                         self.message = 'Could not read JARS configuration.'
-                        return ''
+                        return False
                     #self.dict_to_parms(parms)
                     self.message = 'Current JARS configuration was read successfully.'
                     self.device.save()
                     return parms
                 def write_device(self):
+                    if self.device.status == 3:
+                        self.message = 'Could not configure device. Software Acquisition is running'
+                        return False
                     data = self.experiment.parms_to_dict()
                     data = json.loads(data)
                     data['configurations']['dds']         =''
                     data['configurations']['cgs']         =''
                     data['configurations']['rc']['pulses']=''
                     data['configurations']['rc']['delays']=''
                     json_data = json.dumps(data)
-                    answer = api.configure(self.device.ip_address,self.device.port_address,json_data)
+                    try:
-                    #print answer
+                        answer = api.configure(self.device.ip_address,self.device.port_address,json_data)
-                    self.device.status = int(answer[0])
+                        self.device.status = int(answer[0])
-                    self.message = answer[2:]
+                        self.message = answer[2:]
+                        self.device.save()
+                        if self.device.status == 1:
+                            return False
+                        if self.device.status == 3:
+                            return False
-                    self.device.save()
+                    except Exception as e:
+                        self.device.status = 0
+                        self.message = str(e)
+                        self.device.save()
+                        return False
-                    return self.device.status
+                    return True
                 def start_device(self):
-                    self.write_device()
+                    try:
+                        answer = api.start(self.device.ip_address,self.device.port_address)
+                        self.device.status = int(answer[0])
+                        self.message = answer[2:]
+                        self.device.save()
+                        if self.device.status == 1:
+                            return False
+                    except Exception as e:
+                        self.device.status = 0
+                        self.message = str(e)
+                        self.device.save()
+                        return False
+                    return True
                 def echo(self):
                     answer = api.echo(self.device.ip_address,self.device.port_address,'(=')
                     #print answer
                     self.device.status = int(answer[0])
                     self.message = answer[2:]
                     self.device.save()
                     return #self.device.status
                 def update_from_file(self, parameters):
                     self.dict_to_parms(parameters)
                     self.save()
                 def get_absolute_url_import(self):
                     return reverse('url_import_jars_conf', args=[str(self.id)])
                 def get_absolute_url_read(self):
                     return reverse('url_read_jars_conf', args=[str(self.id)])

apps/jars/views.py +60 -60

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

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