models.py
290 lines
| 9.2 KiB
| text/x-python
|
PythonLexer
|
r45 | import ast | |
|
r25 | import json | |
|
r175 | import requests | |
|
r45 | import numpy as np | |
r345 | import base64 | ||
r346 | import struct | ||
|
r185 | from struct import pack | |
r346 | import time | ||
from django.contrib import messages | |||
|
r0 | from django.db import models | |
r335 | from django.urls import reverse | ||
|
r23 | from django.core.validators import MinValueValidator, MaxValueValidator | |
|
r6 | from apps.main.models import Configuration | |
|
r79 | ||
r345 | AXIS_VALUE = ( | ||
('AZI', 'azimuth'), | |||
('ELE', 'elevation') | |||
) | |||
|
r6 | ||
r346 | class PedestalConfiguration(Configuration): | ||
|
r172 | ||
r345 | axis = models.CharField( | ||
verbose_name='Axis', | |||
max_length=3, | |||
choices=AXIS_VALUE, | |||
null=False, | |||
blank=False | |||
) | |||
speed = models.FloatField( | |||
verbose_name='Speed', | |||
validators=[MinValueValidator(-20), MaxValueValidator(20)], | |||
blank=False, | |||
null=False | |||
) | |||
table = models.CharField( | |||
verbose_name="Table", | |||
max_length=100, | |||
default='', | |||
blank=False, | |||
null=False | |||
) | |||
|
r6 | ||
class Meta: | |||
r345 | db_table = 'pedestal_configurations' | ||
def __str__(self): | |||
return self.label | |||
|
r172 | ||
|
r79 | def get_absolute_url_plot(self): | |
r345 | return reverse('url_plot_pedestal_pulses', args=[str(self.id)]) | ||
|
r172 | ||
|
r264 | def request(self, cmd, method='get', **kwargs): | |
req = getattr(requests, method)(self.device.url(cmd), **kwargs) | |||
payload = req.json() | |||
return payload | |||
|
r175 | def status_device(self): | |
|
r172 | ||
|
r222 | try: | |
self.device.status = 0 | |||
|
r264 | payload = self.request('status') | |
if payload['status']=='enable': | |||
|
r236 | self.device.status = 3 | |
|
r264 | elif payload['status']=='disable': | |
|
r222 | self.device.status = 2 | |
|
r185 | else: | |
|
r243 | self.device.status = 1 | |
|
r222 | self.device.save() | |
r346 | self.message = 'Pedestal status: {}'.format(payload['status']) | ||
|
r222 | return False | |
|
r185 | except Exception as e: | |
|
r222 | if 'No route to host' not in str(e): | |
self.device.status = 4 | |||
self.device.save() | |||
r346 | self.message = 'Pedestal status: {}'.format(str(e)) | ||
|
r185 | return False | |
|
r243 | ||
self.device.save() | |||
return True | |||
|
r175 | ||
def reset_device(self): | |||
|
r243 | ||
|
r185 | try: | |
|
r264 | payload = self.request('reset', 'post') | |
|
r222 | if payload['reset']=='ok': | |
r346 | self.message = 'Pedestal restarted OK' | ||
|
r264 | self.device.status = 2 | |
self.device.save() | |||
|
r185 | else: | |
r346 | self.message = 'Pedestal restart fail' | ||
|
r185 | self.device.status = 4 | |
self.device.save() | |||
except Exception as e: | |||
r346 | self.message = 'Pedestal reset: {}'.format(str(e)) | ||
|
r185 | return False | |
|
r243 | ||
|
r185 | return True | |
|
r243 | ||
|
r175 | def stop_device(self): | |
|
r172 | ||
|
r185 | try: | |
r346 | command = self.device.url() + "stop" | ||
r = requests.get(command) | |||
if r: | |||
self.device.status = 4 | |||
|
r185 | self.device.save() | |
r346 | self.message = 'Pedestal stopped' | ||
|
r185 | else: | |
self.device.status = 4 | |||
self.device.save() | |||
return False | |||
except Exception as e: | |||
|
r222 | if 'No route to host' not in str(e): | |
self.device.status = 4 | |||
else: | |||
self.device.status = 0 | |||
r346 | self.message = 'Pedestal stop: {}'.format(str(e)) | ||
|
r222 | self.device.save() | |
|
r243 | return False | |
|
r185 | return True | |
|
r172 | ||
|
r107 | def start_device(self): | |
r345 | print("Entró al start") | ||
|
r185 | try: | |
r346 | pedestal = PedestalConfiguration.objects.get(pk=self) | ||
r345 | pedestal_axis = pedestal.get_axis_display() | ||
print(pedestal) | |||
print(pedestal_axis) | |||
table = pedestal.table | |||
print(table) | |||
r346 | li = list(table.split(", ")) | ||
print(li) | |||
list_of_floats = [] | |||
for item in li: | |||
list_of_floats.append(float(item)) | |||
print(list_of_floats) | |||
byte_table = [] | |||
for x in list_of_floats: | |||
temp = bytearray(struct.pack("f", x)) | |||
byte_table.append(temp[3]) | |||
byte_table.append(temp[2]) | |||
byte_table.append(temp[1]) | |||
byte_table.append(temp[0]) | |||
print(byte_table) | |||
coded_table = base64.urlsafe_b64encode(bytes(byte_table)) | |||
coded_table_ascii = coded_table.decode('ascii') | |||
print(coded_table_ascii) | |||
data = {'axis': pedestal_axis, 'speed': pedestal.speed, 'table': coded_table_ascii} | |||
r345 | print(data) | ||
r346 | json_data = json.dumps(data) | ||
print(json_data) | |||
first_position = table[0] | |||
if pedestal.axis=='azimuth': | |||
json_az = json.dumps({"axis": 'azimuth', "position": 0.0}) | |||
json_el = json.dumps({"axis": 'elevation', "position": first_position}) | |||
else: | |||
json_az = json.dumps({"axis": 'azimuth', "position": first_position}) | |||
json_el = json.dumps({"axis": 'elevation', "position": 0.0}) | |||
base64_table = base64.urlsafe_b64encode(json_data.encode('ascii')) | |||
base64_az = base64.urlsafe_b64encode(json_az.encode('ascii')) | |||
base64_el = base64.urlsafe_b64encode(json_el.encode('ascii')) | |||
table_url = self.device.url() + "table?params=" | |||
az_url = self.device.url() + "position?params=" | |||
el_url = self.device.url() + "position?params=" | |||
complete_url = table_url + base64_table.decode('ascii') | |||
az_url = az_url + base64_az.decode('ascii') | |||
el_url = el_url + base64_el.decode('ascii') | |||
print(complete_url) | |||
print(az_url) | |||
print(el_url) | |||
r = requests.get(az_url) | |||
r = requests.get(el_url) | |||
#time.sleep(10) | |||
r = requests.get(complete_url) | |||
if r: | |||
|
r185 | self.device.status = 3 | |
self.device.save() | |||
r346 | self.message = 'Pedestal configured and started' | ||
|
r185 | else: | |
return False | |||
except Exception as e: | |||
|
r222 | if 'No route to host' not in str(e): | |
self.device.status = 4 | |||
else: | |||
self.device.status = 0 | |||
r346 | self.message = 'Pedestal start: {}'.format(str(e)) | ||
|
r222 | self.device.save() | |
|
r185 | return False | |
|
r243 | ||
|
r185 | return True | |
|
r172 | ||
r346 | #def write_device(self, raw=False): | ||
r299 | |||
|
r328 | if not raw: | |
clock = RCClock.objects.get(rc_configuration=self) | |||
r345 | print(clock) | ||
|
r328 | 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)) | |||
r345 | print(payload) | ||
r335 | if payload['command'] != 'ok': | ||
r346 | self.message = 'Pedestal write: {}'.format(payload['command']) | ||
|
r328 | else: | |
self.message = payload['programming'] | |||
if payload['programming'] == 'fail': | |||
r346 | self.message = 'Pedestal write: error programming CGS chip' | ||
|
r328 | ||
r299 | values = [] | ||
for pulse, delay in zip(self.get_pulses(), self.get_delays()): | |||
r302 | while delay>65536: | ||
r299 | values.append((pulse, 65535)) | ||
r302 | delay -= 65536 | ||
r299 | values.append((pulse, delay-1)) | ||
|
r236 | data = bytearray() | |
|
r243 | #reset | |
data.extend((128, 0)) | |||
#disable | |||
|
r236 | data.extend((129, 0)) | |
r304 | #SW switch | ||
if self.control_sw: | |||
data.extend((130, 2)) | |||
else: | |||
data.extend((130, 0)) | |||
|
r243 | #divider | |
data.extend((131, self.clock_divider-1)) | |||
|
r236 | #enable writing | |
data.extend((139, 62)) | |||
|
r243 | ||
|
r236 | last = 0 | |
|
r243 | for tup in values: | |
vals = pack('<HH', last^tup[0], tup[1]) | |||
|
r236 | last = tup[0] | |
|
r243 | data.extend((133, vals[1], 132, vals[0], 133, vals[3], 132, vals[2])) | |
|
r236 | #enable | |
data.extend((129, 1)) | |||
|
r243 | ||
|
r316 | if raw: | |
return b64encode(data) | |||
|
r185 | try: | |
r299 | 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) | |||
x = 0 | |||
#while x < n: | |||
|
r264 | payload = self.request('write', 'post', data=b64encode(data)) | |
r299 | # x += 1024 | ||
|
r222 | if payload['write']=='ok': | |
|
r264 | self.device.status = 3 | |
|
r185 | self.device.save() | |
r346 | self.message = 'Pedestal configured and started' | ||
|
r185 | else: | |
|
r236 | self.device.status = 1 | |
|
r185 | self.device.save() | |
r346 | self.message = 'Pedestal write: {}'.format(payload['write']) | ||
|
r185 | return False | |
|
r243 | ||
r299 | #payload = self.request('start', 'post') | ||
|
r185 | except Exception as e: | |
|
r222 | if 'No route to host' not in str(e): | |
self.device.status = 4 | |||
else: | |||
self.device.status = 0 | |||
r346 | self.message = 'Pedestal write: {}'.format(str(e)) | ||
|
r222 | self.device.save() | |
|
r185 | return False | |
|
r243 | ||
|
r185 | return True | |
|
r172 | ||
|
r107 | ||
|
r264 | def get_absolute_url_import(self): | |
r346 | return reverse('url_import_pedestal_conf', args=[str(self.id)]) |