##// END OF EJS Templates
radarsys_met
RSS
clean abs code
jespinoza -
r315:b3c54f0853ae
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,878 +1,876
1 1 from django.db import models
2 2 from apps.main.models import Configuration
3 3 from django.core.urlresolvers import reverse
4 4 # Create your models here.
5 5 from celery.execute import send_task
6 6 from datetime import datetime
7 7 import ast
8 8 import socket
9 9 import json
10 10 import requests
11 11 import struct
12 12 import os, sys, time
13 13
14 14 import multiprocessing
15 15
16 16
17 17 antenna_default = json.dumps({
18 18 "antenna_up": [[0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
19 19 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
20 20 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
21 21 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
22 22 [0.5,0.5,0.5,0.5,1.0,1.0,1.0,1.0],
23 23 [0.5,0.5,0.5,0.5,1.0,1.0,1.0,1.0],
24 24 [0.5,0.5,0.5,0.5,1.0,1.0,1.0,1.0],
25 25 [0.5,0.5,0.5,0.5,1.0,1.0,1.0,1.0]
26 26 ]
27 27 ,
28 28 "antenna_down": [[0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
29 29 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
30 30 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
31 31 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
32 32 [0.5,0.5,0.5,0.5,3.0,3.0,3.0,3.0],
33 33 [0.5,0.5,0.5,0.5,3.0,3.0,3.0,3.0],
34 34 [0.5,0.5,0.5,0.5,3.0,3.0,3.0,3.0],
35 35 [0.5,0.5,0.5,0.5,3.0,3.0,3.0,3.0]],
36 36 })
37 37
38 38
39 39 tx_default = json.dumps({
40 40 "up": [[1,1,1,1,0,0,0,0],
41 41 [1,1,1,1,0,0,0,0],
42 42 [1,1,1,1,0,0,0,0],
43 43 [1,1,1,1,0,0,0,0],
44 44 [0,0,0,0,1,1,1,1],
45 45 [0,0,0,0,1,1,1,1],
46 46 [0,0,0,0,1,1,1,1],
47 47 [0,0,0,0,1,1,1,1]],
48 48
49 49 "down": [[1,1,1,1,0,0,0,0],
50 50 [1,1,1,1,0,0,0,0],
51 51 [1,1,1,1,0,0,0,0],
52 52 [1,1,1,1,0,0,0,0],
53 53 [0,0,0,0,1,1,1,1],
54 54 [0,0,0,0,1,1,1,1],
55 55 [0,0,0,0,1,1,1,1],
56 56 [0,0,0,0,1,1,1,1]],
57 57 })
58 58
59 59 rx_default = json.dumps({
60 60 "up": [[1,1,1,1,0,0,0,0],
61 61 [1,1,1,1,0,0,0,0],
62 62 [1,1,1,1,0,0,0,0],
63 63 [1,1,1,1,0,0,0,0],
64 64 [0,0,0,0,1,1,1,1],
65 65 [0,0,0,0,1,1,1,1],
66 66 [0,0,0,0,1,1,1,1],
67 67 [0,0,0,0,1,1,1,1]],
68 68
69 69 "down": [[1,1,1,1,0,0,0,0],
70 70 [1,1,1,1,0,0,0,0],
71 71 [1,1,1,1,0,0,0,0],
72 72 [1,1,1,1,0,0,0,0],
73 73 [0,0,0,0,1,1,1,1],
74 74 [0,0,0,0,1,1,1,1],
75 75 [0,0,0,0,1,1,1,1],
76 76 [0,0,0,0,1,1,1,1]],
77 77 })
78 78
79 79 status_default = '0000000000000000000000000000000000000000000000000000000000000000'
80 80 default_messages = {}
81 81
82 82 for i in range(1,65):
83 83 default_messages[str(i)] = "Module "+str(i)
84 84
85 85
86 86 ues_default = json.dumps({
87 87 "up": [0.533333,0.00000,1.06667,0.00000],
88 88 "down": [0.533333,0.00000,1.06667,0.00000]
89 89 })
90 90
91 91 onlyrx_default = json.dumps({
92 92 "up": False,
93 93 "down": False
94 94 })
95 95
96 96 def up_convertion(cadena):
97 97 valores = []
98 98 for c in cadena:
99 99 if c == 1.0: valores=valores+['000']
100 100 if c == 2.0: valores=valores+['001']
101 101 if c == 3.0: valores=valores+['010']
102 102 if c == 0.0: valores=valores+['011']
103 103 if c == 0.5: valores=valores+['100']
104 104 if c == 1.5: valores=valores+['101']
105 105 if c == 2.5: valores=valores+['110']
106 106 if c == 3.5: valores=valores+['111']
107 107
108 108 return valores
109 109
110 110 def up_conv_bits(value):
111 111
112 112 if value == 1.0: bits="000"
113 113 if value == 2.0: bits="001"
114 114 if value == 3.0: bits="010"
115 115 if value == 0.0: bits="011"
116 116 if value == 0.5: bits="100"
117 117 if value == 1.5: bits="101"
118 118 if value == 2.5: bits="110"
119 119 if value == 3.5: bits="111"
120 120
121 121 return bits
122 122
123 123 def down_convertion(cadena):
124 124 valores = []
125 125 for c in cadena:
126 126 if c == 1.0: valores=valores+['000']
127 127 if c == 2.0: valores=valores+['001']
128 128 if c == 3.0: valores=valores+['010']
129 129 if c == 0.0: valores=valores+['011']
130 130 if c == 0.5: valores=valores+['100']
131 131 if c == 1.5: valores=valores+['101']
132 132 if c == 2.5: valores=valores+['110']
133 133 if c == 3.5: valores=valores+['111']
134 134
135 135 return valores
136 136
137 137 def down_conv_bits(value):
138 138
139 139 if value == 1.0: bits="000"
140 140 if value == 2.0: bits="001"
141 141 if value == 3.0: bits="010"
142 142 if value == 0.0: bits="011"
143 143 if value == 0.5: bits="100"
144 144 if value == 1.5: bits="101"
145 145 if value == 2.5: bits="110"
146 146 if value == 3.5: bits="111"
147 147
148 148 return bits
149 149
150 150 def up_conv_value(bits):
151 151
152 152 if bits == "000": value=1.0
153 153 if bits == "001": value=2.0
154 154 if bits == "010": value=3.0
155 155 if bits == "011": value=0.0
156 156 if bits == "100": value=0.5
157 157 if bits == "101": value=1.5
158 158 if bits == "110": value=2.5
159 159 if bits == "111": value=3.5
160 160
161 161 return value
162 162
163 163 def down_conv_value(bits):
164 164
165 165 if bits == "000": value=1.0
166 166 if bits == "001": value=2.0
167 167 if bits == "010": value=3.0
168 168 if bits == "011": value=0.0
169 169 if bits == "100": value=0.5
170 170 if bits == "101": value=1.5
171 171 if bits == "110": value=2.5
172 172 if bits == "111": value=3.5
173 173
174 174 return value
175 175
176 176 def ip2position(module_number):
177 177 j=0
178 178 i=0
179 179 for x in range(0,module_number-1):
180 180 j=j+1
181 181 if j==8:
182 182 i=i+1
183 183 j=0
184 184
185 185 pos = [i,j]
186 186 return pos
187 187
188 188
189 189 def fromBinary2Char(binary_string):
190 190 number = int(binary_string, 2)
191 191 #Plus 33 to avoid more than 1 characters values such as: '\x01'-'\x1f'
192 192 number = number + 33
193 193 char = chr(number)
194 194 return char
195 195
196 196 def fromChar2Binary(char):
197 197 number = ord(char) - 33
198 198 #Minus 33 to get the real value
199 199 bits = bin(number)[2:]
200 200 #To ensure we have a string with 6bits
201 201 if len(bits) < 6:
202 202 bits = bits.zfill(6)
203 203 return bits
204 204
205 205 OPERATION_MODES = (
206 206 (0, 'Manual'),
207 207 (1, 'Automatic'),
208 208 )
209 209
210 210
211 211 class ABSConfiguration(Configuration):
212 212 active_beam = models.PositiveSmallIntegerField(verbose_name='Active Beam', default=0)
213 213 module_status = models.CharField(verbose_name='Module Status', max_length=10000, default=json.dumps(status_default))
214 214 operation_mode = models.PositiveSmallIntegerField(verbose_name='Operation Mode', choices=OPERATION_MODES, default = 0)
215 215 operation_value = models.FloatField(verbose_name='Periodic (seconds)', default="10", null=True, blank=True)
216 216 module_messages = models.CharField(verbose_name='Modules Messages', max_length=10000, default=json.dumps(default_messages))
217 217
218 218 class Meta:
219 219 db_table = 'abs_configurations'
220 220
221 221 def get_absolute_url_plot(self):
222 222 return reverse('url_plot_abs_patterns', args=[str(self.id)])
223 223
224 224
225 225 def parms_to_dict(self):
226 226
227 227 parameters = {}
228 228
229 229 parameters['device_id'] = self.device.id
230 230 parameters['name'] = self.name
231 231 parameters['device_type'] = self.device.device_type.name
232 232 parameters['beams'] = {}
233 233
234 234 beams = ABSBeam.objects.filter(abs_conf=self)
235 235 b=1
236 236 for beam in beams:
237 237 #absbeam = ABSBeam.objects.get(pk=beams[beam])
238 238 parameters['beams']['beam'+str(b)] = beam.parms_to_dict()#absbeam.parms_to_dict()
239 239 b+=1
240 240
241 241 return parameters
242 242
243 243
244 244 def dict_to_parms(self, parameters):
245 245
246 246 self.name = parameters['name']
247 247
248 248 absbeams = ABSBeam.objects.filter(abs_conf=self)
249 249 beams = parameters['beams']
250 250
251 251 if absbeams:
252 252 beams_number = len(beams)
253 253 absbeams_number = len(absbeams)
254 254 if beams_number==absbeams_number:
255 255 i = 1
256 256 for absbeam in absbeams:
257 257 absbeam.dict_to_parms(beams['beam'+str(i)])
258 258 i = i+1
259 259 elif beams_number > absbeams_number:
260 260 i = 1
261 261 for absbeam in absbeams:
262 262 absbeam.dict_to_parms(beams['beam'+str(i)])
263 263 i=i+1
264 264 for x in range(i,beams_number+1):
265 265 new_beam = ABSBeam(
266 266 name =beams['beam'+str(i)]['name'],
267 267 antenna =json.dumps(beams['beam'+str(i)]['antenna']),
268 268 abs_conf = self,
269 269 tx =json.dumps(beams['beam'+str(i)]['tx']),
270 270 rx =json.dumps(beams['beam'+str(i)]['rx']),
271 271 ues =json.dumps(beams['beam'+str(i)]['ues']),
272 272 only_rx =json.dumps(beams['beam'+str(i)]['only_rx'])
273 273 )
274 274 new_beam.save()
275 275 i=i+1
276 276 else: #beams_number < absbeams_number:
277 277 i = 1
278 278 for absbeam in absbeams:
279 279 if i <= beams_number:
280 280 absbeam.dict_to_parms(beams['beam'+str(i)])
281 281 i=i+1
282 282 else:
283 283 absbeam.delete()
284 284 else:
285 285 for beam in beams:
286 286 new_beam = ABSBeam(
287 287 name =beams[beam]['name'],
288 288 antenna =json.dumps(beams[beam]['antenna']),
289 289 abs_conf = self,
290 290 tx =json.dumps(beams[beam]['tx']),
291 291 rx =json.dumps(beams[beam]['rx']),
292 292 ues =json.dumps(beams[beam]['ues']),
293 293 only_rx =json.dumps(beams[beam]['only_rx'])
294 294 )
295 295 new_beam.save()
296 296
297 297
298 298
299 299 def update_from_file(self, parameters):
300 300
301 301 self.dict_to_parms(parameters)
302 302 self.save()
303 303
304 304
305 305 def get_beams(self, **kwargs):
306 306 '''
307 307 This function returns ABS Configuration beams
308 308 '''
309 309 return ABSBeam.objects.filter(abs_conf=self.pk, **kwargs)
310 310
311 311 def clone(self, **kwargs):
312 312
313 313 beams = self.get_beams()
314 314 self.pk = None
315 315 self.id = None
316 316 for attr, value in kwargs.items():
317 317 setattr(self, attr, value)
318 318 self.save()
319 319
320 320 for beam in beams:
321 321 beam.clone(abs_conf=self)
322 322
323 323 #-----For Active Beam-----
324 324 new_beams = ABSBeam.objects.filter(abs_conf=self)
325 325 self.active_beam = new_beams[0].id
326 326 self.save()
327 327 #-----For Active Beam-----
328 328 #-----For Device Status---
329 329 self.device.status = 3
330 330 self.device.save()
331 331 #-----For Device Status---
332 332
333 333 return self
334 334
335 335
336 336 def start_device(self):
337 337
338 338 if self.device.status == 3:
339 339
340 340 try:
341 341 #self.write_device()
342 342 send_task('task_change_beam', [self.id],)
343 343 self.message = 'ABS running'
344 344
345 345 except Exception as e:
346 346 self.message = str(e)
347 347 return False
348 348
349 349 return True
350 350
351 351 else:
352 352 self.message = 'Please, select Write ABS Device first.'
353 353 return False
354 354
355 355
356 356 def stop_device(self):
357 357
358 358 self.device.status = 2
359 359 self.device.save()
360 360 self.message = 'ABS has been stopped.'
361 361 self.save()
362 362
363 363 return True
364 364
365 365
366 366 def write_device(self):
367 367
368 368 """
369 369 This function sends the beams list to every abs module.
370 370 It needs 'module_conf' function
371 371 """
372 372
373 373 beams = ABSBeam.objects.filter(abs_conf=self)
374 374 nbeams = len(beams)
375 375 if self.connected_modules() == 0 :
376 376 self.message = "No ABS Module detected."
377 377 return False
378 378
379 379 #-------------Write each abs module-----------
380 380
381 381 if beams:
382 382 block_id = 0
383 383 message = 'SNDF{:03d}{:02d}{:02d}'.format(nbeams, nbeams, block_id)
384 384 for i, status in enumerate(self.module_status):
385 385 message += ''.join([fromBinary2Char(beam.module_6bits(i)) for beam in beams])
386 386 status = ['0'] * 64
387 387 n = 0
388 388
389 389 sock = self.send_multicast(message)
390 390
391 391 for i in range(32):
392 392 try:
393 393 data, address = sock.recvfrom(1024)
394 394 print address, data
395 395 if data == '1':
396 396 status[int(address[0][10:])-1] = '3'
397 397 elif data == '0':
398 398 status[int(address[0][10:])-1] = '1'
399 except:
399 except Exception as e:
400 print 'Error {}'.format(e)
400 401 n += 1
401 402 sock.close()
402 403 else:
403 404 self.message = "ABS Configuration does not have beams"
404 405 return False
405 406
406 407 if n == 64:
407 408 self.message = "Could not write ABS Modules"
408 409 self.device.status = 0
409 410 self.module_status = ''.join(status)
410 411 self.save()
411 412 return False
412 413 else:
413 414 self.message = "ABS Beams List have been sent to ABS Modules"
414 415 self.active_beam = beams[0].pk
415 416
416 417 self.device.status = 3
417 418 self.module_status = ''.join(status)
418 419 self.save()
419 420 return True
420 421
421 422
422 423 def read_module(self, module):
423 424
424 425 """
425 426 Read out-bits (up-down) of 1 abs module NOT for Configuration
426 427 """
427 428
428 429 ip_address = self.device.ip_address
429 430 ip_address = ip_address.split('.')
430 431 module_seq = (ip_address[0],ip_address[1],ip_address[2])
431 432 dot = '.'
432 433 module_ip = dot.join(module_seq)+'.'+str(module)
433 434 module_port = self.device.port_address
434 435 read_route = 'http://'+module_ip+':'+str(module_port)+'/read'
435 436
436 437 module_status = json.loads(self.module_status)
437 438 print(read_route)
438 439
439 440 module_bits = ''
440 441
441 442 try:
442 443 r_read = requests.get(read_route, timeout=0.5)
443 444 answer = r_read.json()
444 445 module_bits = answer['allbits']
445 446 except:
446 447 return {}
447 448
448 449 return module_bits
449 450
450 451 def read_device(self):
451 452
452 453 parms = {}
453 454 # Reads active modules.
454 455 module_status = json.loads(self.module_status)
455 456 total = 0
456 457 for status in module_status:
457 458 if module_status[status] != 0:
458 459 module_bits = self.read_module(int(status))
459 460 bits={}
460 461 if module_bits:
461 462 bits = (str(module_bits['um2']) + str(module_bits['um1']) + str(module_bits['um0']) +
462 463 str(module_bits['dm2']) + str(module_bits['dm1']) + str(module_bits['dm0']) )
463 464 parms[str(status)] = bits
464 465
465 466 total +=1
466 467
467 468 if total==0:
468 469 self.message = "No ABS Module detected. Please select 'Status'."
469 470 return False
470 471
471 472
472 473
473 474 self.message = "ABS Modules have been read"
474 475 #monitoreo_tx = JROABSClnt_01CeCnMod000000MNTR10
475 476 return parms
476 477
477 478
478 479 def connected_modules(self):
479 480 """
480 481 This function returns the number of connected abs-modules without updating.
481 482 """
482 483 num = 0
483 484 print(self.module_status)
484 485 for i, status in enumerate(self.module_status):
485 486 if status != '0':
486 487 num += 1
487 488 #print('status {}:{}'.format(i+1, status))
488 489 return num
489 490
490 491 def send_multicast(self, message):
491 492
492 493 multicast_group = ('224.3.29.71', 10000)
493 494 # Create the datagram socket
494 495 sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
495 sock.settimeout(0.5)
496 sock.settimeout(1)
496 497 # sock.bind((local_ip, 10000))
497 498 local_ip = os.environ.get('LOCAL_IP', '127.0.0.1')
499 local_ip = '192.168.1.128'
498 500 sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_IF, socket.inet_aton(local_ip))
499 501 sent = sock.sendto(message, multicast_group)
500 502 print('Sending ' + message)
501 503 return sock
502 504
503 505 def status_device(self):
504 506 """
505 507 This function returns the status of all abs-modules as one.
506 508 If at least one module is connected, its answer is "1"
507 509 """
508 510
509 511 sock = self.send_multicast('MNTR')
510 512
511 513 n = 0
512 514 status = ['0'] * 64
513 515 for i in range(32):
514 516 #if True:
515 517 try:
518 address = None
516 519 data, address = sock.recvfrom(1024)
517 520 print address, data
518 521 if data == '1':
519 522 status[int(address[0][10:])-1] = '3'
520 523 elif data == '0':
521 524 status[int(address[0][10:])-1] = '1'
522 525 n += 1
523 526 print('Module: {} connected'.format(address))
524 527 except:
525 528 print('Module: {} error'.format(address))
526 529 pass
527 530 sock.close()
528 531
529 532 if n > 0:
530 533 self.message = 'ABS modules Status have been updated.'
531 534 self.device.status = 1
532 535 else:
533 536 self.device.status = 0
534 537 self.message = 'No ABS module is connected.'
535 538 self.module_status = ''.join(status)
536 539 self.save()
537 540
538 541 return self.device.status
539 542
540 543
541 544 def send_beam(self, beam_pos):
542 545 """
543 546 This function connects to a multicast group and sends the beam number
544 547 to all abs modules.
545 548 """
546 549
547 550 # Se manda a cero RC para poder realizar cambio de beam
548 551 if self.experiment is None:
549 552 confs = []
550 553 else:
551 554 confs = Configuration.objects.filter(experiment = self.experiment).filter(type=0)
552 555 confdds = ''
553 556 confjars = ''
554 557 confrc = ''
555 print 'Starting...', self.experiment
556 558 #TO STOP DEVICES: DDS-JARS-RC
557 559 for i in range(0,len(confs)):
558 print i
559 560 if i==0:
560 561 for conf in confs:
561 562 if conf.device.device_type.name == 'dds':
562 563 confdds = conf
563 564 confdds.stop_device()
564 565 break
565 566 if i==1:
566 567 for conf in confs:
567 568 if conf.device.device_type.name == 'jars':
568 569 confjars = conf
569 570 confjars.stop_device()
570 571 break
571 572 if i==2:
572 573 for conf in confs:
573 print conf
574 574 if conf.device.device_type.name == 'rc':
575 575 confrc = conf
576 576 confrc.stop_device()
577 577 break
578 print 'Stop devices'
579 578 if beam_pos > 0:
580 579 beam_pos = beam_pos - 1
581 580 else:
582 581 beam_pos = 0
583 582
584 583 #El indice del apunte debe ser menor que el numero total de apuntes
585 584 #El servidor tcp en el embebido comienza a contar desde 0
586 585 status = ['0'] * 64
587 586 message = 'CHGB{}'.format(beam_pos)
588 print 'Before send'
589 587 sock = self.send_multicast(message)
590 print 'Waiting'
591 588 for i in range(32):
592 589 try:
593 590 data, address = sock.recvfrom(1024)
594 591 print address, data
595 592 if data == '1':
596 593 status[int(address[0][10:])-1] = '3'
597 594 elif data == '0':
598 595 status[int(address[0][10:])-1] = '1'
599 except:
596 except Exception as e:
597 print 'Error {}'.format(e)
600 598 pass
601 599
602 600 sock.close()
603 601
604 602 #Start DDS-RC-JARS
605 603 if confdds:
606 604 confdds.start_device()
607 605 if confrc:
608 606 #print confrc
609 607 confrc.start_device()
610 608 if confjars:
611 609 confjars.start_device()
612 610
613 611 self.message = "ABS Beam has been changed"
614 612 self.module_status = ''.join(status)
615 613 self.save()
616 614 return True
617 615
618 616
619 617 def get_absolute_url_import(self):
620 618 return reverse('url_import_abs_conf', args=[str(self.id)])
621 619
622 620
623 621 class ABSBeam(models.Model):
624 622
625 623 name = models.CharField(max_length=60, default='Beam')
626 624 antenna = models.CharField(verbose_name='Antenna', max_length=1000, default=antenna_default)
627 625 abs_conf = models.ForeignKey(ABSConfiguration, null=True, verbose_name='ABS Configuration')
628 626 tx = models.CharField(verbose_name='Tx', max_length=1000, default=tx_default)
629 627 rx = models.CharField(verbose_name='Rx', max_length=1000, default=rx_default)
630 628 s_time = models.TimeField(verbose_name='Star Time', default='00:00:00')
631 629 e_time = models.TimeField(verbose_name='End Time', default='23:59:59')
632 630 ues = models.CharField(verbose_name='Ues', max_length=100, default=ues_default)
633 631 only_rx = models.CharField(verbose_name='Only RX', max_length=40, default=onlyrx_default)
634 632
635 633 class Meta:
636 634 db_table = 'abs_beams'
637 635
638 636 def __unicode__(self):
639 637 return u'%s' % (self.name)
640 638
641 639 def parms_to_dict(self):
642 640
643 641 parameters = {}
644 642 parameters['name'] = self.name
645 643 parameters['antenna'] = ast.literal_eval(self.antenna)
646 644 parameters['abs_conf'] = self.abs_conf.name
647 645 parameters['tx'] = ast.literal_eval(self.tx)
648 646 parameters['rx'] = ast.literal_eval(self.rx)
649 647 parameters['s_time'] = self.s_time.strftime("%H:%M:%S")
650 648 parameters['e_time'] = self.e_time.strftime("%H:%M:%S")
651 649 parameters['ues'] = ast.literal_eval(self.ues)
652 650 parameters['only_rx'] = json.loads(self.only_rx)
653 651
654 652 return parameters
655 653
656 654 def dict_to_parms(self, parameters):
657 655
658 656 self.name = parameters['name']
659 657 self.antenna = json.dumps(parameters['antenna'])
660 658 #self.abs_conf = parameters['abs_conf']
661 659 self.tx = json.dumps(parameters['tx'])
662 660 self.rx = json.dumps(parameters['rx'])
663 661 #self.s_time = parameters['s_time']
664 662 #self.e_time = parameters['e_time']
665 663 self.ues = json.dumps(parameters['ues'])
666 664 self.only_rx = json.dumps(parameters['only_rx'])
667 665 self.save()
668 666
669 667
670 668 def clone(self, **kwargs):
671 669
672 670 self.pk = None
673 671 self.id = None
674 672 for attr, value in kwargs.items():
675 673 setattr(self, attr, value)
676 674
677 675 self.save()
678 676
679 677 return self
680 678
681 679
682 680 def module_6bits(self, module):
683 681 """
684 682 This function reads antenna pattern and choose 6bits (upbits-downbits) for one abs module
685 683 """
686 684 module += 1
687 685 if module > 64:
688 686 beam_bits = ""
689 687 return beam_bits
690 688
691 689 data = ast.literal_eval(self.antenna)
692 690 up_data = data['antenna_up']
693 691 down_data = data['antenna_down']
694 692
695 693 pos = ip2position(module)
696 694 up_value = up_data[pos[0]][pos[1]]
697 695 down_value = down_data[pos[0]][pos[1]]
698 696
699 697 up_bits = up_conv_bits(up_value)
700 698 down_bits = down_conv_bits(down_value)
701 699 beam_bits = up_bits+down_bits
702 700
703 701 return beam_bits
704 702
705 703
706 704 @property
707 705 def get_upvalues(self):
708 706 """
709 707 This function reads antenna pattern and show the up-value of one abs module
710 708 """
711 709
712 710 data = ast.literal_eval(self.antenna)
713 711 up_data = data['antenna_up']
714 712
715 713 up_values = []
716 714 for data in up_data:
717 715 for i in range(0,8):
718 716 up_values.append(data[i])
719 717
720 718 return up_values
721 719
722 720 @property
723 721 def antenna_upvalues(self):
724 722 """
725 723 This function reads antenna pattern and show the up - values of one abs beam
726 724 in a particular order
727 725 """
728 726 data = ast.literal_eval(self.antenna)
729 727 up_data = data['antenna_up']
730 728
731 729 return up_data
732 730
733 731 @property
734 732 def antenna_downvalues(self):
735 733 """
736 734 This function reads antenna pattern and show the down - values of one abs beam
737 735 in a particular order
738 736 """
739 737 data = ast.literal_eval(self.antenna)
740 738 down_data = data['antenna_down']
741 739
742 740 return down_data
743 741
744 742 @property
745 743 def get_downvalues(self):
746 744 """
747 745 This function reads antenna pattern and show the down-value of one abs module
748 746 """
749 747
750 748 data = ast.literal_eval(self.antenna)
751 749 down_data = data['antenna_down']
752 750
753 751 down_values = []
754 752 for data in down_data:
755 753 for i in range(0,8):
756 754 down_values.append(data[i])
757 755
758 756 return down_values
759 757
760 758 @property
761 759 def get_up_ues(self):
762 760 """
763 761 This function shows the up-ues-value of one beam
764 762 """
765 763 data = ast.literal_eval(self.ues)
766 764 up_ues = data['up']
767 765
768 766 return up_ues
769 767
770 768 @property
771 769 def get_down_ues(self):
772 770 """
773 771 This function shows the down-ues-value of one beam
774 772 """
775 773 data = ast.literal_eval(self.ues)
776 774 down_ues = data['down']
777 775
778 776 return down_ues
779 777
780 778 @property
781 779 def get_up_onlyrx(self):
782 780 """
783 781 This function shows the up-onlyrx-value of one beam
784 782 """
785 783 data = json.loads(self.only_rx)
786 784 up_onlyrx = data['up']
787 785
788 786 return up_onlyrx
789 787
790 788 @property
791 789 def get_down_onlyrx(self):
792 790 """
793 791 This function shows the down-onlyrx-value of one beam
794 792 """
795 793 data = json.loads(self.only_rx)
796 794 down_onlyrx = data['down']
797 795
798 796 return down_onlyrx
799 797
800 798 @property
801 799 def get_tx(self):
802 800 """
803 801 This function shows the tx-values of one beam
804 802 """
805 803 data = json.loads(self.tx)
806 804
807 805 return data
808 806
809 807 @property
810 808 def get_uptx(self):
811 809 """
812 810 This function shows the up-tx-values of one beam
813 811 """
814 812 data = json.loads(self.tx)
815 813 up_data = data['up']
816 814
817 815 up_values = []
818 816 for data in up_data:
819 817 for i in range(0,8):
820 818 up_values.append(data[i])
821 819
822 820 return up_values
823 821
824 822 @property
825 823 def get_downtx(self):
826 824 """
827 825 This function shows the down-tx-values of one beam
828 826 """
829 827 data = json.loads(self.tx)
830 828 down_data = data['down']
831 829
832 830 down_values = []
833 831 for data in down_data:
834 832 for i in range(0,8):
835 833 down_values.append(data[i])
836 834
837 835 return down_values
838 836
839 837
840 838
841 839 @property
842 840 def get_rx(self):
843 841 """
844 842 This function shows the rx-values of one beam
845 843 """
846 844 data = json.loads(self.rx)
847 845
848 846 return data
849 847
850 848 @property
851 849 def get_uprx(self):
852 850 """
853 851 This function shows the up-rx-values of one beam
854 852 """
855 853 data = json.loads(self.rx)
856 854 up_data = data['up']
857 855
858 856 up_values = []
859 857 for data in up_data:
860 858 for i in range(0,8):
861 859 up_values.append(data[i])
862 860
863 861 return up_values
864 862
865 863 @property
866 864 def get_downrx(self):
867 865 """
868 866 This function shows the down-rx-values of one beam
869 867 """
870 868 data = json.loads(self.rx)
871 869 down_data = data['down']
872 870
873 871 down_values = []
874 872 for data in down_data:
875 873 for i in range(0,8):
876 874 down_values.append(data[i])
877 875
878 876 return down_values
General Comments 0
You need to be logged in to leave comments. Login now