radarsys Commit - r414:08d5cd67904a · Jicamarca Repository

Added monitor channel to the RC configuration.

krodriguez -

r414:08d5cd67904a

parent child

Context file:

r414:08d5cd67904a

apps/rc/models.py +16 0

             import ast
             import json
             import requests
             import numpy as np
             from base64 import b64encode
             from struct import pack
             from django.db import models
             from django.urls import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from apps.main.models import Configuration
             from apps.main.utils import Params
             from devices.rc import api
             from apps.rc.utils import RCFile
             LINE_TYPES = (
                 ('none', 'Not used'),
                 ('tr', 'Transmission/reception selector signal'),
                 ('tx', 'A modulating signal (Transmission pulse)'),
                 ('codes', 'BPSK modulating signal'),
                 ('windows', 'Sample window signal'),
                 ('sync', 'Synchronizing signal'),
                 ('flip', 'IPP related periodic signal'),
                 ('prog_pulses', 'Programmable pulse'),
                 ('mix', 'Mixed line'),
                 )
             SAMPLING_REFS = (
                 ('none', 'No Reference'),
                 ('begin_baud', 'Begin of the first baud'),
                 ('first_baud', 'Middle of the first baud'),
                 ('sub_baud', 'Middle of the sub-baud')
                              )
             DAT_CMDS = {
                     # Pulse Design commands
                     'DISABLE' : 0, # Disables pulse generation
                     'ENABLE' : 24, # Enables pulse generation
                     'DELAY_START' : 40, # Write delay status to memory
                     'FLIP_START' : 48, # Write flip status to memory
                     'SAMPLING_PERIOD' : 64, # Establish Sampling Period
                     'TX_ONE' : 72, # Output '0' in line TX
                     'TX_ZERO' : 88, # Output '0' in line TX
                     'SW_ONE' : 104, # Output '0' in line SW
                     'SW_ZERO' : 112, # Output '1' in line SW
                     'RESTART': 120, # Restarts CR8 Firmware
                     'CONTINUE' : 253, # Function Unknown
                     # Commands available to new controllers
                     # In Pulse Design Executable, the clock divisor code is written as 12 at the start, but it should be written as code 22(below) just before the final enable.
                     'CLOCK_DIVISOR_INIT' : 12, # Specifies Clock Divisor. Legacy command, ignored in the actual .dat conversion
                     'CLOCK_DIVISOR_LAST' : 22, # Specifies Clock Divisor (default 60 if not included) syntax: 255,22 254,N-1.
                     'CLOCK_DIVIDER' : 8,
                         }
             MAX_BITS = 8
             # Rotate left: 0b1001 --> 0b0011
             rol = lambda val, r_bits: \
                 (val << r_bits%MAX_BITS) & (2**MAX_BITS-1) | \
                 ((val & (2**MAX_BITS-1)) >> (MAX_BITS-(r_bits%MAX_BITS)))
             # Rotate right: 0b1001 --> 0b1100
             ror = lambda val, r_bits: \
                 ((val & (2**MAX_BITS-1)) >> r_bits%MAX_BITS) | \
                 (val << (MAX_BITS-(r_bits%MAX_BITS)) & (2**MAX_BITS-1))
             class RCConfiguration(Configuration):
                 ipp = models.FloatField(verbose_name='IPP [Km]', validators=[MinValueValidator(1)], default=300)
                 ntx = models.PositiveIntegerField(verbose_name='Number of TX', validators=[MinValueValidator(1)], default=1)
                 clock_in = models.FloatField(verbose_name='Clock in [MHz]', validators=[MinValueValidator(1), MaxValueValidator(80)], default=1)
                 clock_divider = models.PositiveIntegerField(verbose_name='Clock divider', validators=[MinValueValidator(1), MaxValueValidator(256)], default=1)
                 clock = models.FloatField(verbose_name='Clock Master [MHz]', blank=True, default=1)
                 time_before = models.PositiveIntegerField(verbose_name='Time before [&mu;S]', default=12)
                 time_after = models.PositiveIntegerField(verbose_name='Time after [&mu;S]', default=1)
                 sync = models.PositiveIntegerField(verbose_name='Synchro delay', default=0)
+                ch_monitor = models.PositiveIntegerField(verbose_name='Channel Monitor', validators=[MinValueValidator(0), MaxValueValidator(15)], default=6)
                 sampling_reference = models.CharField(verbose_name='Sampling Reference', choices=SAMPLING_REFS, default='none', max_length=40)
                 control_tx = models.BooleanField(verbose_name='Control Switch TX', default=False)
                 control_sw = models.BooleanField(verbose_name='Control Switch SW', default=False)
                 total_units = models.PositiveIntegerField(default=0)
                 mix = models.BooleanField(default=False)
                 class Meta:
                     db_table = 'rc_configurations'
                 def get_absolute_url_plot(self):
                     return reverse('url_plot_rc_pulses', args=[str(self.id)])
                 @property
                 def ipp_unit(self):
                     return '{} ({})'.format(self.ipp, int(self.ipp*self.km2unit))
                 @property
                 def us2unit(self):
                     return self.clock_in/self.clock_divider
                 @property
                 def km2unit(self):
                     return 20./3*(self.clock_in/self.clock_divider)
                 def clone(self, **kwargs):
                     lines = self.get_lines()
                     self.pk = None
                     self.id = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     for line in lines:
                         line.clone(rc_configuration=self)
                     new_lines = self.get_lines()
                     for line in new_lines:
                         line_params = json.loads(line.params)
                         if 'TX_ref' in line_params and (line_params['TX_ref'] != '0'):
                             ref_line = RCLine.objects.get(pk=line_params['TX_ref'])
                             line_params['TX_ref'] = ['{}'.format(l.pk) for l in new_lines if l.get_name()==ref_line.get_name()][0]
                             line.params = json.dumps(line_params)
                             line.save()
                     return self
                 def get_lines(self, **kwargs):
                     '''
                     Retrieve configuration lines
                     '''
                     return RCLine.objects.filter(rc_configuration=self.pk, **kwargs)
                 def clean_lines(self):
                     '''
                     '''
                     empty_line = RCLineType.objects.get(name='none')
                     for line in self.get_lines():
                         line.line_type = empty_line
                         line.params = '{}'
                         line.save()
                 def dict_to_parms(self, params, id=None):
                     '''
                     '''
                     if id:
                         data = Params(params).get_conf(id_conf=id)
                     else:
                         data = Params(params).get_conf(dtype='rc')
                     #print(data)
                     # self.name = data['name']
                     self.ipp = data['ipp']
                     self.ntx = data['ntx']
                     self.clock_in = data['clock_in']
                     self.clock_divider = data['clock_divider']
                     self.clock = data['clock']
                     self.time_before = data['time_before']
                     self.time_after = data['time_after']
                     self.sync = data['sync']
                     self.sampling_reference = data['sampling_reference']
                     self.total_units = self.ipp*self.ntx*self.km2unit
                     self.save()
                     self.clean_lines()
                     #print(params)
                     positions = {'tx':0, 'tr':0}
                     for i, id in enumerate(data['lines']):
                         line_data = params['lines']['byId'][id]
                         line_type = RCLineType.objects.get(name=line_data['line_type'])
                         if line_type.name == 'codes':
                             code = RCLineCode.objects.get(name=line_data['params']['code'])
                             line_data['params']['code'] = code.pk
                         if line_type.name == 'tx':
                             position = positions['tx']
                             positions['tx'] += 1
                         elif line_type.name == 'tr':
                             position = positions['tr']
                             positions['tr'] += 1
                         else:
                             position = 0
                         line, dum = RCLine.objects.update_or_create(
                             rc_configuration=self,
                             channel=i,
                             position=position,
                             defaults={
                                 'line_type': line_type,
                                 'params': json.dumps(line_data['params'])
                                 }
                             )
                     for i, line in enumerate(self.get_lines()):
                         line_params = json.loads(line.params)
                         if 'TX_ref' in line_params:
                             if line_params['TX_ref'] in (0, '0'):
                                 line_params['TX_ref'] = '0'
                             else:
                                 ref_id = '{}'.format(line_params['TX_ref'])
                                 ref_line = params['lines']['byId'][ref_id]
                                 line_params['TX_ref'] = RCLine.objects.get(
                                     rc_configuration=self,
                                     params=json.dumps(ref_line['params'])
                                     ).pk
                             line.params = json.dumps(line_params)
                             print(line.params)
                             line.save()
                     print("Fin de dict to param")
                 def get_delays(self):
                     pulses = [line.pulses_as_points() for line in self.get_lines()]
                     points = [tup for tups in pulses for tup in tups]
                     points = set([x for tup in points for x in tup])
                     points = list(points)
                     points.sort()
                     if points[0]!=0:
                         points.insert(0, 0)
                     return [points[i+1]-points[i] for i in range(len(points)-1)]
                 def get_pulses(self, binary=True):
                     pulses = [line.pulses_as_points() for line in self.get_lines()]
                     tuples = [tup for tups in pulses for tup in tups]
                     points = set([x for tup in tuples for x in tup])
                     points = list(points)
                     points.sort()
                     states = []
                     last = [0 for x in pulses]
                     n_pulses = len(pulses)
                     print('len_pulses', n_pulses)
                     print('len_points', len(points))
                     ups_arr = [[] for _ in range(n_pulses)]
                     dws_arr = [[] for _ in range(n_pulses)]
                     for i, tups in enumerate(pulses):
                         ups_arr[i] = [tup[0] for tup in tups if tup!=(0,0)]
                         dws_arr[i] = [tup[1] for tup in tups if tup!=(0,0)]
                     print('len_points*n_pulses',len(points)*n_pulses)
                     #print('ups_arr', ups_arr)
                     #print('dws_arr', dws_arr)
                     for x in points:
                         dum = []
                         print('loading', x*100/max(points))
                         for i in range(n_pulses):
                             if x in ups_arr[i]:
                                 dum.append(1)
                             elif x in dws_arr[i]:
                                 dum.append(0)
                             else:
                                 dum.append(last[i])
                         #print(dum)
                         states.append(dum)
                         last = dum
                     if binary:
                         ret = []
                         for flips in states:
                             flips.reverse()
                             ret.append(int(''.join([str(x) for x in flips]), 2))
                         states = ret
                     #print(states[:-1])
                     #print('len_states',len(states[:-1]))
                     return states[:-1]
                 def add_cmd(self, cmd):
                     if cmd in DAT_CMDS:
                         return (255, DAT_CMDS[cmd])
                 def add_data(self, value):
                     return (254, value-1)
                 def parms_to_binary(self, dat=True):
                     '''
                     Create "dat" stream to be send to CR
                     '''
                     data = bytearray()
                     # create header
                     data.extend(self.add_cmd('DISABLE'))
                     data.extend(self.add_cmd('CONTINUE'))
                     data.extend(self.add_cmd('RESTART'))
                     if self.control_sw:
                         data.extend(self.add_cmd('SW_ONE'))
                     else:
                         data.extend(self.add_cmd('SW_ZERO'))
                     if self.control_tx:
                         data.extend(self.add_cmd('TX_ONE'))
                     else:
                         data.extend(self.add_cmd('TX_ZERO'))
                     # write divider
                     data.extend(self.add_cmd('CLOCK_DIVIDER'))
                     data.extend(self.add_data(self.clock_divider))
                     # write delays
                     data.extend(self.add_cmd('DELAY_START'))
                     # first delay is always zero
                     data.extend(self.add_data(1))
                     delays = self.get_delays()
                     for delay in delays:
                         while delay>252:
                             data.extend(self.add_data(253))
                             delay -= 253
                         data.extend(self.add_data(int(delay)))
                     # write flips
                     data.extend(self.add_cmd('FLIP_START'))
                     states = self.get_pulses(binary=True)
                     last = 0
                     for flip, delay in zip(states, delays):
                         data.extend(self.add_data((flip^last)+1))
                         last = flip
                         while delay>252:
                             data.extend(self.add_data(1))
                             delay -= 253
                     # write sampling period
                     data.extend(self.add_cmd('SAMPLING_PERIOD'))
                     wins = self.get_lines(line_type__name='windows')
                     if wins:
                         win_params = json.loads(wins[0].params)['params']
                         if win_params:
                             dh = int(win_params[0]['resolution']*self.km2unit)
                         else:
                             dh = 1
                     else:
                         dh = 1
                     data.extend(self.add_data(dh))
                     # write enable
                     data.extend(self.add_cmd('ENABLE'))
                     if not dat:
                         return data
                     return '\n'.join(['{}'.format(x) for x in data])
                 def update_pulses(self):
                     contador = 0
                     for line in self.get_lines():
                         contador=contador+1
                         print(contador)
                         line.update_pulses()
                 def plot_pulses2(self, km=False):
                     import matplotlib
                     matplotlib.use('Agg')
                     import matplotlib.pyplot as plt
                     from bokeh.resources import CDN
                     from bokeh.embed import components
                     from bokeh.mpl import to_bokeh
                     from bokeh.models.tools import WheelZoomTool, ResetTool, PanTool, HoverTool, SaveTool
                     lines = self.get_lines()
                     N = len(lines)
                     npoints = self.total_units/self.km2unit if km else self.total_units
                     fig = plt.figure(figsize=(12, 2+N*0.5))
                     ax = fig.add_subplot(111)
                     labels = ['IPP']
                     for i, line in enumerate(lines):
                         labels.append(line.get_name(channel=True))
                         l = ax.plot((0, npoints),(N-i-1, N-i-1))
                         points = [(tup[0], tup[1]-tup[0]) for tup in line.pulses_as_points(km=km) if tup!=(0,0)]
                         ax.broken_barh(points, (N-i-1, 0.5),
                                        edgecolor=l[0].get_color(), facecolor='none')
                     n = 0
                     f = ((self.ntx+50)/100)*5 if ((self.ntx+50)/100)*10>0 else 2
                     for x in np.arange(0, npoints, self.ipp if km else self.ipp*self.km2unit):
                         if n%f==0:
                             ax.text(x, N, '%s' % n, size=10)
                         n += 1
                     labels.reverse()
                     ax.set_yticks(range(len(labels)))
                     ax.set_yticklabels(labels)
                     ax.set_xlabel = 'Units'
                     plot = to_bokeh(fig, use_pandas=False)
                     plot.tools = [PanTool(dimensions="width"), WheelZoomTool(dimensions="width"), ResetTool(), SaveTool()]
                     plot.toolbar_location="above"
                     return components(plot, CDN)
                 def plot_pulses(self, km=False):
                     from bokeh.plotting import figure
                     from bokeh.resources import CDN
                     from bokeh.embed import components
                     from bokeh.models import FixedTicker, PrintfTickFormatter, Label
                     from bokeh.models.tools import WheelZoomTool, ResetTool, PanTool, HoverTool, SaveTool
                     from bokeh.models.sources import ColumnDataSource
                     lines = self.get_lines().reverse()
                     N = len(lines)
                     npoints = self.total_units/self.km2unit if km else self.total_units
                     ipp = self.ipp if km else self.ipp*self.km2unit
                     hover = HoverTool(tooltips=[("Line", "@name"),
                                                 ("IPP", "@ipp"),
                                                 ("X", "@left")])
                     tools = [PanTool(dimensions="width"),
                              WheelZoomTool(dimensions="width"),
                              hover, SaveTool()]
                     plot = figure(width=1000,
                                   height=40+N*50,
                                   y_range = (0, N),
                                   tools=tools,
                                   toolbar_location='above',
                                   toolbar_sticky=False,)
                     pulses = [line.pulses_as_points() for line in self.get_lines()]
                     tuples = [tup for tups in pulses for tup in tups]
                     points = set([x for tup in tuples for x in tup])
                     capacity_bytes = round((8*(len(points)-1)+12)/2) # se divide entre 2 porque la mitad era solo para direcciones
                     capacity_percent = (capacity_bytes/2097152)*100
                     # Add the used memory message
                     x_label_memory = Label(x=900, y=-1.5, text='Used memory of '+str(capacity_bytes)+'/2097152 bytes ('+'%.3f'%capacity_percent+'%)', text_align="right", x_units='screen', text_font_size='14pt')
                     plot.add_layout(x_label_memory, 'below')
                     plot.xaxis.axis_label = 'Km' if km else 'Units'
                     plot.xaxis[0].formatter = PrintfTickFormatter(format='%d')
                     plot.yaxis.axis_label = 'Pulses'
                     plot.yaxis[0].ticker=FixedTicker(ticks=list(range(N)))
                     plot.yaxis[0].formatter = PrintfTickFormatter(format='Line %d')
                     for i, line in enumerate(lines):
                         points = [tup for tup in line.pulses_as_points(km=km) if tup!=(0,0)]
                         source = ColumnDataSource(data = dict(
                                                               bottom = [i for tup in points],
                                                               top = [i+0.5 for tup in points],
                                                               left = [tup[0] for tup in points],
                                                               right = [tup[1] for tup in points],
                                                               ipp = [int(tup[0]/ipp) for tup in points],
                                                               name = [line.get_name() for tup in points]
                                                               ))
                         plot.quad(
                                  bottom = 'bottom',
                                  top = 'top',
                                  left = 'left',
                                  right = 'right',
                                  source = source,
                                  fill_alpha = 0,
                                  #line_color = 'blue',
                                  )
                         plot.line([0, npoints], [i, i])#, color='blue')
                     return components(plot, CDN)
                 def request(self, cmd, method='get', **kwargs):
                     req = getattr(requests, method)(self.device.url(cmd), **kwargs)
                     payload = req.json()
                     return payload
                 def status_device(self):
                     try:
                         self.device.status = 0
                         payload = self.request('status')
                         if payload['status']=='enable':
                             self.device.status = 3
                         elif payload['status']=='disable':
                             self.device.status = 2
                         else:
                             self.device.status = 1
                             self.device.save()
                             self.message = 'RC status: {}'.format(payload['status'])
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         self.device.save()
                         self.message = 'RC status: {}'.format(str(e))
                         return False
                     self.device.save()
                     return True
                 def reset_device(self):
                     try:
                         payload = self.request('reset', 'post')
                         if payload['reset']=='ok':
                             self.message = 'RC restarted OK'
                             self.device.status = 2
                             self.device.save()
                         else:
                             self.message = 'RC restart fail'
                             self.device.status = 4
                             self.device.save()
                     except Exception as e:
                         self.message = 'RC reset: {}'.format(str(e))
                         return False
                     return True
                 def stop_device(self):
                     try:
                         payload = self.request('stop', 'post')
                         self.message = 'RC stop: {}'.format(payload['stop'])
                         if payload['stop']=='ok':
                             self.device.status = 2
                             self.device.save()
                         else:
                             self.device.status = 4
                             self.device.save()
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         self.message = 'RC stop: {}'.format(str(e))
                         self.device.save()
                         return False
                     return True
                 def start_device(self):
                     try:
                         payload = self.request('start', 'post')
                         self.message = 'RC start: {}'.format(payload['start'])
                         if payload['start']=='ok':
                             self.device.status = 3
                             self.device.save()
                         else:
                             return False
                     except Exception as e:
                         if 'No route to host' not in str(e):
                             self.device.status = 4
                         else:
                             self.device.status = 0
                         self.message = 'RC start: {}'.format(str(e))
                         self.device.save()
                         return False
                     return True
                 def write_device(self, raw=False):
                     print("write device")
                     if not raw:
                         clock = RCClock.objects.get(rc_configuration=self)
                         if clock.mode:
                             data = {'default': clock.frequency}
                         else:
                             data = {'manual': [clock.multiplier, clock.divisor, clock.reference]}
                         payload = self.request('setfreq', 'post', data=json.dumps(data))
                         #if payload['setfreq'] != 'ok':
                         if payload['command'] != 'ok':
                             #self.message = 'RC write: {}'.format(payload['setfreq'])
                             self.message = 'RC write: {}'.format(payload['command'])
                         else:
                             #self.message = payload['setfreq']
                             self.message = payload['programming']
                             #if payload['setfreq'] == 'fail':
                             if payload['programming'] == 'fail':
                                 self.message = 'RC write: error programming CGS chip'
+                        ##############################################################
+                        data = {'setwindow': self.ch_monitor}
+                        print(data)
+                        payload = self.request('setwin', 'post', data=json.dumps(data))
+                        if payload['setwindow'] == 'ok':
+                            self.message = 'RC write: {}'.format(payload['setwindow'])
+                        else:
+                            if payload['command'] != 'wrong format or key':
+                                self.message = 'Error RC monitor channel: {}'.format(payload['command'])
+                        ##############################################################
                     values = []
                     print('wait delay values...')
                     for pulse, delay in zip(self.get_pulses(), self.get_delays()):
                         #print('wait zip...')
                         while delay > 65536:
                             values.append((pulse, 65535))
                             delay -= 65536
                         values.append((pulse, delay-1))
                     data = bytearray()
                     #reset
                     data.extend((128, 0))
                     #disable
                     data.extend((129, 0))
                     #SW switch
                     if self.control_sw:
                         data.extend((130, 2))
                     else:
                         data.extend((130, 0))
                     #divider
                     data.extend((131, self.clock_divider-1))
                     #enable writing
                     data.extend((139, 62))
                     last = 0
                     print('wait data...')
                     for tup in values:
                         vals = pack('<HH', last^tup[0], tup[1])
                         last = tup[0]
                         data.extend((133, vals[1], 132, vals[0], 133, vals[3], 132, vals[2]))
                     #enable
                     data.extend((129, 1))
                     print('len',len(data))
                     if raw:
                         return b64encode(data)
                     #try:
                     print('requests')
                     payload = self.request('stop', 'post')
                     payload = self.request('reset', 'post')
                     #payload = self.request('divider', 'post', data={'divider': self.clock_divider-1})
                     #payload = self.request('write', 'post', data=b64encode(bytearray((139, 62))), timeout=20)
                     n = len(data)
                     print('len: ',n)
                     x = 0
                     cnt = 0
                     while x < n:
                         print('writing...', cnt)
                         payload = self.request('write', 'post', data=b64encode(data[x:x+3072]))#(data))#
                         x += 3072
                         cnt += 1#time.sleep(1)
                         print('writing...', x*100/n)
                     if payload['write']=='ok':
                         self.device.status = 3
                         self.device.save()
                         self.message = 'RC configured and started'
                     else:
                         self.device.status = 1
                         self.device.save()
                         self.message = 'RC write: {}'.format(payload['write'])
                         return False
                         #payload = self.request('start', 'post')
                     #except Exception as e:
                     #    if 'No route to host' not in str(e):
                     #        self.device.status = 4
                     #    else:
                     #        self.device.status = 0
                     #    self.message = 'RC write: {}'.format(str(e))
                     #    self.device.save()
                     #    return False
                     return True
                 def get_absolute_url_import(self):
                     return reverse('url_import_rc_conf', args=[str(self.id)])
             class RCLineCode(models.Model):
                 name = models.CharField(max_length=40)
                 bits_per_code = models.PositiveIntegerField(default=0)
                 number_of_codes = models.PositiveIntegerField(default=0)
                 codes = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'rc_line_codes'
                     ordering = ('name',)
                 def __str__(self):
                     return u'%s' % self.name
             class RCLineType(models.Model):
                 name = models.CharField(choices=LINE_TYPES, max_length=40)
                 description = models.TextField(blank=True, null=True)
                 params = models.TextField(default='[]')
                 class Meta:
                     db_table = 'rc_line_types'
                 def __str__(self):
                     return u'%s - %s' % (self.name.upper(), self.get_name_display())
             class RCLine(models.Model):
                 rc_configuration = models.ForeignKey('RCConfiguration', on_delete=models.CASCADE)
                 line_type = models.ForeignKey('RCLineType',on_delete=models.CASCADE)
                 channel = models.PositiveIntegerField(default=0)
                 position = models.PositiveIntegerField(default=0)
                 params = models.TextField(default='{}')
                 pulses = models.TextField(default='')
                 class Meta:
                     db_table = 'rc_lines'
                     ordering = ['channel']
                 def __str__(self):
                     if self.rc_configuration:
                         return u'{}|{} - {}'.format(self.pk, self.get_name(), self.rc_configuration.name)
                 def jsonify(self):
                     data = {}
                     data['params'] = json.loads(self.params)
                     data['id'] = '{}'.format(self.pk)
                     data['line_type'] = self.line_type.name
                     data['name'] = self.get_name()
                     if data['line_type']=='codes':
                         data['params']['code'] = RCLineCode.objects.get(pk=data['params']['code']).name
                     return data
                 def clone(self, **kwargs):
                     self.pk = None
                     self.id = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     return self
                 def get_name(self, channel=False):
                     chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
                     s = ''
                     if self.line_type.name in ('tx',):
                         s = chars[self.position]
                     elif self.line_type.name in ('codes', 'windows', 'tr'):
                         if 'TX_ref' in json.loads(self.params):
                             pk = json.loads(self.params)['TX_ref']
                             if pk in (0, '0'):
                                 s = ','.join(chars[l.position] for l in self.rc_configuration.get_lines(line_type__name='tx'))
                             else:
                                 ref = RCLine.objects.get(pk=pk)
                                 s = chars[ref.position]
                             s = '({})'.format(s)
                     s = '{}{}'.format(self.line_type.name.upper(), s)
                     if channel:
                         return '{} {}'.format(s, self.channel)
                     else:
                         return s
                 def get_lines(self, **kwargs):
                     return RCLine.objects.filter(rc_configuration=self.rc_configuration, **kwargs)
                 def pulses_as_array(self):
                     y = np.zeros(self.rc_configuration.total_units)
                     for tup in ast.literal_eval(self.pulses):
                         y[tup[0]:tup[1]] = 1
                     return y.astype(np.int8)
                 def pulses_as_points(self, km=False):
                     if km:
                         unit2km = 1/self.rc_configuration.km2unit
                         return [(tup[0]*unit2km, tup[1]*unit2km) for tup in ast.literal_eval(self.pulses)]
                     else:
                         return ast.literal_eval(self.pulses)
                 def get_win_ref(self, params, tx_id, km2unit):
                     ref = self.rc_configuration.sampling_reference
                     codes = [line for line in self.get_lines(line_type__name='codes') if int(json.loads(line.params)['TX_ref'])==int(tx_id)]
                     if codes:
                         tx_width = float(json.loads(RCLine.objects.get(pk=tx_id).params)['pulse_width'])*km2unit/len(json.loads(codes[0].params)['codes'][0])
                     else:
                         tx_width = float(json.loads(RCLine.objects.get(pk=tx_id).params)['pulse_width'])*km2unit
                     if ref=='first_baud':
                         return int(1 + round((tx_width + 1)/2 + params['first_height']*km2unit - params['resolution']*km2unit))
                     elif ref=='sub_baud':
                         return np.ceil(1 + params['first_height']*km2unit - params['resolution']*km2unit/2)
                     else:
                         return 0
                 def update_pulses(self):
                     '''
                     Update pulses field
                     '''
                     km2unit = self.rc_configuration.km2unit
                     us2unit = self.rc_configuration.us2unit
                     ipp = self.rc_configuration.ipp
                     ntx = int(self.rc_configuration.ntx)
                     ipp_u = int(ipp*km2unit)
                     total = ipp_u*ntx if self.rc_configuration.total_units==0 else self.rc_configuration.total_units
                     y = []
                     if self.line_type.name=='tr':
                         tr_params = json.loads(self.params)
                         #print(tr_params)
                         #print(tr_params['TX_ref'])
                         if tr_params['TX_ref'] in ('0', 0):
                             txs = self.get_lines(line_type__name='tx')
                         else:
                             txs = RCLine.objects.filter(pk=tr_params['TX_ref'])
                         for tx in txs:
                             params = json.loads(tx.params)
                             if float(params['pulse_width'])==0:
                                 continue
                             delays = [float(d)*km2unit for d in params['delays'].split(',') if d]
                             width = float(params['pulse_width'])*km2unit+int(self.rc_configuration.time_before*us2unit)
                             before = 0
                             after = int(self.rc_configuration.time_after*us2unit)
                             y_tx = self.points(ntx, ipp_u, width,
                                                delay=delays,
                                                before=before,
                                                after=after,
                                                sync=self.rc_configuration.sync)
                             ranges = params['range'].split(',')
                             if len(ranges)>0 and ranges[0]!='0':
                                 y_tx = self.mask_ranges(y_tx, ranges)
                             tr_ranges = tr_params['range'].split(',')
                             if len(tr_ranges)>0 and tr_ranges[0]!='0':
                                 y_tx = self.mask_ranges(y_tx, tr_ranges)
                             y.extend(y_tx)
                         self.pulses = str(y)
                         y = self.array_to_points(self.pulses_as_array())
                     elif self.line_type.name=='tx':
                         params = json.loads(self.params)
                         delays = [float(d)*km2unit for d in params['delays'].split(',') if d]
                         width = float(params['pulse_width'])*km2unit
                         if width>0:
                             before = int(self.rc_configuration.time_before*us2unit)
                             after = 0
                             y = self.points(ntx, ipp_u, width,
                                             delay=delays,
                                             before=before,
                                             after=after,
                                             sync=self.rc_configuration.sync)
                             ranges = params['range'].split(',')
                             if len(ranges)>0 and ranges[0]!='0':
                                 y = self.mask_ranges(y, ranges)
                     elif self.line_type.name=='flip':
                         n = float(json.loads(self.params)['number_of_flips'])
                         width = n*ipp*km2unit
                         y = self.points(int((ntx+1)/(2*n)), ipp_u*n*2, width)
                     elif self.line_type.name=='codes':
                         params = json.loads(self.params)
                         tx = RCLine.objects.get(pk=params['TX_ref'])
                         tx_params = json.loads(tx.params)
                         delays = [float(d)*km2unit for d in tx_params['delays'].split(',') if d]
                         f = int(float(tx_params['pulse_width'])*km2unit/len(params['codes'][0]))
                         codes = [(np.fromstring(''.join([s*f for s in code]), dtype=np.uint8)-48).astype(np.int8) for code in params['codes']]
                         codes = [self.array_to_points(code) for code in codes]
                         n = len(codes)
                         ranges = tx_params['range'].split(',')
                         if len(ranges)>0 and ranges[0]!='0':
                             dum = self.mask_ranges(tx.pulses_as_points(), ranges)
                         else:
                             dum = tx.pulses_as_points()
                         for i, tup in enumerate(dum):
                             if tup==(0,0): continue
                             code = codes[i%n]
                             y.extend([(c[0]+tup[0], c[1]+tup[0]) for c in code])
                     elif self.line_type.name=='sync':
                         params = json.loads(self.params)
                         n = ipp_u*ntx
                         if params['invert'] in ('1', 1):
                             y = [(n-1, n)]
                         else:
                             y = [(0, 1)]
                     elif self.line_type.name=='prog_pulses':
                         params = json.loads(self.params)
                         if int(params['periodic'])==0:
                             nntx = 1
                             nipp = ipp_u*ntx
                         else:
                             nntx = ntx
                             nipp = ipp_u
                         if 'params' in params and len(params['params'])>0:
                             for p in params['params']:
                                 y_pp = self.points(nntx, nipp,
                                                    p['end']-p['begin'],
                                                    before=p['begin'])
                                 y.extend(y_pp)
                     elif self.line_type.name=='windows':
                         params = json.loads(self.params)
                         if 'params' in params and len(params['params'])>0:
                             tx = RCLine.objects.get(pk=params['TX_ref'])
                             tx_params = json.loads(tx.params)
                             ranges = tx_params['range'].split(',')
                             for p in params['params']:
                                 y_win = self.points(ntx, ipp_u,
                                                     p['resolution']*p['number_of_samples']*km2unit,
                                                     before=int(self.rc_configuration.time_before*us2unit)+p['first_height']*km2unit,
                                                     sync=self.rc_configuration.sync+self.get_win_ref(p, params['TX_ref'], km2unit))
                                 if len(ranges)>0 and ranges[0]!='0':
                                     y_win = self.mask_ranges(y_win, ranges)
                                 y.extend(y_win)
                     elif self.line_type.name=='mix':
                         values = self.rc_configuration.parameters.split('-')
                         confs = [RCConfiguration.objects.get(pk=value.split('|')[0]) for value in values]
                         modes = [value.split('|')[1] for value in values]
                         ops = [value.split('|')[2] for value in values]
                         delays = [value.split('|')[3] for value in values]
                         masks = [value.split('|')[4] for value in values]
                         print("masks")
                         print(masks)
                         print('{:8b}'.format(int(masks[0])))
                         mask = list('{:8b}'.format(int(masks[0])))
                         print("mask")
                         print(mask)
                         mask.reverse()
                         print("mask reverse")
                         print(mask)
                         if mask[self.channel] in ('0', '', ' '):
                             y = np.zeros(confs[0].total_units, dtype=np.int8)
                         else:
                             y = confs[0].get_lines(channel=self.channel)[0].pulses_as_array()
                         for i in range(1, len(values)):
                             mask = list('{:8b}'.format(int(masks[i])))
                             mask.reverse()
                             if mask[self.channel] in ('0', '', ' '):
                                 continue
                             Y = confs[i].get_lines(channel=self.channel)[0].pulses_as_array()
                             delay = float(delays[i])*km2unit
                             if modes[i]=='P':
                                 if delay>0:
                                     if delay<self.rc_configuration.ipp*km2unit and len(Y)==len(y):
                                         y_temp = np.empty_like(Y)
                                         y_temp[:delay] = 0
                                         y_temp[delay:] = Y[:-delay]
                                     elif delay+len(Y)>len(y):
                                         y_new = np.zeros(delay+len(Y), dtype=np.int8)
                                         y_new[:len(y)] = y
                                         y = y_new
                                         y_temp = np.zeros(delay+len(Y), dtype=np.int8)
                                         y_temp[-len(Y):] = Y
                                     elif delay+len(Y)==len(y):
                                         y_temp = np.zeros(delay+len(Y))
                                         y_temp[-len(Y):] = Y
                                     elif delay+len(Y)<len(y):
                                         y_temp = np.zeros(len(y), dtype=np.int8)
                                         y_temp[delay:delay+len(Y)] = Y
                                 else:
                                     y_temp = Y.copy()
                                 if ops[i]=='OR':
                                     y = y | y_temp
                                 elif ops[i]=='XOR':
                                     y = y ^ y_temp
                                 elif ops[i]=='AND':
                                     y = y & y_temp
                                 elif ops[i]=='NAND':
                                     y = y & ~y_temp
                             else:
                                 y = np.concatenate([y, Y])
                         total = len(y)
                         y = self.array_to_points(y)
                     else:
                         y = []
                     if self.rc_configuration.total_units != total:
                         self.rc_configuration.total_units = total
                         self.rc_configuration.save()
                     self.pulses = str(y)
                     self.save()
                 @staticmethod
                 def array_to_points(X):
                     if X.size==0:
                         return []
                     d = X[1:]-X[:-1]
                     up = np.where(d==1)[0]
                     if X[0]==1:
                         up = np.concatenate((np.array([-1]), up))
                     up += 1
                     dw = np.where(d==-1)[0]
                     if X[-1]==1:
                         dw = np.concatenate((dw, np.array([len(X)-1])))
                     dw += 1
                     return [(tup[0], tup[1]) for tup in zip(up, dw)]
                 @staticmethod
                 def mask_ranges(Y, ranges):
                     y = [(0, 0) for __ in Y]
                     for index in ranges:
                         if '-' in index:
                             args = [int(a) for a in index.split('-')]
                             y[args[0]-1:args[1]] = Y[args[0]-1:args[1]]
                         else:
                             y[int(index)-1] = Y[int(index)-1]
                     return y
                 @staticmethod
                 def points(ntx, ipp, width, delay=[0], before=0, after=0, sync=0):
                     delays = len(delay)
                     Y = [(int(ipp*x+before+delay[x%delays]+sync), int(ipp*x+width+before+delay[x%delays]+after+sync)) for x in range(ntx)]
                     return Y
             class RCClock(models.Model):
                 rc_configuration = models.ForeignKey('RCConfiguration', on_delete=models.CASCADE)
                 mode = models.BooleanField(default=True, choices=((True, 'Auto'), (False, 'Manual')))
                 multiplier = models.PositiveIntegerField(default=60)
                 divisor = models.PositiveIntegerField(default=10)
                 reference = models.PositiveSmallIntegerField(default=1, choices=((0, 'Internal (25MHz)'), (1, 'External (10MHz)')))
                 frequency = models.FloatField(default=60.0)

apps/rc/views.py +1 -1

             import json
             from django.contrib import messages
             from django.utils.safestring import mark_safe
             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from django.contrib.auth.decorators import login_required
             from apps.main.models import Experiment, Device
             from apps.main.views import sidebar
             from .models import RCConfiguration, RCLine, RCLineType, RCLineCode, RCClock
             from .forms import RCConfigurationForm, RCLineForm, RCLineViewForm, RCLineEditForm, RCImportForm, RCLineCodesForm, RCClockForm
             def conf(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 lines = RCLine.objects.filter(rc_configuration=conf).order_by('channel')
                 clk = RCClock.objects.filter(rc_configuration=conf).first()
                 if clk is None:
                     clk = RCClock(rc_configuration=conf)
                     clk.save()
                 for line in lines:
                     params = json.loads(line.params)
                     line.form = RCLineViewForm(extra_fields=params, line=line)
                     if 'params' in params:
                         line.subforms = [RCLineViewForm(extra_fields=fields, line=line, subform=True) for fields in params['params']]
                 kwargs = {}
                 kwargs['clock'] = clk
                 kwargs['dev_conf'] = conf
                 kwargs['rc_lines'] = lines
                 kwargs['dev_conf_keys'] = ['ipp_unit', 'ntx', 'clock_divider', 'clock',
-                                           'time_before', 'time_after', 'sync', 'sampling_reference',
+                                           'time_before', 'time_after', 'sync', 'ch_monitor', 'sampling_reference',
                                            'control_tx', 'control_sw']
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'Detail'
                 kwargs['button'] = 'Edit Configuration'
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'rc_conf.html', kwargs)
             @login_required
             def conf_edit(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 clock = RCClock.objects.get(rc_configuration=conf)
                 lines = RCLine.objects.filter(rc_configuration=conf).order_by('channel')
                 for line in lines:
                     params = json.loads(line.params)
                     #print(params)
                     line.form = RCLineEditForm(conf=conf, line=line, extra_fields=params)
                     line.subform = False
                     if 'params' in params:
                         line.subforms = [RCLineEditForm(extra_fields=fields, line=line, subform=i) for i, fields in enumerate(params['params'])]
                         line.subform = True
                     print(params)
                     print("fin de sub carga de params")
                 #print("fin de carga de params")
                 if request.method=='GET':
                     print("GET case")
                     form = RCConfigurationForm(instance=conf)
                     form_clock = RCClockForm(instance=clock)
                 elif request.method=='POST':
                     #print("ingreso a post conf edit")
                     line_data = {}
                     conf_data = {}
                     clock_data = {}
                     extras = []
                     print("Inicio impresion POST#####")
                     print(request.POST.items)
                     print("Fin impresion de POST items#####")
                     #classified post fields
                     for label,value in request.POST.items():
                         if label=='csrfmiddlewaretoken':
                             continue
                         if label.count('|')==0:
                             if label in ('mode', 'multiplier', 'divisor', 'reference', 'frequency'):
                                 clock_data[label] = value
                             else:
                                 conf_data[label] = value
                             continue
                         elif label.split('|')[0]!='-1':
                             extras.append(label)
                             continue
                         #print(label)
                         x, pk, name = label.split('|')
                         if name=='codes':
                             value = [s for s in value.split('\r\n') if s]
                         if pk in line_data:
                             line_data[pk][name] = value
                         else:
                             line_data[pk] = {name:value}
                         #print(line_data[pk])
                     #update conf
                     form_clock = RCClockForm(clock_data, instance=clock)
                     form = RCConfigurationForm(conf_data, instance=conf)
                     #print(request.POST.items())
                     if form_clock.is_valid() and form.is_valid():
                         form_clock.save()
                         form.save()
                         #update lines fields
                         extras.sort(key=lambda x: int(x.split('|')[0]))
                         #print("Inicio extras")
                         #print(extras)
                         #print("Fin extras")
                         for label in extras:
                             x, pk, name = label.split('|')
                             if pk not in line_data:
                                 line_data[pk] = {}
                             if 'params' not in line_data[pk]:
                                 line_data[pk]['params'] = []
                             if len(line_data[pk]['params'])<int(x)+1:
                                 line_data[pk]['params'].append({})
                             line_data[pk]['params'][int(x)][name] = float(request.POST[label])
                         for pk, params in line_data.items():
                             line = RCLine.objects.get(pk=pk)
                             if line.line_type.name in ('windows', 'prog_pulses'):
                                 if 'params' not in params:
                                     params['params'] = []
                             line.params = json.dumps(params)
                             #print(line.params)
                             line.save()
                         #update pulses field
                         conf.update_pulses()
                         messages.success(request, 'RC Configuration successfully updated')
                         return redirect(conf.get_absolute_url())
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 kwargs['form'] = form
                 kwargs['form_clock'] = form_clock
                 kwargs['rc_lines'] = lines
                 kwargs['edit'] = True
                 kwargs['title'] = 'RC Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 return render(request, 'rc_conf_edit.html', kwargs)
             def add_line(request, conf_id, line_type_id=None, code_id=None):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 if request.method=='GET':
                     if line_type_id:
                         line_type = get_object_or_404(RCLineType, pk=line_type_id)
                         if code_id:
                             form = RCLineForm(initial={'rc_configuration':conf_id, 'line_type': line_type_id, 'code_id': code_id},
                                               extra_fields=json.loads(line_type.params))
                         else:
                             form = RCLineForm(initial={'rc_configuration':conf_id, 'line_type': line_type_id},
                                               extra_fields=json.loads(line_type.params))
                     else:
                         line_type = {'id':0}
                         form = RCLineForm(initial={'rc_configuration':conf_id})
                 if request.method=='POST':
                     line_type = get_object_or_404(RCLineType, pk=line_type_id)
                     form = RCLineForm(request.POST,
                                       extra_fields=json.loads(line_type.params))
                     if form.is_valid():
                         form.save()
                         form.instance.update_pulses()
                         return redirect('url_edit_rc_conf', conf.id)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'RC Configuration'
                 kwargs['suptitle'] = 'Add Line'
                 kwargs['button'] = 'Add'
                 kwargs['previous'] = conf.get_absolute_url_edit()
                 kwargs['dev_conf'] = conf
                 kwargs['line_type'] = line_type
                 return render(request, 'rc_add_line.html', kwargs)
             def edit_codes(request, conf_id, line_id, code_id=None):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 line = get_object_or_404(RCLine, pk=line_id)
                 params = json.loads(line.params)
                 if request.method=='GET':
                     if code_id:
                         code = get_object_or_404(RCLineCode, pk=code_id)
                         form = RCLineCodesForm(instance=code)
                     else:
                         initial = {'code': params['code'],
                                    'codes': params['codes'] if 'codes' in params else [],
                                    'number_of_codes': len(params['codes']) if 'codes' in params else 0,
                                    'bits_per_code': len(params['codes'][0]) if 'codes' in params else 0,
                                    }
                         form = RCLineCodesForm(initial=initial)
                 if request.method=='POST':
                     form = RCLineCodesForm(request.POST)
                     if form.is_valid():
                         params['code'] = request.POST['code']
                         params['codes'] = [s for s in request.POST['codes'].split('\r\n') if s]
                         line.params = json.dumps(params)
                         line.save()
                         messages.success(request, 'Line: "%s" has been updated.'  % line)
                         return redirect('url_edit_rc_conf', conf.id)
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = line
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 kwargs['dev_conf'] = conf
                 kwargs['previous'] = conf.get_absolute_url_edit()
                 kwargs['line'] = line
                 return render(request, 'rc_edit_codes.html', kwargs)
             def add_subline(request, conf_id, line_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 line = get_object_or_404(RCLine, pk=line_id)
                 if request.method == 'POST':
                     if line:
                         params = json.loads(line.params)
                         subparams = json.loads(line.line_type.params)
                         if 'params' in subparams:
                             dum = {}
                             for key, value in subparams['params'].items():
                                 dum[key] = value['value']
                             params['params'].append(dum)
                             line.params = json.dumps(params)
                             line.save()
                         return redirect('url_edit_rc_conf', conf.id)
                 kwargs = {}
                 kwargs['title'] = 'Add new'
                 kwargs['suptitle'] = '%s to %s' % (line.line_type.name, line)
                 return render(request, 'confirm.html', kwargs)
             def remove_line(request, conf_id, line_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 line = get_object_or_404(RCLine, pk=line_id)
                 if request.method == 'POST':
                     if line:
                         try:
                             channel = line.channel
                             line.delete()
                             for ch in range(channel+1, RCLine.objects.filter(rc_configuration=conf).count()+1):
                                 l = RCLine.objects.get(rc_configuration=conf, channel=ch)
                                 l.channel = l.channel-1
                                 l.save()
                             messages.success(request, 'Line: "%s" has been deleted.'  % line)
                         except:
                             messages.error(request, 'Unable to delete line: "%s".' % line)
                     return redirect('url_edit_rc_conf', conf.id)
                 kwargs = {}
                 kwargs['object'] = line
                 kwargs['delete'] = True
                 kwargs['title'] = 'Delete'
                 kwargs['suptitle'] = 'Line'
                 kwargs['previous'] = conf.get_absolute_url_edit()
                 return render(request, 'confirm.html', kwargs)
             def remove_subline(request, conf_id, line_id, subline_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 line = get_object_or_404(RCLine, pk=line_id)
                 if request.method == 'POST':
                     if line:
                         params = json.loads(line.params)
                         params['params'].remove(params['params'][int(subline_id)-1])
                         line.params = json.dumps(params)
                         line.save()
                         return redirect('url_edit_rc_conf', conf.id)
                 kwargs = {}
                 kwargs['object'] = line
                 kwargs['object_name'] = line.line_type.name
                 kwargs['delete_view'] = True
                 kwargs['title'] = 'Confirm delete'
                 return render(request, 'confirm.html', kwargs)
             def update_lines_position(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 print("ingreso a update_lines_position")
                 if request.method=='POST':
                     ch = 0
                     for item in request.POST['items'].split('&'):
                         line = RCLine.objects.get(pk=item.split('=')[-1])
                         line.channel = ch
                         line.save()
                         ch += 1
                     lines = RCLine.objects.filter(rc_configuration=conf).order_by('channel')
                     for line in lines:
                         params = json.loads(line.params)
                         print(params)
                         print("Fin de impresion_lines_position")
                         line.form = RCLineEditForm(conf=conf, line=line, extra_fields=params)
                         if 'params' in params:
                             line.subform = True
                             line.subforms = [RCLineEditForm(extra_fields=fields, line=line, subform=i) for i, fields in enumerate(params['params'])]
                     html = render(request, 'rc_lines.html', {'dev_conf':conf, 'rc_lines':lines, 'edit':True})
                     data = {'html': html.content.decode('utf8')}
                     return HttpResponse(json.dumps(data), content_type="application/json")
                 return redirect('url_edit_rc_conf', conf.id)
             def import_file(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 if request.method=='POST':
                     form = RCImportForm(request.POST, request.FILES)
                     if form.is_valid():
                         try:
                             data = conf.import_from_file(request.FILES['file_name'])
                             conf.dict_to_parms(data)
                             conf.update_pulses()
                             messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name'])
                             return redirect(conf.get_absolute_url_edit())
                         except Exception as e:
                             messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], repr(e)))
                 else:
                     messages.warning(request, 'Your current configuration will be replaced')
                     form = RCImportForm()
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'RC Configuration'
                 kwargs['suptitle'] = 'Import file'
                 kwargs['button'] = 'Upload'
                 kwargs['previous'] = conf.get_absolute_url()
                 return render(request, 'rc_import.html', kwargs)
             def plot_pulses(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 km = True if 'km' in request.GET else False
                 script, div = conf.plot_pulses(km=km)
                 kwargs = {}
                 kwargs['no_sidebar'] = True
                 kwargs['title'] = 'RC Pulses'
                 kwargs['suptitle'] = conf.name
                 kwargs['div'] = mark_safe(div)
                 kwargs['script'] = mark_safe(script)
                 kwargs['units'] = conf.km2unit
                 kwargs['kms'] = 1/conf.km2unit
                 if km:
                     kwargs['km_selected'] = True
                 if 'json' in request.GET:
                     return HttpResponse(json.dumps({'div':mark_safe(div), 'script':mark_safe(script)}), content_type="application/json")
                 else:
                     return render(request, 'rc_pulses.html', kwargs)
             def plot_pulses2(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 km = True if 'km' in request.GET else False
                 script, div = conf.plot_pulses2(km=km)
                 kwargs = {}
                 kwargs['no_sidebar'] = True
                 kwargs['title'] = 'RC Pulses'
                 kwargs['suptitle'] = conf.name
                 kwargs['div'] = mark_safe(div)
                 kwargs['script'] = mark_safe(script)
                 kwargs['units'] = conf.km2unit
                 kwargs['kms'] = 1/conf.km2unit
                 if km:
                     kwargs['km_selected'] = True
                 if 'json' in request.GET:
                     return HttpResponse(json.dumps({'div':mark_safe(div), 'script':mark_safe(script)}), content_type="application/json")
                 else:
                     return render(request, 'rc_pulses.html', kwargs)
             def conf_raw(request, conf_id):
                 conf = get_object_or_404(RCConfiguration, pk=conf_id)
                 raw = conf.write_device(raw=True)
                 return HttpResponse(raw, content_type='application/json')

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