##// END OF EJS Templates
radarsys_met
RSS
api jars functions have been modificated: stop, configure, read, status and created: start...
Fiorella Quino -
r210:8db2b04b1bbf
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,1189 +1,1210
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 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 conf_default = {}
80 80 status_default = {}
81 81 default_messages = {}
82 82 for i in range(1,65):
83 83 conf_default[str(i)] = ""
84 84 status_default[str(i)] = 0
85 85 default_messages[str(i)] = "Module "+str(i)
86 86
87 87
88 88 ues_default = json.dumps({
89 89 "up": [0.533333,0.00000,1.06667,0.00000],
90 90 "down": [0.533333,0.00000,1.06667,0.00000]
91 91 })
92 92
93 93 onlyrx_default = json.dumps({
94 94 "up": False,
95 95 "down": False
96 96 })
97 97
98 98 def up_convertion(cadena):
99 99 valores = []
100 100 for c in cadena:
101 101 if c == 1.0: valores=valores+['000']
102 102 if c == 2.0: valores=valores+['001']
103 103 if c == 3.0: valores=valores+['010']
104 104 if c == 0.0: valores=valores+['011']
105 105 if c == 0.5: valores=valores+['100']
106 106 if c == 1.5: valores=valores+['101']
107 107 if c == 2.5: valores=valores+['110']
108 108 if c == 3.5: valores=valores+['111']
109 109
110 110 return valores
111 111
112 112 def up_conv_bits(value):
113 113
114 114 if value == 1.0: bits="000"
115 115 if value == 2.0: bits="001"
116 116 if value == 3.0: bits="010"
117 117 if value == 0.0: bits="011"
118 118 if value == 0.5: bits="100"
119 119 if value == 1.5: bits="101"
120 120 if value == 2.5: bits="110"
121 121 if value == 3.5: bits="111"
122 122
123 123 return bits
124 124
125 125 def down_convertion(cadena):
126 126 valores = []
127 127 for c in cadena:
128 128 if c == 1.0: valores=valores+['000']
129 129 if c == 2.0: valores=valores+['001']
130 130 if c == 3.0: valores=valores+['010']
131 131 if c == 0.0: valores=valores+['011']
132 132 if c == 0.5: valores=valores+['100']
133 133 if c == 1.5: valores=valores+['101']
134 134 if c == 2.5: valores=valores+['110']
135 135 if c == 3.5: valores=valores+['111']
136 136
137 137 return valores
138 138
139 139 def down_conv_bits(value):
140 140
141 141 if value == 1.0: bits="000"
142 142 if value == 2.0: bits="001"
143 143 if value == 3.0: bits="010"
144 144 if value == 0.0: bits="011"
145 145 if value == 0.5: bits="100"
146 146 if value == 1.5: bits="101"
147 147 if value == 2.5: bits="110"
148 148 if value == 3.5: bits="111"
149 149
150 150 return bits
151 151
152 152 def up_conv_value(bits):
153 153
154 154 if bits == "000": value=1.0
155 155 if bits == "001": value=2.0
156 156 if bits == "010": value=3.0
157 157 if bits == "011": value=0.0
158 158 if bits == "100": value=0.5
159 159 if bits == "101": value=1.5
160 160 if bits == "110": value=2.5
161 161 if bits == "111": value=3.5
162 162
163 163 return value
164 164
165 165 def down_conv_value(bits):
166 166
167 167 if bits == "000": value=1.0
168 168 if bits == "001": value=2.0
169 169 if bits == "010": value=3.0
170 170 if bits == "011": value=0.0
171 171 if bits == "100": value=0.5
172 172 if bits == "101": value=1.5
173 173 if bits == "110": value=2.5
174 174 if bits == "111": value=3.5
175 175
176 176 return value
177 177
178 178 def ip2position(module_number):
179 179 j=0
180 180 i=0
181 181 for x in range(0,module_number-1):
182 182 j=j+1
183 183 if j==8:
184 184 i=i+1
185 185 j=0
186 186
187 187 pos = [i,j]
188 188 return pos
189 189
190 190
191 191 def fromBinary2Char(binary_string):
192 192 number = int(binary_string, 2)
193 193 #Plus 33 to avoid more than 1 characters values such as: '\x01'-'\x1f'
194 194 number = number + 33
195 195 char = chr(number)
196 196 return char
197 197
198 198 def fromChar2Binary(char):
199 199 number = ord(char) - 33
200 200 #Minus 33 to get the real value
201 201 bits = bin(number)[2:]
202 202 #To ensure we have a string with 6bits
203 203 if len(bits) < 6:
204 204 bits = bits.zfill(6)
205 205 return bits
206 206
207 207 OPERATION_MODES = (
208 208 (0, 'Manual'),
209 209 (1, 'Automatic'),
210 210 )
211 211
212 212
213 213 class ABSConfiguration(Configuration):
214 214 active_beam = models.CharField(verbose_name='Active Beam', max_length=20000, default="{}")
215 215 module_status = models.CharField(verbose_name='Module Status', max_length=10000, default=json.dumps(status_default))
216 216 operation_mode = models.PositiveSmallIntegerField(verbose_name='Operation Mode', choices=OPERATION_MODES, default = 0)
217 217 operation_value = models.FloatField(verbose_name='Periodic (seconds)', default="10", null=True, blank=True)
218 218 module_messages = models.CharField(verbose_name='Modules Messages', max_length=10000, default=json.dumps(default_messages))
219 219
220 220 class Meta:
221 221 db_table = 'abs_configurations'
222 222
223 223 def get_absolute_url_plot(self):
224 224 return reverse('url_plot_abs_patterns', args=[str(self.id)])
225 225
226 226
227 227 def parms_to_dict(self):
228 228
229 229 parameters = {}
230 230
231 231 parameters['device_id'] = self.device.id
232 232 parameters['name'] = self.name
233 233 parameters['beams'] = {}
234 234
235 235 beams = ABSBeam.objects.filter(abs_conf=self)
236 236 b=1
237 237 for beam in beams:
238 238 #absbeam = ABSBeam.objects.get(pk=beams[beam])
239 239 parameters['beams']['beam'+str(b)] = beam.parms_to_dict()#absbeam.parms_to_dict()
240 240 b+=1
241 241
242 242 return parameters
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 active_beam = json.loads(self.active_beam)
325 325 new_beams = ABSBeam.objects.filter(abs_conf=self)
326 326 active_beam['active_beam'] = new_beams[0].id
327 327
328 328 self.active_beam = json.dumps(active_beam)
329 329 self.save()
330 330 #-----For Active Beam-----
331 331 #-----For Device Status---
332 332 self.device.status = 3
333 333 self.device.save()
334 334 #-----For Device Status---
335 335
336 336 return self
337 337
338 338
339 339 def start_device(self):
340 340
341 341 if self.device.status == 3:
342 342
343 343 try:
344 344 #self.write_device()
345 345 send_task('task_change_beam', [self.id],)
346 346 self.message = 'ABS running'
347 347
348 348 except Exception as e:
349 349 self.message = str(e)
350 350 return False
351 351
352 352 return True
353 353
354 354 else:
355 355 self.message = 'Please, select Write ABS Device first.'
356 356 return False
357 357
358 358
359 359 def stop_device(self):
360 360
361 361 self.device.status = 2
362 362 self.device.save()
363 363 self.message = 'ABS has been stopped.'
364 364 self.save()
365 365
366 366 return True
367 367
368 def moni(self):
369
370 monitoreo_tx = 'JROABSClnt_01CeCnMod000000MNTR10'
371 beam_tx = 'JROABSCeCnModCnMod01000001CHGB10'
372
373 beam_pos = 1
374 module_address = ('192.168.1.63', 5500)
375
376 message_tx = monitoreo_tx
377 # Create the datagram socket
378 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
379 sock.connect(module_address)
380
381 sock.send(message_tx)
382 t = sock.recv(1024)
383 print 'Respuesta: \n',t
384 sock.close()
385 sock = None
386
387 return True
388
368 389
369 390 def module_conf(self, module_num, beams):
370 391 """
371 392 This function creates beam configurations for one abs module.
372 393 """
373 394 ip_address = self.device.ip_address
374 395 ip_address = ip_address.split('.')
375 396 module_seq = (ip_address[0],ip_address[1],ip_address[2])
376 397 dot = '.'
377 398 module_ip = dot.join(module_seq)+'.'+str(module_num)
378 399 module_port = self.device.port_address
379 400 write_route = 'http://'+module_ip+':'+str(module_port)+'/write'
380 401
381 402 #header = 'JROABSCeCnModCnMod01000108SNDFexperimento1.ab1'
382 403 #module = 'ABS_'+str(module_num)
383 404 bs = '' #{}
384 405 i=1
385 406
386 407 for beam in beams:
387 408 #bs[i] = fromBinary2Char(beam.module_6bits(module_num))
388 409 bs = bs + fromBinary2Char(beam.module_6bits(module_num))
389 410 i=i+1
390 411
391 412 beams = bs
392 413
393 414 parameters = {}
394 415 parameters['beams'] = beams #json.dumps(beams)
395 416 print parameters
396 417 answer = ''
397 418
398 419 try:
399 420 #r_write = requests.post(write_route, parameters, timeout=0.5)
400 421 r_write = requests.post(write_route, json = parameters, timeout=0.5)
401 422 answer = r_write.json()
402 423 #self.message = answer['message']
403 424 except:
404 425 #self.message = "Could not write ABS parameters"
405 426 return False
406 427
407 428 return answer
408 429
409 430
410 431
411 432 def write_device(self):
412 433
413 434 """
414 435 This function sends the beams list to every abs module.
415 436 It needs 'module_conf' function
416 437 """
417 438
418 439 beams = ABSBeam.objects.filter(abs_conf=self)
419 440 connected_modules = ast.literal_eval(self.module_status)
420 441 suma_connected_modules = 0
421 442
422 443 for c in connected_modules:
423 444 suma_connected_modules = suma_connected_modules+connected_modules[c]
424 445 if not suma_connected_modules > 0 :
425 446 self.message = "No ABS Module detected."
426 447 return False
427 448
428 449 #-------------Write each abs module-----------
429 450 if beams:
430 451 beams_status = ast.literal_eval(self.module_status)
431 452 disconnected_modules = 0
432 453 for i in range(1,65): #(62,65)
433 454 #--------------JUEVES-------------
434 455 if beams_status[str(i)] != 0:
435 456 try:
436 457 answer = self.module_conf(i,beams)
437 458 if answer:
438 459 if answer['status']:
439 460 beams_status[str(i)] = 3
440 461
441 462 except:
442 463 beams_status[str(i)] = 1
443 464
444 465 pass
445 466 else:
446 467 disconnected_modules += 1
447 468
448 469 else:
449 470 self.message = "ABS Configuration does not have beams"
450 471 return False
451 472
452 473 #self.device.status = 1
453 474 ##
454 475 #-------------Jueves-------------
455 476 if disconnected_modules == 64:
456 477 self.message = "Could not write ABS Modules"
457 478 self.device.status = 0
458 479 return False
459 480 else:
460 481 self.message = "ABS Beams List have been sent to ABS Modules"
461 482 beams[0].set_as_activebeam()
462 483
463 484 self.device.status = 3
464 485 self.module_status = json.dumps(beams_status)
465 486
466 487
467 488
468 489 self.save()
469 490 return True
470 491
471 492
472 493
473 494
474 495 def read_module(self, module):
475 496
476 497 """
477 498 Read out-bits (up-down) of 1 abs module NOT for Configuration
478 499 """
479 500
480 501 ip_address = self.device.ip_address
481 502 ip_address = ip_address.split('.')
482 503 module_seq = (ip_address[0],ip_address[1],ip_address[2])
483 504 dot = '.'
484 505 module_ip = dot.join(module_seq)+'.'+str(module)
485 506 module_port = self.device.port_address
486 507 read_route = 'http://'+module_ip+':'+str(module_port)+'/read'
487 508
488 509 module_status = json.loads(self.module_status)
489 510 print(read_route)
490 511
491 512 module_bits = ''
492 513
493 514 try:
494 515 r_read = requests.get(read_route, timeout=0.5)
495 516 answer = r_read.json()
496 517 module_bits = answer['allbits']
497 518 except:
498 519 return {}
499 520
500 521 return module_bits
501 522
502 523 def read_device(self):
503 524
504 525 parms = {}
505 526 # Reads active modules.
506 527 module_status = json.loads(self.module_status)
507 528 total = 0
508 529 for status in module_status:
509 530 if module_status[status] != 0:
510 531 module_bits = self.read_module(int(status))
511 532 bits={}
512 533 if module_bits:
513 534 bits = (str(module_bits['um2']) + str(module_bits['um1']) + str(module_bits['um0']) +
514 535 str(module_bits['dm2']) + str(module_bits['dm1']) + str(module_bits['dm0']) )
515 536 parms[str(status)] = bits
516 537
517 538 total +=1
518 539
519 540 if total==0:
520 541 self.message = "No ABS Module detected. Please select 'Status'."
521 542 return False
522 543
523 544
524 545
525 546 self.message = "ABS Modules have been read"
526 547 #monitoreo_tx = JROABSClnt_01CeCnMod000000MNTR10
527 548 return parms
528 549
529 550
530 551 def absmodule_status(self):
531 552 """
532 553 This function gets the status of each abs module. It sends GET method to Web Application
533 554 in Python Bottle.
534 555 This function updates "module_status" field from ABSconfiguration.
535 556 """
536 557 ip_address = self.device.ip_address
537 558 ip_address = ip_address.split('.')
538 559 module_seq = (ip_address[0],ip_address[1],ip_address[2])
539 560 dot = '.'
540 561 module_port = self.device.port_address
541 562
542 563 modules_status = json.loads(self.module_status)
543 564 module_messages = json.loads(self.module_messages)
544 565
545 566 for i in range(1,65):
546 567 module_ip = dot.join(module_seq)+'.'+str(i)
547 568 print module_ip
548 569
549 570 route = 'http://'+module_ip+':'+str(module_port)+'/status'
550 571
551 572 try:
552 573 r = requests.get(route, timeout=0.5)#, timeout=0.7)
553 574 answer = r.json()
554 575 modules_status[str(i)] = answer['status']
555 576 module_messages[str(i)] = answer['message']
556 577 except:
557 578 modules_status[str(i)] = 0
558 579 pass
559 580
560 581
561 582 self.module_status = json.dumps(modules_status)
562 583 self.module_messages = json.dumps(module_messages)
563 584 self.save()
564 585
565 586 return
566 587
567 588
568 589 def connected_modules(self):
569 590 """
570 591 This function returns the number of connected abs-modules without updating.
571 592 """
572 593 modules_status = json.loads(self.module_status)
573 594 num = 0
574 595 for status in modules_status:
575 596 if modules_status[status] != 0:
576 597 num += 1
577 598
578 599 return num
579 600
580 601
581 602 def status_device(self):
582 603 """
583 604 This function returns the status of all abs-modules as one.
584 605 If at least one module is connected, its answer is "1"
585 606 """
586 607 self.absmodule_status()
587 608 connected_modules = self.connected_modules()
588 609 if connected_modules>0:
589 610 self.message = 'ABS modules Status have been updated.'
590 611 return 1
591 612 self.message = 'No ABS module is connected.'
592 613 return 0
593 614
594 615
595 616
596 617 def write_module(self, module):
597 618
598 619 """
599 620 Send configuration to one abs module
600 621 """
601 622
602 623 parameters = {}
603 624 ip_address = self.abs_conf.device.ip_address
604 625 ip_address = ip_address.split('.')
605 626 module_seq = (ip_address[0],ip_address[1],ip_address[2])
606 627 dot = '.'
607 628 module_ip = dot.join(module_seq)+'.'+str(module)
608 629 module_port = self.abs_conf.device.port_address
609 630 write_route = 'http://'+module_ip+':'+str(module_port)+'/write'
610 631
611 632 #print write_route
612 633
613 634 #header = 'JROABSCeCnModCnMod01000108SNDFexperimento1.ab1'
614 635 #module = 'ABS_'+str(module)
615 636 beams = '!`*3<ENW'#{1: '001000', 2: '010001', 3: '010010', 4: '000011', 5: '101100', 6: '101101',
616 637 # 7: '110110', 8: '111111', 9: '000000', 10: '001001', 11: '010010', 12: '011011'}
617 638
618 639 #parameters['header'] = header
619 640 parameters['module'] = module
620 641 parameters['beams'] = json.dumps(beams)
621 642
622 643 answer = ''
623 644
624 645 try:
625 646 r_write = requests.post(write_route, parameters, timeout=0.5)
626 647 answer = r_write.json()
627 648 self.message = answer['message']
628 649 except:
629 650 self.message = "Could not write ABS parameters"
630 651 return 0
631 652
632 653
633 654 #self.device.status = int(answer['status'])
634 655
635 656 return 1
636 657
637 658
638 659 def beam_selector(self, module, beam_pos):
639 660 """
640 661 This function selects the beam number for one absmodule.
641 662 """
642 663
643 664 if beam_pos > 0:
644 665 beam_pos = beam_pos - 1
645 666 else:
646 667 beam_pos = 0
647 668
648 669 #El indice del apunte debe ser menor que el numero total de apuntes
649 670 #El servidor tcp en el embebido comienza a contar desde 0
650 671 beams_list = ABSBeam.objects.filter(abs_conf=self)
651 672 if len(beams_list) < beam_pos:
652 673 return 0
653 674
654 675 flag = 1
655 676 if beam_pos>9:
656 677 flag = 2
657 678
658 679 module_address = ('192.168.1.'+str(module), 5500)
659 680 header = 'JROABSCeCnModCnMod0100000'
660 681 numbers = len(str(beam_pos))
661 682 function = 'CHGB'
662 683
663 684 message_tx = header+str(numbers)+function+str(beam_pos)+'0'
664 685
665 686 # Create the datagram socket
666 687 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
667 688 #sock.connect(module_address)
668 689 try:
669 690 sock.connect(module_address)
670 691 sock.send(message_tx)
671 692 sock.close()
672 693 print("Writing abs module:"+module_address[0]+"...")
673 694 except:
674 695 sock = None
675 696 print("Problem writing abs module:"+module_address[0])
676 697 return 0
677 698
678 699 return 1
679 700
680 701
681 702 def change_beam(self, beam_pos):
682 703 """
683 704 This function selects the beam number for all absmodules.
684 705 """
685 706 for i in range(1,65):
686 707 try:
687 708 self.beam_selector(i,beam_pos)
688 709 except:
689 710 print("Problem with module: 192.168.1."+str(i))
690 711 self.message = "Problem with module: 192.168.1."+str(i)
691 712 #return 0
692 713 return 1
693 714
694 715
695 716 def send_beam_num(self, beam_pos):
696 717 """
697 718 This function connects to a multicast group and sends the beam number
698 719 to all abs modules.
699 720 """
700 721
701 722 if beam_pos > 0:
702 723 beam_pos = beam_pos - 1
703 724 else:
704 725 beam_pos = 0
705 726
706 727 #El indice del apunte debe ser menor que el numero total de apuntes
707 728 #El servidor tcp en el embebido comienza a contar desde 0
708 729 beams_list = ABSBeam.objects.filter(abs_conf=self)
709 730 if len(beams_list) < beam_pos:
710 731 return 0
711 732
712 733 flag = 1
713 734 if beam_pos>9:
714 735 flag = 2
715 736
716 737 header = 'JROABSCeCnModCnMod0100000'
717 738 flag = str(flag)
718 739 function = 'CHGB'
719 740 message_tx = header+flag+function+str(beam_pos)+'0'
720 741
721 742 multicast_group = '224.3.29.71'
722 743 server_address = ('',10000)
723 744
724 745 # Create the socket
725 746 sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
726 747 # Bind to the server address
727 748 sock.bind(server_address)
728 749 # Telling the OS add the socket to the multicast on all interfaces
729 750 group = socket.inet_aton(multicast_group)
730 751 mreq = struct.pack('4sL', group, socket.INADDR_ANY)
731 752 sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
732 753
733 754 #print 'sending acknowledgement to all: \n' + message_tx
734 755 sock.sendto(message_tx, (multicast_group, 10000))
735 756 sock.close()
736 757 sock = None
737 758
738 759 return 1
739 760
740 761 def test1(self):
741 762 t1 = time.time()
742 763 t2 = 0
743 764 while (t2-t1)<100:#300
744 765 t2 = time.time()
745 766 self.send_beam_num(2)
746 767 time.sleep(0.04)
747 768 self.send_beam_num(1)
748 769 time.sleep(0.04)
749 770 return
750 771
751 772 def change_procs_test1(self, module):
752 773
753 774 for i in range (1,300):#300
754 775 beam_pos = 1
755 776 module_address = ('192.168.1.'+str(module), 5500)
756 777 header = 'JROABSCeCnModCnMod0100000'
757 778 numbers = len(str(beam_pos))
758 779 function = 'CHGB'
759 780
760 781 message_tx = header+str(numbers)+function+str(beam_pos)+'0'
761 782
762 783 # Create the datagram socket
763 784 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
764 785 sock.connect(module_address)
765 786
766 787 sock.send(message_tx)
767 788 #t = sock.recv(1024)
768 789 sock.close()
769 790 sock = None
770 791
771 792
772 793 time.sleep(0.04)
773 794
774 795
775 796 beam_pos = 0
776 797 numbers = len(str(beam_pos))
777 798
778 799 message_tx = header+str(numbers)+function+str(beam_pos)+'0'
779 800
780 801 # Create the datagram socket
781 802 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
782 803 sock.connect(module_address)
783 804 sock.send(message_tx)
784 805 sock.close()
785 806 sock = None
786 807
787 808 time.sleep(0.04)
788 809
789 810
790 811 def multi_procs_test1(self):
791 812
792 813 """
793 814 This function sends the beam number to all abs modules using multiprocessing.
794 815 """
795 816
796 817 #if __name__ == "__main__":
797 818 size = 10000000 # Number of random numbers to add
798 819 procs = 65 # (Number-1) of processes to create (absmodule)
799 820
800 821 # Create a list of jobs and then iterate through
801 822 # the number of processes appending each process to
802 823 # the job list
803 824 jobs = []
804 825 for i in range(1, procs):
805 826
806 827 process = multiprocessing.Process(target=self.change_procs_test1,args=(i,))
807 828 jobs.append(process)
808 829 #print jobs
809 830
810 831 # Start the processes (i.e. calculate the random number lists)
811 832 for j in jobs:
812 833 #time.sleep(0.4)
813 834 #print j
814 835 j.start()
815 836
816 837 # Ensure all of the processes have finished
817 838 for j in jobs:
818 839 j.join()
819 840
820 841 print("List processing complete.")
821 842 return 1
822 843
823 844
824 845
825 846 def multi_procs_test2(self):
826 847 """
827 848 This function use multiprocessing python library. Importing Pool we can select
828 849 the number of cores we want to use
829 850 After 'nproc' linux command, we know how many cores computer has.
830 851 NOT WORKING
831 852 """
832 853 import multiprocessing
833 854 pool = multiprocessing.Pool(3) # cores
834 855
835 856 tasks = []
836 857 procs = 65
837 858 for i in range(62, procs):
838 859 tasks.append( (i,))
839 860 #print tasks
840 861 #pool.apply_async(self.change_procs_test1, 62)
841 862 results = [pool.apply( self.change_procs_test1, t ) for t in tasks]
842 863 #for result in results:
843 864 #result.get()
844 865 #(plotNum, plotFilename) = result.get()
845 866 #print("Result: plot %d written to %s" % (plotNum, plotFilename) )
846 867
847 868 return 1
848 869
849 870
850 871 def multi_procs_test3(self):
851 872 """
852 873 This function use multiprocessing python library. Importing Pool we can select
853 874 the number of cores we want to use
854 875 After 'nproc' linux command, we know how many cores computer has.
855 876 """
856 877 from multiprocessing import Pool
857 878 import time
858 879
859 880 def f(x):
860 881 return x*x
861 882
862 883 tasks = []
863 884 procs = 65
864 885 pool = Pool(processes=4)
865 886
866 887 #for i in range(62, procs):
867 888 #result = pool.map(f, range(62,65))
868 889 it = pool.imap(self.change_procs_test1, range(62,65))
869 890 #result.get(timeout=5)
870 891
871 892 return 1
872 893
873 894
874 895 def f(x):
875 896 print x
876 897 return
877 898
878 899 def multi_procs_test4(self):
879 900 import multiprocessing as mp
880 901
881 902
882 903 num_workers = mp.cpu_count()
883 904
884 905 pool = mp.Pool(num_workers)
885 906 procs = 65
886 907 for i in range(62, procs):
887 908 #for task in tasks:
888 909 pool.apply_async(self.f, args = (i,))
889 910
890 911 pool.close()
891 912 pool.join()
892 913
893 914 return 1
894 915
895 916
896 917 def get_absolute_url_import(self):
897 918 return reverse('url_import_abs_conf', args=[str(self.id)])
898 919
899 920
900 921
901 922
902 923 class ABSBeam(models.Model):
903 924
904 925 name = models.CharField(max_length=60, default='Beam')
905 926 antenna = models.CharField(verbose_name='Antenna', max_length=1000, default=antenna_default)
906 927 abs_conf = models.ForeignKey(ABSConfiguration, null=True, verbose_name='ABS Configuration')
907 928 tx = models.CharField(verbose_name='Tx', max_length=1000, default=tx_default)
908 929 rx = models.CharField(verbose_name='Rx', max_length=1000, default=rx_default)
909 930 s_time = models.TimeField(verbose_name='Star Time', default='00:00:00')
910 931 e_time = models.TimeField(verbose_name='End Time', default='23:59:59')
911 932 modules_conf = models.CharField(verbose_name='Modules', max_length=2000, default=json.dumps(conf_default))
912 933 ues = models.CharField(verbose_name='Ues', max_length=100, default=ues_default)
913 934 only_rx = models.CharField(verbose_name='Only RX', max_length=40, default=onlyrx_default)
914 935
915 936 class Meta:
916 937 db_table = 'abs_beams'
917 938
918 939 def __unicode__(self):
919 940 return u'%s' % (self.name)
920 941
921 942 def parms_to_dict(self):
922 943
923 944 #Update data
924 945 self.modules_6bits()
925 946
926 947 parameters = {}
927 948
928 949 parameters['name'] = self.name
929 950 parameters['antenna'] = ast.literal_eval(self.antenna)
930 951 parameters['abs_conf'] = self.abs_conf.name
931 952 parameters['tx'] = ast.literal_eval(self.tx)
932 953 parameters['rx'] = ast.literal_eval(self.rx)
933 954 parameters['s_time'] = self.s_time.strftime("%H:%M:%S")
934 955 parameters['e_time'] = self.e_time.strftime("%H:%M:%S")
935 956 parameters['configuration'] = ast.literal_eval(self.modules_conf)
936 957 parameters['ues'] = ast.literal_eval(self.ues)
937 958 parameters['only_rx'] = json.loads(self.only_rx)
938 959
939 960 return parameters
940 961
941 962 def dict_to_parms(self, parameters):
942 963
943 964 self.name = parameters['name']
944 965 self.antenna = json.dumps(parameters['antenna'])
945 966 #self.abs_conf = parameters['abs_conf']
946 967 self.tx = json.dumps(parameters['tx'])
947 968 self.rx = json.dumps(parameters['rx'])
948 969 #self.s_time = parameters['s_time']
949 970 #self.e_time = parameters['e_time']
950 971 self.ues = json.dumps(parameters['ues'])
951 972 self.only_rx = json.dumps(parameters['only_rx'])
952 973
953 974 self.modules_6bits()
954 975 self.save()
955 976
956 977
957 978 def clone(self, **kwargs):
958 979
959 980 self.pk = None
960 981 self.id = None
961 982 for attr, value in kwargs.items():
962 983 setattr(self, attr, value)
963 984
964 985 self.save()
965 986
966 987 return self
967 988
968 989
969 990
970 991 def module_6bits(self, module):
971 992 """
972 993 This function reads antenna pattern and choose 6bits (upbits-downbits) for one abs module
973 994 """
974 995 if module > 64:
975 996 beam_bits = ""
976 997 return beam_bits
977 998
978 999 data = ast.literal_eval(self.antenna)
979 1000 up_data = data['antenna_up']
980 1001 down_data = data['antenna_down']
981 1002
982 1003 pos = ip2position(module)
983 1004 up_value = up_data[pos[0]][pos[1]]
984 1005 down_value = down_data[pos[0]][pos[1]]
985 1006
986 1007 up_bits = up_conv_bits(up_value)
987 1008 down_bits = down_conv_bits(down_value)
988 1009 beam_bits = up_bits+down_bits
989 1010
990 1011 return beam_bits
991 1012
992 1013 def modules_6bits(self):
993 1014 """
994 1015 This function returns 6bits from every abs module (1-64) in a dict
995 1016 """
996 1017 modules_configuration = ast.literal_eval(self.modules_conf)
997 1018
998 1019 for i in range(1,65):
999 1020 modules_configuration[str(i)] = self.module_6bits(i)
1000 1021
1001 1022 self.modules_conf = json.dumps(modules_configuration)
1002 1023 self.save()
1003 1024
1004 1025 return self.modules_conf
1005 1026
1006 1027
1007 1028 def set_as_activebeam(self):
1008 1029 """
1009 1030 This function set this beam as the active beam of its ABS Configuration.
1010 1031 """
1011 1032 self.abs_conf.active_beam = json.dumps({'active_beam': self.id})
1012 1033 self.abs_conf.save()
1013 1034
1014 1035 return
1015 1036
1016 1037
1017 1038 @property
1018 1039 def get_upvalues(self):
1019 1040 """
1020 1041 This function reads antenna pattern and show the up-value of one abs module
1021 1042 """
1022 1043
1023 1044 data = ast.literal_eval(self.antenna)
1024 1045 up_data = data['antenna_up']
1025 1046
1026 1047 up_values = []
1027 1048 for data in up_data:
1028 1049 for i in range(0,8):
1029 1050 up_values.append(data[i])
1030 1051
1031 1052 return up_values
1032 1053
1033 1054 @property
1034 1055 def antenna_upvalues(self):
1035 1056 """
1036 1057 This function reads antenna pattern and show the up - values of one abs beam
1037 1058 in a particular order
1038 1059 """
1039 1060 data = ast.literal_eval(self.antenna)
1040 1061 up_data = data['antenna_up']
1041 1062
1042 1063 return up_data
1043 1064
1044 1065 @property
1045 1066 def antenna_downvalues(self):
1046 1067 """
1047 1068 This function reads antenna pattern and show the down - values of one abs beam
1048 1069 in a particular order
1049 1070 """
1050 1071 data = ast.literal_eval(self.antenna)
1051 1072 down_data = data['antenna_down']
1052 1073
1053 1074 return down_data
1054 1075
1055 1076 @property
1056 1077 def get_downvalues(self):
1057 1078 """
1058 1079 This function reads antenna pattern and show the down-value of one abs module
1059 1080 """
1060 1081
1061 1082 data = ast.literal_eval(self.antenna)
1062 1083 down_data = data['antenna_down']
1063 1084
1064 1085 down_values = []
1065 1086 for data in down_data:
1066 1087 for i in range(0,8):
1067 1088 down_values.append(data[i])
1068 1089
1069 1090 return down_values
1070 1091
1071 1092 @property
1072 1093 def get_up_ues(self):
1073 1094 """
1074 1095 This function shows the up-ues-value of one beam
1075 1096 """
1076 1097 data = ast.literal_eval(self.ues)
1077 1098 up_ues = data['up']
1078 1099
1079 1100 return up_ues
1080 1101
1081 1102 @property
1082 1103 def get_down_ues(self):
1083 1104 """
1084 1105 This function shows the down-ues-value of one beam
1085 1106 """
1086 1107 data = ast.literal_eval(self.ues)
1087 1108 down_ues = data['down']
1088 1109
1089 1110 return down_ues
1090 1111
1091 1112 @property
1092 1113 def get_up_onlyrx(self):
1093 1114 """
1094 1115 This function shows the up-onlyrx-value of one beam
1095 1116 """
1096 1117 data = json.loads(self.only_rx)
1097 1118 up_onlyrx = data['up']
1098 1119
1099 1120 return up_onlyrx
1100 1121
1101 1122 @property
1102 1123 def get_down_onlyrx(self):
1103 1124 """
1104 1125 This function shows the down-onlyrx-value of one beam
1105 1126 """
1106 1127 data = json.loads(self.only_rx)
1107 1128 down_onlyrx = data['down']
1108 1129
1109 1130 return down_onlyrx
1110 1131
1111 1132 @property
1112 1133 def get_tx(self):
1113 1134 """
1114 1135 This function shows the tx-values of one beam
1115 1136 """
1116 1137 data = json.loads(self.tx)
1117 1138
1118 1139 return data
1119 1140
1120 1141 @property
1121 1142 def get_uptx(self):
1122 1143 """
1123 1144 This function shows the up-tx-values of one beam
1124 1145 """
1125 1146 data = json.loads(self.tx)
1126 1147 up_data = data['up']
1127 1148
1128 1149 up_values = []
1129 1150 for data in up_data:
1130 1151 for i in range(0,8):
1131 1152 up_values.append(data[i])
1132 1153
1133 1154 return up_values
1134 1155
1135 1156 @property
1136 1157 def get_downtx(self):
1137 1158 """
1138 1159 This function shows the down-tx-values of one beam
1139 1160 """
1140 1161 data = json.loads(self.tx)
1141 1162 down_data = data['down']
1142 1163
1143 1164 down_values = []
1144 1165 for data in down_data:
1145 1166 for i in range(0,8):
1146 1167 down_values.append(data[i])
1147 1168
1148 1169 return down_values
1149 1170
1150 1171
1151 1172
1152 1173 @property
1153 1174 def get_rx(self):
1154 1175 """
1155 1176 This function shows the rx-values of one beam
1156 1177 """
1157 1178 data = json.loads(self.rx)
1158 1179
1159 1180 return data
1160 1181
1161 1182 @property
1162 1183 def get_uprx(self):
1163 1184 """
1164 1185 This function shows the up-rx-values of one beam
1165 1186 """
1166 1187 data = json.loads(self.rx)
1167 1188 up_data = data['up']
1168 1189
1169 1190 up_values = []
1170 1191 for data in up_data:
1171 1192 for i in range(0,8):
1172 1193 up_values.append(data[i])
1173 1194
1174 1195 return up_values
1175 1196
1176 1197 @property
1177 1198 def get_downrx(self):
1178 1199 """
1179 1200 This function shows the down-rx-values of one beam
1180 1201 """
1181 1202 data = json.loads(self.rx)
1182 1203 down_data = data['down']
1183 1204
1184 1205 down_values = []
1185 1206 for data in down_data:
1186 1207 for i in range(0,8):
1187 1208 down_values.append(data[i])
1188 1209
1189 1210 return down_values
Show file before | Show file after | Hide comments
@@ -1,113 +1,122
1 1 '''
2 2 Created on Nov 25, 2015
3 3
4 4 @author: Miguel Urco
5 5
6 6 eth_device decorator is used to implement an api to ethernet devices.
7 7 When eth_device decorator is used it adds two parameters to any function (ip and port)
8 8
9 9 #Definition of a function using eth_device decorator
10 10
11 11 @eth_device(ID_CLASS)
12 12 def enable_acq(message)
13 13 cmd = "xxxxx"
14 14 payload = message
15 15
16 16 return cmd, payload
17 17
18 18 #How to call this function:
19 19 answer = enable_acq(ip, port, message)
20 20
21 21 '''
22 22 import sys
23 23 import struct
24 24 import json
25 25
26 26 from devices.jro_device import eth_device, IdClass
27 27
28 28 ID_CLASS = IdClass["jars"]
29 29
30 30 CMD_RESET = 0X01
31 31 CMD_CHANGEIP = 0X03
32 32 #Add other commands
33 33 CMD_CONFIGURE = 0X10
34 34 CMD_STATUS = 0X11
35 35 CMD_SET_EXEPATH = 0X12
36 36 CMD_ECHO = 0XFE
37 37 CMD_READ = 0X08
38 38 CMD_STOP = 0X09
39 CMD_START = 0x05
39 40
40 41 @eth_device(ID_CLASS)
41 42 def reset():
42 43
43 44 cmd = CMD_RESET
44 45 payload = ''
45 46
46 47 return cmd, payload
47 48
48 49 @eth_device(ID_CLASS)
50 def start():
51
52 cmd = CMD_START
53 payload = ''
54
55 return cmd, payload
56
57 @eth_device(ID_CLASS)
49 58 def stop():
50 59
51 60 cmd = CMD_STOP
52 61 payload = ''
53 62
54 63 return cmd, payload
55 64
56 65 @eth_device(ID_CLASS)
57 66 def echo(message):
58 67
59 68 cmd = CMD_ECHO
60 69 payload = message
61 70
62 71 return cmd, payload
63 72
64 73 @eth_device(ID_CLASS)
65 74 def configure(conf):
66 75
67 76 cmd = CMD_CONFIGURE
68 77 payload = conf
69 78
70 79 return cmd, payload
71 80
72 81 @eth_device(ID_CLASS)
73 82 def status():
74 83
75 84 cmd = CMD_STATUS
76 85 payload = ''
77 86
78 87 return cmd, payload
79 88
80 89 @eth_device(ID_CLASS)
81 90 def read():
82 91
83 92 cmd = CMD_READ
84 93 payload = ''
85 94
86 95 return cmd, payload
87 96
88 97 @eth_device(ID_CLASS)
89 98 def set_exepath(path):
90 99
91 100 cmd = CMD_SET_EXEPATH
92 101 payload = path
93 102
94 103 return cmd, payload
95 104
96 105 #--To take .json file from computer:
97 106 #with open('/home/fquino/Downloads/Experiment.json') as data_file:
98 107 # data = json.load(data_file)
99 108
100 109 # data['configurations']['dds']=''
101 110 # data['configurations']['rc']['pulses']=''
102 111 # data['configurations']['rc']['delays']=''
103
112
104 113 #data = json.dumps(data)
105 114 #-----------------------------------
106 115
107 116 #print reset('10.10.10.100', 10000)
108 117 #print echo('10.10.10.95', 10000, 'Hola JARS :)')
109 118
110 119 #json_data = json.dumps({'name':'archivo1','variable':9})
111 120 #print configure('10.10.10.95', 10000, data)
112 121 #print configure('10.10.10.100', 10000, '')
113 122 #print status('10.10.10.100', 10000)
General Comments 0
You need to be logged in to leave comments. Login now