radarsys Commit - r158:03c8e52d0d74 · Jicamarca Repository

updating repository....

Fiorella Quino -

r158:03c8e52d0d74

parent child

Context file:

r158:03c8e52d0d74

Collapse all files

devices/jars/__init__.py created 644 0 0

NO CONTENT: new file 100644

devices/jars/api.py created 644 +113 0

@@ -0,0 +1,113
	1	'''
	2	Created on Nov 25, 2015
	3
	4	@author: Miguel Urco
	5
	6	eth_device decorator is used to implement an api to ethernet devices.
	7	When eth_device decorator is used it adds two parameters to any function (ip and port)
	8
	9	#Definition of a function using eth_device decorator
	10
	11	@eth_device(ID_CLASS)
	12	def enable_acq(message)
	13	cmd = "xxxxx"
	14	payload = message
	15
	16	return cmd, payload
	17
	18	#How to call this function:
	19	answer = enable_acq(ip, port, message)
	20
	21	'''
	22	import sys
	23	import struct
	24	import json
	25
	26	from devices.jro_device import eth_device, IdClass
	27
	28	ID_CLASS = IdClass["jars"]
	29
	30	CMD_RESET = 0X01
	31	CMD_CHANGEIP = 0X03
	32	#Add other commands
	33	CMD_CONFIGURE = 0X10
	34	CMD_STATUS = 0X11
	35	CMD_SET_EXEPATH = 0X12
	36	CMD_ECHO = 0XFE
	37	CMD_READ = 0X08
	38	CMD_STOP = 0X09
	39
	40	@eth_device(ID_CLASS)
	41	def reset():
	42
	43	cmd = CMD_RESET
	44	payload = ''
	45
	46	return cmd, payload
	47
	48	@eth_device(ID_CLASS)
	49	def stop():
	50
	51	cmd = CMD_STOP
	52	payload = ''
	53
	54	return cmd, payload
	55
	56	@eth_device(ID_CLASS)
	57	def echo(message):
	58
	59	cmd = CMD_ECHO
	60	payload = message
	61
	62	return cmd, payload
	63
	64	@eth_device(ID_CLASS)
	65	def configure(conf):
	66
	67	cmd = CMD_CONFIGURE
	68	payload = conf
	69
	70	return cmd, payload
	71
	72	@eth_device(ID_CLASS)
	73	def status():
	74
	75	cmd = CMD_STATUS
	76	payload = ''
	77
	78	return cmd, payload
	79
	80	@eth_device(ID_CLASS)
	81	def read():
	82
	83	cmd = CMD_READ
	84	payload = ''
	85
	86	return cmd, payload
	87
	88	@eth_device(ID_CLASS)
	89	def set_exepath(path):
	90
	91	cmd = CMD_SET_EXEPATH
	92	payload = path
	93
	94	return cmd, payload
	95
	96	#--To take .json file from computer:
	97	#with open('/home/fquino/Downloads/Experiment.json') as data_file:
	98	# data = json.load(data_file)
	99
	100	# data['configurations']['dds']=''
	101	# data['configurations']['rc']['pulses']=''
	102	# data['configurations']['rc']['delays']=''
	103
	104	#data = json.dumps(data)
	105	#-----------------------------------
	106
	107	#print reset('10.10.10.100', 10000)
	108	#print echo('10.10.10.95', 10000, 'Hola JARS :)')
	109
	110	#json_data = json.dumps({'name':'archivo1','variable':9})
	111	#print configure('10.10.10.95', 10000, data)
	112	#print configure('10.10.10.100', 10000, '')
	113	#print status('10.10.10.100', 10000)

apache/apache_radarsys.conf +1 -1

             ## DJANGO
             WSGIScriptAlias / /usr/local/radarsys/radarsys/wsgi.py
             WSGIPythonPath /usr/local/radarsys/:/usr/local/virtuals/radarsys/lib/python2.7/site-packages
             Alias /static/ /var/www/html/static/
             <Directory /usr/local/radarsys/>
               <Files wsgi.py>
                 #Order deny,allow
                 Require all granted
                 #Allow from all
               </Files>
-            </Directory>
  No newline at end of file
+            </Directory>

apps/abs/urls.py +1 -5

             from django.conf.urls import url
             urlpatterns = (
                 url(r'^(?P<id_conf>-?\d+)/$', 'apps.main.views.dev_conf', name='url_abs_conf'),
                 url(r'^(?P<id_conf>-?\d+)/edit/$', 'apps.main.views.dev_conf_edit', name='url_edit_abs_conf'),
-                url(r'^(?P<id_conf>-?\d+)/write/$', 'apps.main.views.dev_conf_write', name='url_write_abs_conf'),
-                url(r'^(?P<id_conf>-?\d+)/read/$', 'apps.main.views.dev_conf_read', name='url_read_abs_conf'),
-                url(r'^(?P<id_conf>-?\d+)/import/$', 'apps.main.views.dev_conf_import', name='url_import_abs_conf'),
-                url(r'^(?P<id_conf>-?\d+)/export/$', 'apps.main.views.dev_conf_export', name='url_export_abs_conf'),
-            )
  No newline at end of file

apps/cgs/forms.py +9 -9

             from django import forms
             from apps.main.models import Device
             from .models import CGSConfiguration
             class CGSConfigurationForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     #request = kwargs.pop('request')
                     super(CGSConfigurationForm, self).__init__(*args, **kwargs)
                     instance = getattr(self, 'instance', None)
                     if instance and instance.pk:
                         devices = Device.objects.filter(device_type__name='cgs')
                         if instance.experiment:
                             self.fields['experiment'].widget.attrs['disabled'] = 'disabled'
                         self.fields['device'].widget.choices = [(device.id, device) for device in devices]
                 def clean(self):
                     return
+            #
                 class Meta:
                     model = CGSConfiguration
                     exclude = ('type', 'parameters', 'status')
                     #fields = ('experiment', 'device', 'freq0', 'freq1', 'freq2', 'freq3')
             class UploadFileForm(forms.Form):
                 title = forms.CharField(label='Extension Type', widget=forms.TextInput(attrs={'readonly':'readonly'}))
-                file = forms.FileField()
  No newline at end of file
+                file = forms.FileField()

apps/jars/models.py +5 0

             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)
                     self.device.status = int(answer[0])
                     self.message = answer[2:]
                     self.device.save()
                     return self.device.status
                 def stop_device(self):
                     answer = api.stop(self.device.ip_address,self.device.port_address)
                     self.device.status = int(answer[0])
                     self.message = answer[2:]
                     self.device.save()
                     return self.device.status
                 def read_device(self):
                     answer = api.read(self.device.ip_address,self.device.port_address)
                     self.device.status = int(answer[0])
                     try:
                         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 ''
                     #self.dict_to_parms(parms)
                     self.message = 'Current JARS configuration was read successfully.'
                     self.device.save()
                     return parms
                 def write_device(self):
                     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)
                     #print answer
                     self.device.status = int(answer[0])
                     self.message = answer[2:]
                     self.device.save()
                     return self.device.status
+                def start_device(self):
+                    self.write_device()
                 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/rc/forms.py +4 -6

             import os
-            import ast
             import json
             from django import forms
             from django.utils.safestring import mark_safe
             from apps.main.models import Device
             from apps.main.forms import add_empty_choice
             from .models import RCConfiguration, RCLine, RCLineType, RCLineCode
             from .widgets import KmUnitWidget, KmUnitHzWidget, KmUnitDcWidget, UnitKmWidget, DefaultWidget, CodesWidget, HiddenWidget, HCheckboxSelectMultiple
             def create_choices_from_model(model, conf_id, all_choice=False):
                 if model=='RCLine':
                     instance = RCConfiguration.objects.get(pk=conf_id)
                     choices =  [(line.pk, line.get_name()) for line in instance.get_lines(line_type__name='tx')]
                     if all_choice:
                         choices = add_empty_choice(choices, label='All')
                 else:
                     instance = globals()[model]
                     choices = instance.objects.all().values_list('pk', 'name')
                 return choices
             class ExtFileField(forms.FileField):
                 """
                 Same as forms.FileField, but you can specify a file extension whitelist.
                 >>> from django.core.files.uploadedfile import SimpleUploadedFile
                 >>>
                 >>> t = ExtFileField(ext_whitelist=(".pdf", ".txt"))
                 >>>
                 >>> t.clean(SimpleUploadedFile('filename.pdf', 'Some File Content'))
                 >>> t.clean(SimpleUploadedFile('filename.txt', 'Some File Content'))
                 >>>
                 >>> t.clean(SimpleUploadedFile('filename.exe', 'Some File Content'))
                 Traceback (most recent call last):
                 ...
                 ValidationError: [u'Not allowed filetype!']
                 """
                 def __init__(self, *args, **kwargs):
                     extensions = kwargs.pop("extensions")
                     self.extensions = [i.lower() for i in extensions]
                     super(ExtFileField, self).__init__(*args, **kwargs)
                 def clean(self, *args, **kwargs):
                     data = super(ExtFileField, self).clean(*args, **kwargs)
                     filename = data.name
                     ext = os.path.splitext(filename)[1]
                     ext = ext.lower()
                     if ext not in self.extensions:
                         raise forms.ValidationError('Not allowed file type: %s' % ext)
             class RCConfigurationForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(RCConfigurationForm, self).__init__(*args, **kwargs)
                     instance = getattr(self, 'instance', None)
                     if instance and instance.pk:
                         devices = Device.objects.filter(device_type__name='rc')
                         if instance.experiment:
                             self.fields['experiment'].widget.attrs['read_only'] = True
                             #self.fields['experiment'].widget.choices = [(instance.experiment.id, instance.experiment)]
                         self.fields['device'].widget.choices = [(device.id, device) for device in devices]
                         self.fields['ipp'].widget = KmUnitHzWidget(attrs={'km2unit':instance.km2unit})
                         self.fields['clock'].widget.attrs['readonly'] = True
                     self.fields['time_before'].label = mark_safe(self.fields['time_before'].label)
                     self.fields['time_after'].label = mark_safe(self.fields['time_after'].label)
                     if 'initial' in kwargs and 'experiment' in kwargs['initial'] and kwargs['initial']['experiment'] not in (0, '0'):
                         self.fields['experiment'].widget.attrs['readonly'] = True
                 class Meta:
                     model = RCConfiguration
                     exclude = ('type', 'parameters', 'status', 'total_units', 'mix')
                 def clean(self):
                     form_data = super(RCConfigurationForm, self).clean()
                     if 'clock_divider' in form_data:
                         if form_data['clock_divider']<1:
                             self.add_error('clock_divider', 'Invalid Value')
                         else:
                             if form_data['ipp']*(20./3*(form_data['clock_in']/form_data['clock_divider']))%10<>0:
                                 self.add_error('ipp', 'Invalid IPP units={}'.format(form_data['ipp']*(20./3*(form_data['clock_in']/form_data['clock_divider']))))
                     return form_data
                 def save(self):
                     conf = super(RCConfigurationForm, self).save()
                     conf.total_units = conf.ipp*conf.ntx*conf.km2unit
                     conf.save()
                     return conf
             class RCMixConfigurationForm(forms.Form):
                 clock_in = forms.CharField(widget=forms.HiddenInput())
                 clock_divider = forms.CharField(widget=forms.HiddenInput())
                 name = forms.CharField()
                 experiment = forms.ChoiceField()
                 mode = forms.ChoiceField(widget=forms.RadioSelect(),
                                          choices=[(0, 'Parallel'), (1, 'Sequence')],
                                          initial=0)
                 operation = forms.ChoiceField(widget=forms.RadioSelect(),
                                               choices=[(0, 'OR'), (1, 'XOR'), (2, 'AND'), (3, 'NAND')],
                                               initial=1)
                 delay = forms.CharField()
                 mask = forms.MultipleChoiceField(choices=[(0, 'L1'),(1, 'L2'),(2, 'L3'),(3, 'L4'),(4, 'L5'),(5, 'L6'),(6, 'L7'),(7, 'L8')],
                                                  widget=HCheckboxSelectMultiple())
                 result = forms.CharField(required=False,
                                          widget=forms.Textarea(attrs={'readonly':True, 'rows':5, 'class':'tabuled'}))
                 def __init__(self, *args, **kwargs):
                     confs = kwargs.pop('confs', [])
                     if confs:
                         km2unit = confs[0].km2unit
                         clock_in = confs[0].clock_in
                         clock_divider = confs[0].clock_divider
                     else:
                         km2unit = clock_in = clock_divider = 0
                     super(RCMixConfigurationForm, self).__init__(*args, **kwargs)
                     self.fields['experiment'].choices = [(conf.pk, '{} | {}'.format(conf.pk, conf.name)) for conf in confs]
                     self.fields['delay'].widget = KmUnitWidget(attrs = {'km2unit':km2unit})
                     self.fields['clock_in'].initial = clock_in
                     self.fields['clock_divider'].initial = clock_divider
             class RCLineForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     self.extra_fields = kwargs.pop('extra_fields', [])
                     super(RCLineForm, self).__init__(*args, **kwargs)
                     if 'initial' in kwargs and 'line_type' in kwargs['initial']:
                         line_type = RCLineType.objects.get(pk=kwargs['initial']['line_type'])
                         if 'code_id' in kwargs['initial']:
                             model_initial = kwargs['initial']['code_id']
                         else:
                             model_initial = 0
                         params = json.loads(line_type.params)
                         for label, value in self.extra_fields.items():
                             if label=='params':
                                 continue
                             if 'model' in params[label]:
                                 self.fields[label] = forms.ChoiceField(choices=create_choices_from_model(params[label]['model'],
                                                                                                          kwargs['initial']['rc_configuration']),
                                                                        initial=model_initial)
                             else:
                                 if label=='codes' and 'code_id' in kwargs['initial']:
                                     self.fields[label] = forms.CharField(initial=RCLineCode.objects.get(pk=kwargs['initial']['code_id']).codes)
                                 else:
                                     self.fields[label] = forms.CharField(initial=value['value'])
                                 if label=='codes':
                                     self.fields[label].widget = CodesWidget()
                     if self.data:
                         line_type = RCLineType.objects.get(pk=self.data['line_type'])
                         if 'code_id' in self.data:
                             model_initial = self.data['code_id']
                         else:
                             model_initial = 0
                         params = json.loads(line_type.params)
                         for label, value in self.extra_fields.items():
                             if label=='params':
                                 continue
                             if 'model' in params[label]:
                                 self.fields[label] = forms.ChoiceField(choices=create_choices_from_model(params[label]['model'],
                                                                                                          self.data['rc_configuration']),
                                                                        initial=model_initial)
                             else:
                                 if label=='codes' and 'code' in self.data:
                                     self.fields[label] = forms.CharField(initial=self.data['codes'])
                                 else:
                                     self.fields[label] = forms.CharField(initial=self.data[label])
                                 if label=='codes':
                                     self.fields[label].widget = CodesWidget()
                 class Meta:
                     model = RCLine
                     fields = ('rc_configuration', 'line_type', 'channel')
                     widgets = {
                         'channel': forms.HiddenInput(),
                     }
                 def clean(self):
                     form_data = self.cleaned_data
                     if 'code' in self.data and self.data['TX_ref']=="0":
                         self.add_error('TX_ref', 'Choose a valid TX reference')
                     if RCLineType.objects.get(pk=self.data['line_type']).name=='mix':
                         self.add_error('line_type', 'Invalid Line type')
                     return form_data
                 def save(self):
                     line = super(RCLineForm, self).save()
                     #auto add channel
                     line.channel = RCLine.objects.filter(rc_configuration=line.rc_configuration).count()-1
                     #auto add position for TX, TR & CODE
                     if line.line_type.name in ('tx', ):
                         line.position = RCLine.objects.filter(rc_configuration=line.rc_configuration, line_type=line.line_type).count()-1
                     #save extra fields in params
                     params = {}
                     for label, value in self.extra_fields.items():
                         if label=='params':
                             params['params'] = []
                         elif label=='codes':
                             params[label] = [s for s in self.data[label].split('\r\n') if s]
                         else:
                             params[label] = self.data[label]
                     line.params = json.dumps(params)
                     line.save()
                     return
             class RCLineViewForm(forms.Form):
                 def __init__(self, *args, **kwargs):
                     extra_fields = kwargs.pop('extra_fields')
                     line = kwargs.pop('line')
                     subform = kwargs.pop('subform', False)
                     super(RCLineViewForm, self).__init__(*args, **kwargs)
                     if subform:
                         params = json.loads(line.line_type.params)['params']
                     else:
                         params = json.loads(line.line_type.params)
                     for label, value in extra_fields.items():
                         if label=='params':
                             continue
                         if 'ref' in label:
                             if value in (0, '0'):
                                 value = 'All'
                             else:
                                 value = RCLine.objects.get(pk=value).get_name()
                         elif label=='code':
                             value = RCLineCode.objects.get(pk=value).name
                         self.fields[label] = forms.CharField(initial=value)
                         if 'widget' in params[label]:
                             km2unit = line.rc_configuration.km2unit
                             if params[label]['widget']=='km':
                                 self.fields[label].widget = KmUnitWidget(attrs={'line':line, 'km2unit':km2unit, 'disabled':True})
                             elif params[label]['widget']=='unit':
                                 self.fields[label].widget = UnitKmWidget(attrs={'line':line, 'km2unit':km2unit, 'disabled':True})
                             elif params[label]['widget']=='dc':
                                 self.fields[label].widget = KmUnitDcWidget(attrs={'line':line, 'km2unit':km2unit, 'disabled':True})
                             elif params[label]['widget']=='codes':
                                 self.fields[label].widget = CodesWidget(attrs={'line':line, 'km2unit':km2unit, 'disabled':True})
                         else:
                             self.fields[label].widget = DefaultWidget(attrs={'disabled':True})
             class RCLineEditForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     extra_fields = kwargs.pop('extra_fields', [])
                     conf = kwargs.pop('conf', False)
                     line = kwargs.pop('line')
                     subform = kwargs.pop('subform', False)
                     super(RCLineEditForm, self).__init__(*args, **kwargs)
                     if subform is not False:
                         params = json.loads(line.line_type.params)['params']
                         count = subform
                     else:
                         params = json.loads(line.line_type.params)
                         count = -1
                     for label, value in extra_fields.items():
                         if label in ('params',):
                             continue
                         if 'help' in params[label]:
                             help_text = params[label]['help']
                         else:
                             help_text = ''
                         if 'model' in params[label]:
                             if line.line_type.name=='tr':
                                 all_choice = True
                             else:
                                 all_choice = False
                             self.fields[label] = forms.ChoiceField(choices=create_choices_from_model(params[label]['model'], conf.id, all_choice=all_choice),
                                                         initial=value,
                                                         widget=forms.Select(attrs={'name':'%s|%s|%s' % (count, line.id, label)}),
                                                         help_text=help_text)
                         else:
                             self.fields[label] = forms.CharField(initial=value, help_text=help_text)
                             if label in ('code', ):
                                 self.fields[label].widget = HiddenWidget(attrs={'name':'%s|%s|%s' % (count, line.id, label)})
                             elif 'widget' in params[label]:
                                 km2unit = line.rc_configuration.km2unit
                                 if params[label]['widget']=='km':
                                     self.fields[label].widget = KmUnitWidget(attrs={'line':line, 'km2unit':km2unit, 'name':'%s|%s|%s' % (count, line.id, label)})
                                 elif params[label]['widget']=='unit':
                                     self.fields[label].widget = UnitKmWidget(attrs={'line':line, 'km2unit':km2unit, 'name':'%s|%s|%s' % (count, line.id, label)})
                                 elif params[label]['widget']=='dc':
                                     self.fields[label].widget = KmUnitDcWidget(attrs={'line':line, 'km2unit':km2unit, 'name':'%s|%s|%s' % (count, line.id, label)})
                                 elif params[label]['widget']=='codes':
                                     self.fields[label].widget = CodesWidget(attrs={'line':line, 'km2unit':km2unit, 'name':'%s|%s|%s' % (count, line.id, label)})
                             else:
-                                self.fields[label].widget = DefaultWidget(attrs={'name':'%s|%s|%s' % (count, line.id, label)})
+                                self.fields[label].widget = DefaultWidget(attrs={'line':line, 'name':'%s|%s|%s' % (count, line.id, label)})
                 class Meta:
                     model = RCLine
                     exclude = ('rc_configuration', 'line_type', 'channel', 'position', 'params', 'pulses')
             class RCSubLineEditForm(forms.Form):
                 def __init__(self, *args, **kwargs):
                     extra_fields = kwargs.pop('extra_fields')
                     count = kwargs.pop('count')
                     line = kwargs.pop('line')
                     super(RCSubLineEditForm, self).__init__(*args, **kwargs)
                     for label, value in extra_fields.items():
                         self.fields[label] = forms.CharField(initial=value,
                                                              widget=forms.TextInput(attrs={'name':'%s|%s|%s' % (count, line, label)}))
             class RCImportForm(forms.Form):
                 file_name = ExtFileField(extensions=['.racp', '.json', '.dat'])
             class RCLineCodesForm(forms.ModelForm):
                 def __init__(self, *args, **kwargs):
                     super(RCLineCodesForm, self).__init__(*args, **kwargs)
                     if 'initial' in kwargs:
                         self.fields['code'] = forms.ChoiceField(choices=RCLineCode.objects.all().values_list('pk', 'name'),
                                                                 initial=kwargs['initial']['code'])
                     if 'instance' in kwargs:
                         self.fields['code'] = forms.ChoiceField(choices=RCLineCode.objects.all().values_list('pk', 'name'),
                                                                 initial=kwargs['instance'].pk)
                     self.fields['codes'].widget = CodesWidget()
                 class Meta:
                     model = RCLineCode
                     exclude = ('name',)
   No newline at end of file

devices/jro_device.py +5 -2

             '''
             Created on Dec 2, 2014
             @author: Miguel Urco
             '''
             import time
             import struct
             import socket
             DEBUG = False
             CMD_RESET           =0X01
             CMD_ENABLE          =0X02
             CMD_CHANGEIP        =0X03
             IdClass={
                 "rc"        : 0x01,
                 "dds"       : 0x02,
                 "jars"      : 0x03,
                 "usrp"      : 0x04,
                 "echotek"   : 0x05,
                 "abs"       : 0x06,
                 "clk_gen"   : 0x07
                 }
             def ascii2hex(cadena):
                 hex_cad = ''
                 for c in cadena:
                     hex_cad += hex(ord(c))[2:].rjust(2,'0') + ' '
                 return hex_cad
             def ping(host):
                 """
                 Returns True if host responds to a ping request
                 """
                 import os, platform
                 # Ping parameters as function of OS
                 ping_str = "-n 1" if  platform.system().lower()=="windows" else "-c 1"
                 # Ping
                 return os.system("ping " + ping_str + " " + host) == 0
             class IPData(object):
                 '''
                 Clase para manejar la trama de datos provenientes del/hacia un dispositivo Ethernet.
                 La trama de datos es la siguiente:
                 **********************************
                 ** FORMATO GENERAL DE UNA TRAMA **
                 **********************************
 . Cabecera (5 bytes):    Secuencia Fija que deber ser "$JRO$"
 . Longitud (3 bytes):    Cantidad de bytes de la Data, contados desde IdClass hasta el Xor
 . Id class (1 byte) :    Clase de dispositivo a configurar. Por defecto 0
 . Id device (1 byte):    Identificar del dispositivo a configurar. Por defecto 0
 . Cmd (2 bytes):         Identificador del comando a ejecutarse.
 . Payload (n bytes):     Carga Util conteniendo secuencia,comandos y parametros
 . Xor (1 byte):          Byte de revision de consistencia de la data al aplicar Xor a todos los bytes,
                                           desde la longitud hasta el payload.
                 '''
                 __HEADER = "$JRO$"
                 def __init__(self, ip, port, id_class=0, id_dev=0):
                     '''
                     '''
                     self.id_class = id_class
                     self.id_dev = id_dev
                     self.address = (str(ip), int(port))
                     self.__iniVariables()
                 def __iniVariables(self):
                     self.tx_buffer = None
                     self.rx_buffer = None
                     #self.header = None
                     self.len = None
                     self.cmd = None
                     self.payload = None
                     self.invalid = True
                     self.errormsg = ''
                     self.hasPayload = False
                 def __getXor(self, cadena):
                     '''
                     '''
                     #trama = '%03d' %lenght + ipPayload
                     xor = 0
                     for character in cadena:
                         xor = xor ^ ord(character)
             #         xor_hex = hex(xor)
             #         xor_hex = xor_hex[2:]
             #         xor_hex = xor_hex.rjust(2,'0')
                     return xor
                 def __verifyXor(self, cadena):
                     xor = self.__getXor(cadena)
                     if xor != 0:
                         return 0
                     return 1
                 def __encoder(self, cmd, payload):
                     '''
                     Inputs:
                         cmd            :    Entero que indica el tipo de comando
                         payload        :    Cadena de caracteres con informacion, depende del comando
                     '''
                     #seq = '%04d' %(sequence)
                     #conf = '%04d' %(confcode)
                     #Number to Cad: 2 Bytes <> H, 4 Bytes <> I
                     cmd_cad = struct.pack(">H", cmd)
                     data = chr(self.id_class) + chr(self.id_dev) + cmd_cad + payload
                     len_data = len(data) + 1 # + xor
                     len_cad = struct.pack('>I', len_data)
                     lenAndData = len_cad + chr(self.id_class) + chr(self.id_dev) + cmd_cad + payload
                     xor = self.__getXor(lenAndData)
                     trama = self.__HEADER + lenAndData + chr(xor)
                     self.tx_buffer = trama
                     return trama
                 def __decoder(self, rx_buffer):
                     '''
                     Evalua la trama y la separa en los campos correspondientes
 Bytes    |    4Bytes    | 1Byte    | 1 Byte |  2 Bytes |    n Bytes          |    1 Byte
                     Header    |    Len       | Id class | Id dev |   Cmd    |   Payload           |    Xor
                     '''
                     self.invalid = True
                     self.hasPayload = False
                     self.rx_buffer = rx_buffer
                     try:
                         index = rx_buffer.find(self.__HEADER)
                     except:
                         self.errormsg = "rx_buffer is not a string"
                         return 0
                     if index == -1:
                         self.errormsg = "No header found: %s" %ascii2hex(rx_buffer)
                         return 0
                     rx_buffer = rx_buffer[index + len(self.__HEADER):]
                     len_cad = rx_buffer[0:4]
                     len_data = struct.unpack('>I',len_cad)[0]
                     lenAndDataAndXor = rx_buffer[0:len_data + 4]    #Incluye los 4 bytes de la longitud
                     dataAndXor = lenAndDataAndXor[4:]
                     if len(dataAndXor) < len_data:
                         self.errormsg = "Data length is lower than %s" %(len_data)
                         return 0
             #         print self.header, ", ", ascii2hex(lenCad), ", ", ascii2hex(ipDataAndXor), ", ", hex(self.xor)
                     if not self.__verifyXor(lenAndDataAndXor):
                         self.errormsg = "Invalid xor: %s" %lenAndDataAndXor[-1]
                         return 0
                     self.invalid = False
                     len_payload = len_data - 5  #Decrementar 1B (id_class), 1B (id_dev), 2B (cmd) y 1B (xor)
                     id_class = ord(dataAndXor[0])
                     id_dev = ord(dataAndXor[1])
                     cmd_cad = dataAndXor[2:4]
                     payload = dataAndXor[4:4+len_payload]
                     cmd = struct.unpack('>H',cmd_cad)[0]
                     self.id_class = id_class
                     self.id_dev = id_dev
                     self.cmd = cmd
                     if len(payload) < 1:
                         self.errormsg = "IP data is valid but it hasn't payload"
                         return 1
                     self.hasPayload = True
                     self.payload = payload
                     self.errormsg = "Successful"
                     return 1
                 def __decoder_api(self, rx_buffer, debug = DEBUG):
                     """
                     Input:
                         rx_buffer    :    Trama recibida como respuesta a un comando enviada a un dispositivo.
                     Return:
 :    Trama recibida incorrecta. La cadena "rx_buffer" no ha sido decodificada correctamente.
                         -1    :    Dispositivo no inicializado. El dispositivo, dds o rc, no ha sido inicializado
                                     correctamente.
                         -2    :    Trama enviada no reconocida. La cadena recibida es correcta y el dispositivo ha sido
                                     inicializaado correctamente pero la trama enviada no ha sido reconocida por el
                                     dispositivo o el comando enviado no ha sido implementado.
                         >0    :    Trama enviada y recibida correctamente
                     """
                     if not self.__decoder(rx_buffer):
                         return "0:Error decoding eth data: " + ascii2hex(self.rx_buffer)
             #         if self.getPayload() == "OK":
             #             return 1
             #
             #         if self.getPayload() == "NI":
             #             return -1
             #
             #         if self.getPayload() == "KO":
             #             return -2
                     if debug:
                         print ascii2hex(self.rx_buffer)
                     return self.payload
                 def getRxBufferHex(self):
                     if self.rx_buffer == None:
                         return ''
                     cad = ascii2hex(self.rx_buffer)
                     return cad
                 def getTxBufferHex(self):
                     if self.tx_buffer == None:
                         return ''
                     cad = ascii2hex(self.tx_buffer)
                     return cad
                 def isInvalid(self):
                     return self.invalid
                 def getCmd(self):
                     return self.cmd
                 def getPayload(self):
                     return self.payload
                 def getErrorMessage(self):
                     return self.errormsg
                 def getTxBuffer(self):
                     return self.tx_buffer
                 def getRxBuffer(self):
                     return self.rx_buffer
                 def __encodeIpCmd(self, ip, mask, gateway):
                     payload = ip + '/' + mask + '/' + gateway
                     return self.__encoder(CMD_CHANGEIP, payload)
                 def __encodeResetCmd(self):
                     payload = ""
                     return self.__encoder(CMD_RESET, payload)
                 def __sendTCPData(self, cadena):
                     sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                    sck.settimeout(2)
+                    sck.settimeout(3)
                     try:
                         sck.connect(self.address)
                     except:
                         return None
             #         print "TX: ", ascii2hex(cadena)
                     sck.send(cadena)
                     rx_buffer = ""
                     ini = time.time()
                     try:
                         while True:
                             if time.time() - ini > 0.5:
                                 break
-                            tmp = sck.recv(255)
+                            try:
+                                tmp = sck.recv(4096)
+                            except:
+                                break
                             if len(tmp) < 1:
                                 continue
                             ini = time.time()
                             rx_buffer += tmp
                     finally:
                         sck.close()
             #         print "RX: ", ascii2hex(rx_buffer)
                     return rx_buffer
                 def changeIP(self, ip, mask, gateway):
                     tx_buffer = self.__encodeIpCmd(ip, mask, gateway)
                     rx_buffer = self.__sendTCPData(tx_buffer)
                     sts = self.__decoder_api(rx_buffer)
                     if sts > 0:
                         self.address = (ip, self.address[1])
                     return sts
                 def reset(self):
                     tx_buffer = self.__encodeResetCmd()
                     rx_buffer = self.__sendTCPData(tx_buffer)
                     return self.__decoder_api(rx_buffer)
                 def sendData(self, cmd, payload, server=False):
                     if server:
                         tx_buffer = self.__encoder(cmd, payload)
                         print "TX: ", ascii2hex(tx_buffer)
                         self.client_connection.sendall(tx_buffer)
                     else:
                         tx_buffer = self.__encoder(cmd, payload)
                         print "TX: ", ascii2hex(tx_buffer)
                         rx_buffer = self.__sendTCPData(tx_buffer)
                         if not rx_buffer:
                             msg =  "0:Could not connect to Device %s" %str(self.address)
                             return msg
                         print "RX: ", ascii2hex(rx_buffer)
                         return self.__decoder_api(rx_buffer)
                 def receiveData(self, rx_buffer):
                     print "RX: ", ascii2hex(rx_buffer)
                     return self.__decoder(rx_buffer)
             def eth_device(id_class):
                 def inner_func(func):
                     def func_wrapper(ip, port, *args):
                         cmd, payload = func(*args)
                         ipObj = IPData(ip, port, id_class=id_class)
                         rx = ipObj.sendData(cmd, payload)
                         return rx
                     return func_wrapper
                 return inner_func

devices/rc/api.py +8 -26

             '''
             Created on Dec 2, 2014
             @author: Miguel Urco
             eth_device decorator is used to implement an api to ethernet devices.
             When eth_device decorator is used it adds two parameters to any function (ip and port)
             #Definition
             @eth_device
             def enable_rf()
                 cmd = "xxxxx"
                 payload = "xxxxxx"
                 return cmd, payload
             #How to call this function:
             answer = enable_rf(ip, port)
             '''
             import data
             from devices.jro_device import eth_device, IdClass
             ID_CLASS = IdClass["rc"]
             CMD_RESET           =0X01
             CMD_ENABLE          =0X02
             CMD_CHANGEIP        =0X03
             CMD_STATUS          =0X04
             CMD_DISABLE         =0X02
             CMD_ECHO            =0XFE
             RC_CMD_RESET        =0X10
             RC_CMD_WRITE        =0x50
             RC_CMD_READ         =0x8000
-            RC_CMD_ENABLE       =0X24
-            RC_CMD_DISABLE      =0X00
             @eth_device(ID_CLASS)
             def reset():
                 cmd = CMD_RESET
                 payload = ""
                 return cmd, payload
             @eth_device(ID_CLASS)
             def change_ip(ip, mask="255.255.255.0", gateway="0.0.0.0"):
                 cmd = CMD_CHANGEIP
                 payload = ip + '/' + mask + '/' + gateway
                 return cmd, payload
             @eth_device(ID_CLASS)
             def status():
                 cmd = CMD_STATUS
                 payload = ""
                 return cmd, payload
             @eth_device(ID_CLASS)
             def echo():
                 cmd = CMD_ECHO
                 payload = ""
                 return cmd, payload
             @eth_device(ID_CLASS)
-            def enable():
-                cmd = RC_CMD_ENABLE
-                payload = chr(0x01)
-                return cmd, payload
-            @eth_device(ID_CLASS)
-            def disable():
-                cmd = RC_CMD_DISABLE
-                payload = chr(0x00)
-                return cmd, payload
-            @eth_device(ID_CLASS)
             def read_all_device():
                 payload = ""
-                return RC_CMD_READ, payload
+                return CR_CMD_READ, payload
             @eth_device(ID_CLASS)
             def write_all_device(payload):
-                return RC_CMD_WRITE, payload
+                return CR_CMD_WRITE, payload
             def read_config(ip, port):
                 """
                 Output:
                     parms   : Dictionary with keys
                 """
                 payload = read_all_device(ip, port)
                 return data.rc_str_to_dict(payload)
             def write_config(ip, port, parms):
                 """
                 Input:
                     ip      :
                     port    :
                     parms   : Dictionary with keys
                 """
-                payload = write_ram_memory(parms['pulses'], parms['delays'])
+                payload = data.dict_to_rc_str(parms)
                 answer = write_all_device(ip, port, payload)
                 return answer
             def __get_low_byte(valor):
-                return ord(valor & 0x00FF)
+               return ord(valor & 0x00FF)
             def __get_high_byte(valor):
-                return ord((valor & 0xFF00) >> 8)
+               return ord((valor & 0xFF00) >> 8)
+            @eth_device(ID_CLASS)
             def write_ram_memory(vector_valores, vector_tiempos):
                 l1 = len(vector_valores)
                 l2 = len(vector_tiempos)
                 cad = ""
                 for i in range(l1):
-                    cad += ord(84) + __get_low_byte(vector_valores[i]) + ord(85) + __get_high_byte(vector_valores[i]) + \
+                  cad += ord(84) + __get_low_byte(vector_valores[i]) + ord(85) + __get_high_byte(vector_valores[i]) + \
                          ord(84) + __get_low_byte(vector_tiempos[i]) + ord(85) + __get_high_byte(vector_tiempos[i])
-                return cad
+                return RC_CMD_WRITE, cad
             if __name__ == '__main__':
                 ip = "10.10.20.150"
                 port = 2000
                 print status(ip, port)
                 print read_config(ip, port)

radarsys/urls.py +1 -1

             """radarsys URL Configuration
             The `urlpatterns` list routes URLs to views. For more information please see:
                 https://docs.djangoproject.com/en/1.8/topics/http/urls/
             Examples:
             Function views
 . Add an import:  from my_app import views
 . Add a URL to urlpatterns:  url(r'^$', views.home, name='home')
             Class-based views
 . Add an import:  from other_app.views import Home
 . Add a URL to urlpatterns:  url(r'^$', Home.as_view(), name='home')
             Including another URLconf
 . Add an import:  from blog import urls as blog_urls
 . Add a URL to urlpatterns:  url(r'^blog/', include(blog_urls))
             """
             from django.conf.urls import include, url
             from django.contrib import admin
             urlpatterns = [
                 url(r'^$', 'apps.main.views.index', name='index'),
                 url(r'^admin/', include(admin.site.urls)),
                 url(r'^accounts/', include('apps.accounts.urls')),
                 url(r'^', include('apps.main.urls')),
                 url(r'^rc/', include('apps.rc.urls')),
                 url(r'^dds/', include('apps.dds.urls')),
                 url(r'^cgs/', include('apps.cgs.urls')),
                 url(r'^jars/', include('apps.jars.urls')),
                 url(r'^usrp/', include('apps.usrp.urls')),
                 url(r'^abs/', include('apps.abs.urls')),
                 url(r'^misc/', include('apps.misc.urls')),
             ]

requirements.txt 0 -1

             Django==1.8.6
             django-bootstrap3==6.2.2
             MySQL-python==1.2.5
             django-polymorphic==0.7.2
             requests==2.9.1
             bokeh==0.11.0
             numpy==1.10.4
             matplotlib==1.5.1

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