##// END OF EJS Templates
radarsys
RSS
Actualizacion de la app RC a python3 y django 2, antes del merge con cambios
Actualizacion de la app RC a python3 y django 2, antes del merge con cambios
gonzalesluisfrancisco - - Load All Authors

File last commit:

r341:cb29d2ed7f9e merge
r341:cb29d2ed7f9e merge
Show More
models.py
305 lines | 12.0 KiB | text/x-python | PythonLexer
/ apps / dds_rest / models.py
History | Annotation | Raw |Copy content |Copy permalink
import ast
import json
import requests
import numpy as np
from base64 import b64encode
from struct import pack
from django.urls import reverse
from django.db import models
from apps.main.models import Configuration
from apps.main.utils import Params
# Create your models here.
from django.core.validators import MinValueValidator, MaxValueValidator
from django.core.exceptions import ValidationError
from devices.dds_rest import api, data
ENABLE_TYPE = (
(False, 'Disabled'),
(True, 'Enabled'),
)
MOD_TYPES = (
(0, 'Single Tone'),
(1, 'FSK'),
(2, 'Ramped FSK'),
(3, 'Chirp'),
(4, 'BPSK'),
)
class DDSRestConfiguration(Configuration):
DDS_NBITS = 48
clock = models.FloatField(verbose_name='Clock In (MHz)',validators=[MinValueValidator(5), MaxValueValidator(75)], null=True, default=60)
multiplier = models.PositiveIntegerField(verbose_name='Multiplier',validators=[MinValueValidator(1), MaxValueValidator(20)], default=4)
frequencyA_Mhz = models.DecimalField(verbose_name='Frequency A (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=19, decimal_places=16, null=True, default=49.9200)
frequencyA = models.BigIntegerField(verbose_name='Frequency A (Decimal)',validators=[MinValueValidator(0), MaxValueValidator(2**DDS_NBITS-1)], blank=True, null=True)
frequencyB_Mhz = models.DecimalField(verbose_name='Frequency B (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=19, decimal_places=16, blank=True, null=True)
frequencyB = models.BigIntegerField(verbose_name='Frequency B (Decimal)',validators=[MinValueValidator(0), MaxValueValidator(2**DDS_NBITS-1)], blank=True, null=True)
delta_frequency_Mhz = models.DecimalField(verbose_name='Delta frequency (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=19, decimal_places=16, blank=True, null=True)
delta_frequency = models.BigIntegerField(verbose_name='Delta frequency (Decimal)',validators=[MinValueValidator(0), MaxValueValidator(2**DDS_NBITS-1)], blank=True, null=True)
update_clock_Mhz = models.DecimalField(verbose_name='Update clock (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=19, decimal_places=16, blank=True, null=True)
update_clock = models.BigIntegerField(verbose_name='Update clock (Decimal)',validators=[MinValueValidator(0), MaxValueValidator(2**32-1)], blank=True, null=True)
ramp_rate_clock_Mhz = models.DecimalField(verbose_name='Ramp rate clock (MHz)', validators=[MinValueValidator(0), MaxValueValidator(150)], max_digits=19, decimal_places=16, blank=True, null=True)
ramp_rate_clock = models.BigIntegerField(verbose_name='Ramp rate clock (Decimal)',validators=[MinValueValidator(0), MaxValueValidator(2**18-1)], blank=True, null=True)
phaseA_degrees = models.FloatField(verbose_name='Phase A (Degrees)', validators=[MinValueValidator(0), MaxValueValidator(360)], default=0)
phaseB_degrees = models.FloatField(verbose_name='Phase B (Degrees)', validators=[MinValueValidator(0), MaxValueValidator(360)], blank=True, null=True)
modulation = models.PositiveIntegerField(verbose_name='Modulation Type', choices = MOD_TYPES, default = 0)
amplitude_enabled = models.BooleanField(verbose_name='Amplitude Control', choices=ENABLE_TYPE, default=False)
amplitudeI = models.PositiveIntegerField(verbose_name='Amplitude CH1',validators=[MinValueValidator(0), MaxValueValidator(2**12-1)], blank=True, null=True)
amplitudeQ = models.PositiveIntegerField(verbose_name='Amplitude CH2',validators=[MinValueValidator(0), MaxValueValidator(2**12-1)], blank=True, null=True)
def get_nbits(self):
return self.DDS_NBITS
def clean(self):
if self.modulation in [1,2,3]:
if self.frequencyB is None or self.frequencyB_Mhz is None:
raise ValidationError({
'frequencyB': 'Frequency modulation has to be defined when FSK or Chirp modulation is selected'
})
if self.modulation in [4,]:
if self.phaseB_degrees is None:
raise ValidationError({
'phaseB': 'Phase modulation has to be defined when BPSK modulation is selected'
})
self.frequencyA_Mhz = data.binary_to_freq(self.frequencyA, self.clock*self.multiplier)
self.frequencyB_Mhz = data.binary_to_freq(self.frequencyB, self.clock*self.multiplier)
def verify_frequencies(self):
return True
def parms_to_text(self):
my_dict = self.parms_to_dict()['configurations']['byId'][str(self.id)]
text = data.dict_to_text(my_dict)
return text
def status_device(self):
print("Status ")
try:
self.device.status = 0
payload = self.request('status')
if payload['status']=='generating RF':
self.device.status = 3
elif payload['status']=='no generating RF':
self.device.status = 2
else:
self.device.status = 1
self.device.save()
self.message = 'DDS REST 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 = 'DDS REST 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 = 'DDS REST restarted OK'
self.device.status = 2
self.device.save()
else:
self.message = 'DDS REST restart fail'
self.device.status = 4
self.device.save()
except Exception as e:
self.message = 'DDS REST reset: {}'.format(str(e))
return False
return True
def stop_device(self):
try:
payload = self.request('stop', 'post',data=json.dumps({'_rf_enable':0}))
self.message = 'DDS REST: {}'.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 = 'DDS REST stop: {}'.format(str(e))
self.device.save()
return False
return True
def start_device(self):
try:
payload = self.request('start', 'post',data=json.dumps({'_rf_enable':1}))
self.message = 'DDS REST start: {}'.format(payload['start'])
if payload['start']=='ok':
self.device.status = 3
self.device.save()
else:
self.device.status = 2
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 = 'DDS REST start: {}'.format(str(e))
self.device.save()
return False
return True
def read_device(self):
parms = self.request('read')
print(parms)
if not parms:
self.message = "Could not read DDS REST parameters from this device"
return parms
self.message = ""
return parms
def arma_control(self,l_clock,l_multiplier,l_modulation):
sysclock = l_clock*l_multiplier
pll_range = 0
if(sysclock>=200):
pll_range = 1
l_control = ((l_modulation<<9)+(pll_range<<22)+(l_multiplier<<16)).to_bytes(4,'little')
return l_control
def conv_phase(self,l_phase):
l_phase_2B = int((l_phase*(2**14)/360)).to_bytes(2,'little')
return l_phase_2B
def arma_data_write(self):
#clock = RCClock.objects.get(rc_configuration=self)
clock = self.clock
print(clock)
multiplier = self.multiplier
print(multiplier)
frequencyA_Mhz = self.frequencyA_Mhz
print(frequencyA_Mhz)
frequencyA = self.frequencyA
print(frequencyA)
frequencyB_Mhz = self.frequencyB_Mhz
print(frequencyB_Mhz)
frequencyB = self.frequencyB
print(frequencyB)
phaseA_degrees = self.phaseA_degrees or 0
print(phaseA_degrees)
phaseB_degrees = self.phaseB_degrees or 0
print(phaseB_degrees)
modulation = self.modulation or 0
print(modulation)
amplitude_enabled = self.amplitude_enabled or 0
print(amplitude_enabled)
amplitudeI = self.amplitudeI or 0
print(amplitudeI)
amplitudeQ = self.amplitudeQ or 0
print(amplitudeQ)
delta_frequency = self.delta_frequency or 0
print(delta_frequency)
update_clock = self.update_clock or 0
print(update_clock)
ramp_rate_clock = self.ramp_rate_clock or 0
print(ramp_rate_clock)
osrr = 0
qdac = 0
control = self.arma_control(clock,multiplier,modulation)
phase1 = self.conv_phase(phaseA_degrees)
phase2 = self.conv_phase(phaseB_degrees)
cadena_json = {'clock': (b64encode(pack('<f',clock))).decode("UTF-8"),\
'multiplier': (b64encode(pack('<B',multiplier))).decode("UTF-8"),\
'frequencyA': (b64encode((frequencyA).to_bytes(6,'little'))).decode("UTF-8"),\
'frequencyB': (b64encode((frequencyB).to_bytes(6,'little'))).decode("UTF-8"),\
'delta_frequency': (b64encode((delta_frequency).to_bytes(6,'little'))).decode("UTF-8"),\
'update_clock': (b64encode((update_clock).to_bytes(4,'little'))).decode("UTF-8"),\
'ramp_rate_clock': (b64encode((ramp_rate_clock).to_bytes(3,'little'))).decode("UTF-8"),\
'control': (b64encode(control)).decode("UTF-8"),\
'amplitudeI': (b64encode((amplitudeI).to_bytes(2,'little'))).decode("UTF-8"),\
'amplitudeQ': (b64encode((amplitudeQ).to_bytes(2,'little'))).decode("UTF-8"),\
'_phase1': (b64encode((phase1))).decode("UTF-8"),\
'_phase2': (b64encode((phase2))).decode("UTF-8"),\
'osrr': (b64encode((osrr).to_bytes(1,'little'))).decode("UTF-8"),\
'qdac': (b64encode((qdac).to_bytes(2,'little'))).decode("UTF-8")
}
return cadena_json
def write_device(self, raw=False):
print("Ingreso a write")
try:
if not raw:
data = self.arma_data_write()
print(data)
payload = self.request('write', 'post', data=json.dumps(data))
print(payload)
if payload['write'] == 'ok':
self.device.status = 3
self.device.save()
self.message = 'DDS Rest write configured and started'
else:
self.message = payload['programming']
if payload['programming'] == 'fail':
self.message = 'DDS Rest write: error programming DDS chip'
if raw:
return b64encode(data)
except Exception as e:
if 'No route to host' not in str(e):
self.device.status = 4
else:
self.device.status = 0
self.message = 'DDS Rest write: {}'.format(str(e))
self.device.save()
return False
return True
def request(self, cmd, method='get', **kwargs):
print("Ingreso a request")
req = getattr(requests, method)(self.device.url(cmd), **kwargs)
payload = req.json()
return payload
class Meta:
db_table = 'ddsrest_configurations'