radarsys Commit - r409:ff996bcda7e9 · Jicamarca Repository

Update cr models.py to show used memory in plot_pulses view

jrojas -

r409:ff996bcda7e9

parent child

Context file:

r409:ff996bcda7e9

apps/rc/models.py +105 -53

             from struct import pack
             from django.db import models
-            from django.core.urlresolvers import reverse
+            from django.urls import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from apps.main.models import Configuration
                 def clone(self, **kwargs):
                     lines = self.get_lines()
                     self.pk = None
                     self.id = None
                     for attr, value in kwargs.items():
                     else:
                         data = Params(params).get_conf(dtype='rc')
+                    #print(data)
                     # self.name = data['name']
                     self.ipp = data['ipp']
                     self.ntx = data['ntx']
                     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]
                                     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):
                     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()]
                     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 = []
-                        for i, tups in enumerate(pulses):
+                        print('loading', x*100/max(points))
-                            ups = [tup[0] for tup in tups if tup!=(0,0)]
-                            dws = [tup[1] for tup in tups if tup!=(0,0)]
+                        for i in range(n_pulses):
-                            if x in ups:
+                            if x in ups_arr[i]:
                                 dum.append(1)
-                            elif x in dws:
+                            elif x in dws_arr[i]:
                                 dum.append(0)
                             else:
                                 dum.append(last[i])
-                        states.append(dum)
+                        #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]
                     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):
                     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.tools = [PanTool(dimensions="width"), WheelZoomTool(dimensions="width"), ResetTool(), SaveTool()]
                     plot.toolbar_location="above"
                     return components(plot, CDN)
                     from bokeh.plotting import figure
                     from bokeh.resources import CDN
                     from bokeh.embed import components
-                    from bokeh.models import FixedTicker, PrintfTickFormatter
+                    from bokeh.models import FixedTicker, PrintfTickFormatter, Label
                     from bokeh.models.tools import WheelZoomTool, ResetTool, PanTool, HoverTool, SaveTool
                     from bokeh.models.sources import ColumnDataSource
                                                 ("IPP", "@ipp"),
                                                 ("X", "@left")])
-                    tools = [PanTool(dimensions=['width']),
+                    tools = [PanTool(dimensions="width"),
-                             WheelZoomTool(dimensions=['width']),
+                             WheelZoomTool(dimensions="width"),
                              hover, SaveTool()]
                     plot = figure(width=1000,
                                   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'
                     return True
                 def write_device(self, raw=False):
+                    print("write device")
                     if not raw:
                         clock = RCClock.objects.get(rc_configuration=self)
                         else:
                             data = {'manual': [clock.multiplier, clock.divisor, clock.reference]}
                         payload = self.request('setfreq', 'post', data=json.dumps(data))
-                        if payload['command'] <> 'ok':
+                        #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'
                     values = []
+                    print('wait delay values...')
                     for pulse, delay in zip(self.get_pulses(), self.get_delays()):
-                        while delay>65536:
+                        #print('wait zip...')
+                        while delay > 65536:
                             values.append((pulse, 65535))
                             delay -= 65536
                         values.append((pulse, delay-1))
                     data.extend((139, 62))
                     last = 0
+                    print('wait data...')
                     for tup in values:
                         vals = pack('<HH', last^tup[0], tup[1])
                         last = tup[0]
                     #enable
                     data.extend((129, 1))
+                    print('len',len(data))
                     if raw:
                         return b64encode(data)
-                    try:
+                    #try:
-                        payload = self.request('stop', 'post')
+                    print('requests')
-                        payload = self.request('reset', 'post')
+                    payload = self.request('stop', 'post')
-                        #payload = self.request('divider', 'post', data={'divider': self.clock_divider-1})
+                    payload = self.request('reset', 'post')
-                        #payload = self.request('write', 'post', data=b64encode(bytearray((139, 62))), timeout=20)
+                    #payload = self.request('divider', 'post', data={'divider': self.clock_divider-1})
-                        n = len(data)
+                    #payload = self.request('write', 'post', data=b64encode(bytearray((139, 62))), timeout=20)
-                        x = 0
+                    n = len(data)
-                        #while x < n:
+                    print('len: ',n)
-                        payload = self.request('write', 'post', data=b64encode(data))
+                    x = 0
-                        #    x += 1024
+                    cnt = 0
+                    while x < n:
-                        if payload['write']=='ok':
+                        print('writing...', cnt)
-                            self.device.status = 3
+                        payload = self.request('write', 'post', data=b64encode(data[x:x+3072]))#(data))#
-                            self.device.save()
+                        x += 3072
-                            self.message = 'RC configured and started'
+                        cnt += 1#time.sleep(1)
-                        else:
+                        print('writing...', x*100/n)
-                            self.device.status = 1
-                            self.device.save()
+                    if payload['write']=='ok':
-                            self.message = 'RC write: {}'.format(payload['write'])
+                        self.device.status = 3
-                            return False
+                        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:
+                    #except Exception as e:
-                        if 'No route to host' not in str(e):
+                    #    if 'No route to host' not in str(e):
-                            self.device.status = 4
+                    #        self.device.status = 4
-                        else:
+                    #    else:
-                            self.device.status = 0
+                    #        self.device.status = 0
-                        self.message = 'RC write: {}'.format(str(e))
+                    #    self.message = 'RC write: {}'.format(str(e))
-                        self.device.save()
+                    #    self.device.save()
-                        return False
+                    #    return False
                     return True
             class RCLine(models.Model):
-                rc_configuration = models.ForeignKey(RCConfiguration, on_delete=models.CASCADE)
+                rc_configuration = models.ForeignKey('RCConfiguration', on_delete=models.CASCADE)
-                line_type = models.ForeignKey(RCLineType)
+                line_type = models.ForeignKey('RCLineType',on_delete=models.CASCADE)
                 channel = models.PositiveIntegerField(default=0)
                 position = models.PositiveIntegerField(default=0)
                 params = models.TextField(default='{}')
                     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:
                         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:
             class RCClock(models.Model):
-                rc_configuration = models.ForeignKey(RCConfiguration, on_delete=models.CASCADE)
+                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)
  No newline at end of file
+                frequency = models.FloatField(default=60.0)

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