radarsys_met Commit - r444:d8e453ba0459

Add 'reset pedestal' option

eynilupu -

r444:d8e453ba0459

parent child

Context file:

r444:d8e453ba0459

volumes/sirm/apps/main/management/commands/restart_pedestal.py +15 -5

             from django.core.management.base import BaseCommand
             from apps.main.models import Experiment
             from django.shortcuts import get_object_or_404
             import os, fnmatch
             import time
             from datetime import datetime
             import h5py
             import numpy as np
             class Command(BaseCommand):
                 """
                 Check pedestal acquisition each 10 minutes.
                 Example:
                     manage.py restart_pedestal
                 """
                 def handle(self, *args, **options):
                     #start = time.time()
                     #time.sleep(1)
                     restart_pedestal(self)
                     #end = time.time()
                     #self.stdout.write(f'TIME: "{end - start}"')
             def check_experiment():
                 if len(Experiment.objects.filter(status=2)) > 0:
                     return True
                 else:
                     return False
             def pedestal_start(self, id_exp):
                 all_status = Experiment.objects.filter(status=2)
                 check_id = False
                 if len(all_status) > 0:
                     check_id = all_status[0].pk
                 if check_id and check_id == id_exp:
                     exp = get_object_or_404(Experiment, pk=id_exp)
                     name = '{}-R@{}'.format(exp.name, datetime.now().strftime('%Y-%m-%dT%H-%M-%S'))
                     exp.pedestal.start_device(name_experiment=name)
                     self.stdout.write(f'"{exp.name}" experiment: Pedestal acquisition was restarted')
+            def pedestal_reset(self, id_exp):
+                all_status = Experiment.objects.filter(status=2)
+                check_id = False
+                if len(all_status) > 0:
+                    check_id = all_status[0].pk
+                if check_id and check_id == id_exp:
+                    exp = get_object_or_404(Experiment, pk=id_exp)
+                    exp.pedestal.reset_device()
+                    self.stdout.write(f'"{exp.name}" experiment: Pedestal acquisition is resetting')
             def pedestal_stop(self, id_exp):
                 all_status = Experiment.objects.filter(status=2)
                 check_id = False
                 if len(all_status) > 0:
                     check_id = all_status[0].pk
                 if check_id and check_id == id_exp:
                     exp = get_object_or_404(Experiment, pk=id_exp)
                     exp.pedestal.stop_device()
-                    self.stdout.write(f'"{exp.name}" experiment: Pedestal acquisition "{exp.name}" was stopped')
+                    self.stdout.write(f'"{exp.name}" experiment: Pedestal acquisition was stopped')
             def hdf5_list_content(get_file):
                 table_records = np.array(get_file).tolist()
                 table_dim = get_file.ndim
                 table_rows = get_file.shape[0]
                 if table_dim == 1 and table_rows >= 1:
                     #type(table_records[0]) -> float
                     return table_records
                 else:
                     return False
             def hdf5_read(file):
                 dataspeed = {"ele_speed": False, "azi_speed": False}
                 for key, value in dataspeed.items():
                     with h5py.File(file, 'r') as hdf:
                         get = hdf.get('Data'+'/'+key)
                         if get is not None:
                             # 10 values
                             dataspeed[key] = hdf5_list_content(get)[-10:]
                 return dataspeed
             def count_data(last_position):
                 pattern = "pos@*.h5"
                 count = 0
                 list_data = []
                 list_position = os.listdir(last_position)
                 for entry in sorted(list_position):
                     if fnmatch.fnmatch(entry, pattern):
                         count = count + 1
                         list_data.append(os.path.join(last_position, entry))
                 if len(list_data) > 1:
                     list_data = list_data[-2]
                 else:
                     list_data = False
                 return count, list_data
             def response_data(datadir, old_path_datetime, old_position, new_position):
                 path_position = True
                 path_datetime = False
                 read_files = False
                 rootdir = os.path.join(datadir, 'position')
                 if os.path.isdir(rootdir):
                     path_datetime = path_data(os.path.join(datadir, 'position'))
                     if path_datetime:
                         if not old_path_datetime or path_datetime != old_path_datetime:
                             old_position, read_files = count_data(path_datetime)
                         time.sleep(65)
                         new_position, read_files = count_data(path_datetime)
                     else:
                         time.sleep(65)
                 else:
                     path_position = False
                 return path_position, path_datetime, old_position, new_position, read_files
             def path_data(rootdir):
                 list_=[]
                 for it in os.scandir(rootdir):
                     if it.is_dir():
                         try:
                             datetime.strptime(it.path.split("/")[-1], "%Y-%m-%dT%H-00-00")
                             list_.append(it.path)
                         except ValueError:
                             pass
                 list_ = sorted(list_, reverse=True)
                 try:
                     return list_[0]
                 except:
                     return False
             def check_count(datadir):
                 old_numbers = 0
                 new_numbers = 0
                 validation = False
                 path_datetime = False
                 speed = {"ele_speed": False, "azi_speed": False}
                 path_position, path_datetime, old_numbers, new_numbers, read_files = response_data(datadir, path_datetime, old_numbers, new_numbers)
                 for u in range(2):
                     if new_numbers > old_numbers:
                         validation = True
                         data = hdf5_read(read_files)
                         for key, value in data.items():
                             try:
                                 if not max(data[key]) <= 0.1:
                                     speed[key] = True
                             except:
                                 pass
                         break
                     else:
                         if u < 1:
                             path_position, path_datetime, old_numbers, new_numbers, read_files = response_data(datadir, path_datetime, old_numbers, new_numbers)
                 return path_position, path_datetime, validation, speed
             def restart_pedestal(self):
                 if check_experiment():
                     all_status = Experiment.objects.filter(status=2)
                     id_exp = all_status[0].pk
                     datadir_exp = all_status[0].reception_rx.datadir
                     datadir_exp = datadir_exp.replace(os.environ.get('EXPOSE_NAS', '/DATA_RM/DATA'), '/data')
                     datadir_exp = datadir_exp.replace('/rawdata', '')
                     path_position, path_datetime, validation, speed = check_count(datadir_exp)
                     if path_position:
                         # Execute the process
                         if validation:
                             self.stdout.write(f'Acquisition pedestal is running')
                             if speed['ele_speed'] or speed['azi_speed']:
                                 self.stdout.write(f'Pedestal speeds on Azimuth and Elevation are running')
                             else:
                                 for key, value in speed.items():
                                     if not value:
                                         self.stdout.write(f'Speed on {key} is <= 0.1, retry')
                                 pedestal_stop(self, id_exp)
                                 time.sleep(14)
-                                #pedestal_reset(self, id_exp)
-                                #time.sleep(2)
                                 pedestal_start(self, id_exp)
                         else:
                             if not path_datetime:
                                 self.stdout.write(f'No such directory with datetime format "%Y-%m-%dT%H-00-00", retry!')
                             else:
                                 self.stdout.write(f'No file increment, retry')
+                            pedestal_reset(self, id_exp)
+                            time.sleep(14)
                             pedestal_stop(self, id_exp)
                             time.sleep(14)
-                            #pedestal_reset(self, id_exp)
-                            #time.sleep(2)
                             pedestal_start(self, id_exp)
                     else:
                         self.stdout.write(f'No such directory: position, fail!')

volumes/sirm/apps/main/management/commands/restart_reception.py +5 -1

             from django.core.management.base import BaseCommand
             from apps.main.models import Experiment
             from django.shortcuts import get_object_or_404
             import os, fnmatch
             import time
             from datetime import datetime
             import requests
             class Command(BaseCommand):
                 """
                 Check data acquisition each 05 minutes.
                 Example:
                     manage.py restart_reception
                 """
                 def handle(self, *args, **options):
                     #start = time.time()
                     time.sleep(15)
                     restart_acquisition(self)
                     #end = time.time()
                     #self.stdout.write(f'TIME: "{end - start}"')
             def check_experiment():
                 if len(Experiment.objects.filter(status=2)) > 0:
                     return True
                 else:
                     return False
             def acquisition_start(self, id_exp):
                 all_status = Experiment.objects.filter(status=2)
                 check_id = False
                 if len(all_status) > 0:
                     check_id = all_status[0].pk
                 if check_id and check_id == id_exp:
                     exp = get_object_or_404(Experiment, pk=id_exp)
                     name = '{}-R@{}'.format(exp.name, datetime.now().strftime('%Y-%m-%dT%H-%M-%S'))
                     exp.reception_rx.start_device(name_experiment = name, restart = True)
                     self.stdout.write(f'"{exp.name}" experiment: Data acquisition was restarted')
                     self.stdout.write(f'Restarting schain...')
+                    datadir_exp = exp.reception_rx.datadir
+                    datadir_exp = datadir_exp.replace(os.environ.get('EXPOSE_NAS', '/DATA_RM/DATA') + '/', '')
+                    datadir_exp = datadir_exp.replace('/rawdata', '')
                     r = requests.get('http://'+os.environ.get('SCHAIN_SITE', 'sophy-schain')+'/stop')
                     time.sleep(1)
-                    r = requests.post('http://'+os.environ.get('SCHAIN_SITE', 'sophy-schain')+'/start', json={'name': exp.name})
+                    r = requests.post('http://'+os.environ.get('SCHAIN_SITE', 'sophy-schain')+'/start', json={'name': datadir_exp})
             def acquisition_stop(self, id_exp):
                 all_status = Experiment.objects.filter(status=2)
                 check_id = False
                 if len(all_status) > 0:
                     check_id = all_status[0].pk
                 if check_id and check_id == id_exp:
                     exp = get_object_or_404(Experiment, pk=id_exp)
                     exp.reception_rx.stop_device()
                     self.stdout.write(f'"{exp.name}" experiment: Data acquisition "{exp.name}" was stopped')
             def count_data(last_channel):
                 pattern = "rf@*.h5"
                 count = 0
                 list_channel = os.listdir(last_channel)
                 for entry in sorted(list_channel):
                     if fnmatch.fnmatch(entry, pattern):
                         count = count + 1
                 return count
             def response_data(datadir, old_channel, old_rawdata, new_rawdata, search):
                 path_channels = {'ch0': True, 'ch1': True}
                 channel = {'ch0': False, 'ch1': False}
                 for key, value in path_channels.items():
                     rootdir = os.path.join(datadir, key)
                     if os.path.isdir(rootdir):
                         channel[key] = path_data(os.path.join(datadir, key))
                         if key in search:
                             if channel[key]:
                                 if not old_channel[key] or channel[key] != old_channel[key]:
                                     old_rawdata[key] = count_data(channel[key])
                                 time.sleep(1)
                                 new_rawdata[key] = count_data(channel[key])
                             else:
                                 time.sleep(1)
                     else:
                         path_channels[key] = False
                 return path_channels, channel, old_rawdata, new_rawdata
             def path_data(rootdir):
                 list_=[]
                 for it in os.scandir(rootdir):
                     if it.is_dir():
                         try:
                             datetime.strptime(it.path.split("/")[-1], "%Y-%m-%dT%H-00-00")
                             list_.append(it.path)
                         except ValueError:
                             pass
                 list_ = sorted(list_, reverse=True)
                 try:
                     return list_[0]
                 except:
                     return False
             def check_count(datadir):
                 old_numbers = {'ch0': 0, 'ch1': 0}
                 new_numbers = {'ch0': 0, 'ch1': 0}
                 validation = {'ch0': False, 'ch1': False}
                 channel = {'ch0': False, 'ch1': False}
                 path_channels, channel, old_numbers, new_numbers = response_data(datadir, channel, old_numbers, new_numbers, ['ch0', 'ch1'])
                 for key, value in validation.items():
                     for _ in range(5):
                         if new_numbers[key] > old_numbers[key]:
                             validation[key] = True
                             break
                         else:
                             path_channels, channel, old_numbers, new_numbers = response_data(datadir, channel, old_numbers, new_numbers, [key])
                 return path_channels, channel, validation
             def restart_acquisition(self):
                 if check_experiment():
                     all_status = Experiment.objects.filter(status=2)
                     id_exp = all_status[0].pk
                     datadir_exp = all_status[0].reception_rx.datadir
                     datadir_exp = datadir_exp.replace(os.environ.get('EXPOSE_NAS', '/DATA_RM/DATA'), '/data')
                     path_channels, channel, validation = check_count(datadir_exp)
                     if path_channels['ch0'] and path_channels['ch1']:
                         # Execute the process
                         if validation['ch0'] and validation['ch1']:
                             self.stdout.write(f'Data acquisition is running')
                         else:
                             if not channel['ch0'] or not channel['ch1']:
                                 for key, value in channel.items():
                                     if not value:
                                         self.stdout.write(f'No such directory with datetime format "%Y-%m-%dT%H-00-00": channel["{key}"], retry!')
                             else:
                                 for key, value in validation.items():
                                     if not value:
                                         self.stdout.write(f'No file increment: channel["{key}"]')
                             acquisition_stop(self, id_exp)
                             time.sleep(3)
                             acquisition_start(self, id_exp)
                     else:
                         for key, value in path_channels.items():
                             if not value:
                                 self.stdout.write(f'No such directory: channel["{key}"], fail!')

volumes/sirm/apps/main/models.py +2 0

             import os
             import json
             import requests
             import time
             from datetime import datetime
             import base64
             try:
                 from polymorphic.models import PolymorphicModel
             except:
                 from polymorphic import PolymorphicModel
             from django.template.base import kwarg_re
             from django.db import models
             from django.urls import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from django.shortcuts import get_object_or_404
             from django.contrib.auth.models import User
             from django.db.models.signals import post_save
             from django.dispatch import receiver
             from apps.main.utils import Params
             DEV_PORTS = {
                             'pedestal'      : 80,
                             'pedestal_dev'  : 80,
                             'generator'     : 80,
                             'usrp_rx'       : 2000,
                             'usrp_tx'       : 2000,
                         }
             RADAR_STATES = (
                              (0, 'No connected'),
                              (1, 'Connected'),
                              (2, 'Configured'),
                              (3, 'Running'),
                              (4, 'Scheduled'),
                          )
             EXPERIMENT_TYPE = (
                                (0, 'RAW_DATA'),
                                (1, 'PDATA'),
                                )
             DECODE_TYPE = (
                          (0, 'None'),
                          (1, 'TimeDomain'),
                          (2, 'FreqDomain'),
                          (3, 'InvFreqDomain'),
                          )
             DEV_STATES = (
                              (0, 'Unknown'),
                              (1, 'Connected'),
                              (2, 'Configured'),
                              (3, 'Running'),
                              (4, 'Offline'),
                          )
             DEV_TYPES = (
                             ('', 'Select a  device type'),
                             ('pedestal', 'Pedestal Controller'),
                             ('pedestal_dev', 'Pedestal Controller Dev Mode'),
                             ('generator', 'Pulse Generator'),
                             ('usrp_rx', 'Universal Software Radio Peripheral Rx'),
                             ('usrp_tx', 'Universal Software Radio Peripheral Tx'),
                         )
             EXP_STATES = (
                              (0,'Error'),                 #RED
                              (1,'Cancelled'),             #YELLOW
                              (2,'Running'),               #GREEN
                              (3,'Scheduled'),             #BLUE
                              (4,'Unknown'),               #WHITE
                              (5,'Other'),                 #ORANGE
                          )
             CONF_TYPES = (
                              (0, 'Active'),
                              (1, 'Historical'),
                          )
             class Profile(models.Model):
                 user = models.OneToOneField(User, on_delete=models.CASCADE)
                 theme = models.CharField(max_length=30, default='spacelab')
             @receiver(post_save, sender=User)
             def create_user_profile(sender, instance, created, **kwargs):
                 if created:
                     Profile.objects.create(user=instance)
             @receiver(post_save, sender=User)
             def save_user_profile(sender, instance, **kwargs):
                 instance.profile.save()
             class DeviceType(models.Model):
                 name = models.CharField(max_length = 15, choices = DEV_TYPES, default = 'pedestal')
                 sequence = models.PositiveSmallIntegerField(default=55)
                 description = models.TextField(blank=True, null=True)
                 class Meta:
                     db_table = 'db_device_types'
                 def __str__(self):
                     return u'%s' % self.name.title()
             class Device(models.Model):
                 device_type  = models.ForeignKey('DeviceType', on_delete=models.CASCADE)
                 ip_address   = models.GenericIPAddressField(verbose_name = 'IP address', protocol='IPv4', default='0.0.0.0')
                 port_address = models.PositiveSmallIntegerField(default=2000)
                 description  = models.TextField(blank=True, null=True)
                 status       = models.PositiveSmallIntegerField(default=4, choices=DEV_STATES)
                 conf_active  = models.PositiveIntegerField(default=0, verbose_name='Current configuration')
                 class Meta:
                     db_table = 'db_devices'
                 def __str__(self):
                     ret = self.device_type
                     return str(ret)
                 @property
                 def name(self):
                     return str(self)
                 def get_status(self):
                     return self.status
                 @property
                 def status_color(self):
                     color = 'muted'
                     if self.status == 0:
                         color = "danger"
                     elif self.status == 1:
                         color = "primary"
                     elif self.status == 2:
                         color = "info"
                     elif self.status == 3:
                         color = "success"
                     return color
                 def url(self, path=None):
                     if path:
                         return 'http://{}:{}/{}/'.format(self.ip_address, self.port_address, path)
                     else:
                         return 'http://{}:{}/'.format(self.ip_address, self.port_address)
                 def get_absolute_url(self):
                     return reverse('url_device', args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_device', args=[str(self.id)])
                 def get_absolute_url_delete(self):
                     return reverse('url_delete_device', args=[str(self.id)])
                 def change_ip(self, ip_address, mask, gateway, dns, **kwargs):
                     if self.device_type.name=='pedestal':
                         headers = {'content-type': "application/json",
                                    'cache-control': "no-cache"}
                         ip      = [int(x) for x in ip_address.split('.')]
                         dns     = [int(x) for x in dns.split('.')]
                         gateway = [int(x) for x in gateway.split('.')]
                         subnet  = [int(x) for x in mask.split('.')]
                         payload = {
                             "ip": ip,
                             "dns": dns,
                             "gateway": gateway,
                             "subnet": subnet
                             }
                         req = requests.post(self.url('changeip'), data=json.dumps(payload), headers=headers)
                         try:
                             answer = req.json()
                             if answer['changeip']=='ok':
                                 self.message    = '25|IP succesfully changed'
                                 self.ip_address = ip_address
                                 self.save()
                             else:
                                 self.message = '30|An error ocuur when changing IP'
                         except Exception as e:
                             self.message = '40|{}'.format(str(e))
                     else:
                         self.message = 'Not implemented'
                         return False
                     return True
             class Experiment(PolymorphicModel):
                 name       = models.CharField(max_length=40, default='', unique=True)
                 pedestal   = models.ForeignKey('pedestal.PedestalConfiguration', null=False, blank=False, on_delete=models.PROTECT, default=None, limit_choices_to={'type': 0}, related_name = "pedestal_conf")
                 generator = models.ForeignKey('Device', null=False, blank=False, on_delete=models.PROTECT, default=2, editable=False, limit_choices_to={'device_type__name': 'generator'}, related_name = "generator_conf")
                 reception_rx    = models.ForeignKey('usrp_rx.USRPRXConfiguration', null=False, blank=False, on_delete=models.PROTECT, default=None, limit_choices_to={'type': 0}, related_name = "usrp_rx_CONF")
                 transmission_tx = models.ForeignKey('usrp_tx.USRPTXConfiguration', null=False, blank=False, on_delete=models.PROTECT, default=None, limit_choices_to={'type': 0}, related_name = "usrp_tx")
                 task       = models.CharField(max_length=36, default='', blank=True, null=True)
                 status     = models.PositiveSmallIntegerField(default=4, choices=EXP_STATES)
                 author     = models.ForeignKey(User, null=True, blank=True, on_delete=models.CASCADE)
                 hash       = models.CharField(default='', max_length=64, null=True, blank=True)
                 latitude = models.FloatField(null=False, blank=False, default=0, editable=False)
                 longitude = models.FloatField(null=False, blank=False, default=0, editable=False)
                 altitude = models.FloatField(null=False, blank=False, default=0, editable=False)
                 heading = models.FloatField(null=True, blank=True)
                 mode_stop = models.CharField(max_length=3, null=False, blank=False, default='web', editable=False)
                 class Meta:
                     db_table = 'db_experiments'
                     ordering = ('name',)
                 def __str__(self):
                     return u'%s' % (self.name)
                 def jsonify(self):
                     data = {}
                     ignored = []
                     for field in self._meta.fields:
                         if field.name in ignored:
                             continue
                         data[field.name] = field.value_from_object(self)
                     data['configurations'] = ['{}'.format(conf.pk) for
                         conf in Configuration.objects.filter(experiment=self, type=0)]
                     return data
                 def clone(self, **kwargs):
                     confs = Configuration.objects.filter(experiment=self, type=0)
                     self.pk = None
                     self.name = '{}_{:%y%m%d}'.format(self.name, datetime.now())
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     for conf in confs:
                         conf.clone(experiment=self)
                     return self
                 def generator_start(self):
                     try:
                         experiment = get_object_or_404(Experiment, pk=self.id)
                         generator_url = experiment.generator.url()
                         period = self.transmission_tx.ipp*2/0.3
                         if self.transmission_tx.enable_2:
                             payload = {"Delay": 1 + self.transmission_tx.delay, "periode1": period, "width1": self.transmission_tx.pulse_1 + 6, "repeatability1": self.transmission_tx.repetitions_1, "periode2": period, "width2": self.transmission_tx.pulse_2 + 6, "repeatability2": self.transmission_tx.repetitions_2, "enable": 1}
                         else:
                             payload = {"Delay": 1 + self.transmission_tx.delay, "periode1": period, "width1": self.transmission_tx.pulse_1 + 6, "repeatability1": 1, "periode2": period, "width2": self.transmission_tx.pulse_1 + 6, "repeatability2": 1, "enable": 1}
                         json_trmode = json.dumps(payload)
                         base64_trmode = base64.standard_b64encode(json_trmode.encode('ascii'))
                         trmode_url = generator_url + "trmode?params="
                         complete_url_trmode = trmode_url + base64_trmode.decode('ascii')
                         requests.get(complete_url_trmode)
                     except:
                         return False
                     return True
                 def generator_stop(self):
                     try:
                         experiment = get_object_or_404(Experiment, pk=self.id)
                         generator_url = experiment.generator.url()
                         payload = {"enable": 0}
                         json_trmode_selector = json.dumps(payload)
                         base64_trmode_selector = base64.standard_b64encode(json_trmode_selector.encode('ascii'))
                         trmode_url = generator_url + "trmode?params="
                         url_trmode_selector = trmode_url + base64_trmode_selector.decode('ascii')
                         requests.get(url_trmode_selector)
                     except:
                         return False
                     return True
                 def start(self):
                     '''
                     Configure and start experiments's devices
                     '''
                     all_status = Experiment.objects.filter(status=2)
                     if self.status != 2:
                         if len(all_status) == 0:
                             data = {
                                 'name': '{}@{}'.format(self.name, datetime.now().strftime('%Y-%m-%dT%H-%M-%S')),
                                 'latitude': self.latitude,
                                 'longitude': self.longitude,
                                 'altitude': self.altitude,
                                 'heading': self.heading
                             }
                             try:
                                 data['pedestal'] = self.pedestal.start_device(name_experiment=data['name'])
                                 time.sleep(1.0)
                                 self.generator_start()
                                 time.sleep(1.0)
                                 data['usrp_tx'] = self.transmission_tx.start_device(name_experiment=data['name'])
                                 time.sleep(1.0)
                                 data['usrp_rx'] = self.reception_rx.start_device(name_experiment=data['name'])
                                 time.sleep(0.1)
                                 proc_url = 'http://'+os.environ['PROC_SITE']+'/start'
                                 requests.post(proc_url, json=data)
                             except:
                                 return 0
                             return 2
                         else:
                             return 5
                     else:
                         return 2
                 def stop(self):
                     '''
                     Stop experiments's devices
                     PEDESTAL, GENERATOR & USRP's
                     '''
                     try:
                         self.transmission_tx.stop_device()
                         time.sleep(1.0)
                         self.generator_stop()
                         time.sleep(0.1)
                         self.reception_rx.stop_device()
                         time.sleep(0.1)
+                        self.pedestal.reset_device()
+                        time.sleep(14)
                         self.pedestal.stop_device()
                         time.sleep(0.1)
                         proc_url = 'http://'+os.environ['PROC_SITE']+'/stop'
                         requests.get(proc_url)
                     except:
                         return 0
                     return 4
                 def get_status(self):
                     if self.status == 3:
                         return
                     confs =  Configuration.objects.filter(experiment=self, type=0)
                     for conf in confs:
                         conf.status_device()
                     total = confs.aggregate(models.Sum('device__status'))['device__status__sum']
                     if total==2*confs.count():
                         status = 1
                     elif total == 3*confs.count():
                         status = 2
                     else:
                         status = 0
                     self.status = status
                     self.save()
                 def status_color(self):
                     color = 'muted'
                     if self.status == 0:
                         color = "danger"
                     elif self.status == 1:
                         color = "warning"
                     elif self.status == 2:
                         color = "success"
                     elif self.status == 3:
                         color = "info"
                     return color
                 def parms_to_dict(self):
                     params = Params({})
                     params.add(self.jsonify(), 'experiments')
                     configurations = Configuration.objects.filter(experiment=self, type=0)
                     for conf in configurations:
                         params.add(conf.jsonify(), 'configurations')
                     return params.data
                 def dict_to_parms(self, parms, CONF_MODELS, id_exp=None):
                     configurations = Configuration.objects.filter(experiment=self)
                     if id_exp is not None:
                         exp_parms = parms['experiments']['byId'][id_exp]
                     else:
                         exp_parms = parms['experiments']['byId'][parms['experiments']['allIds'][0]]
                     if configurations:
                         for configuration in configurations:
                             configuration.delete()
                     for id_conf in exp_parms['configurations']:
                         conf_parms = parms['configurations']['byId'][id_conf]
                         device     = Device.objects.filter(device_type__name=conf_parms['device_type'])[0]
                         model      = CONF_MODELS[conf_parms['device_type']]
                         conf = model(
                             experiment = self,
                             device = device,
                             )
                         conf.dict_to_parms(parms, id=id_conf)
                     self.name = '{}-{}'.format(exp_parms['name'], datetime.now().strftime('%y%m%d'))
                     self.save()
                     return self
                 def get_absolute_url(self):
                     return reverse('url_experiment', args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_experiment', args=[str(self.id)])
                 def get_absolute_url_delete(self):
                     return reverse('url_delete_experiment', args=[str(self.id)])
                 def get_absolute_url_import(self):
                     return reverse('url_import_experiment', args=[str(self.id)])
                 def get_absolute_url_export(self):
                     return reverse('url_export_experiment', args=[str(self.id)])
                 def get_absolute_url_start(self):
                     return reverse('url_start_experiment', args=[str(self.id)])
                 def get_absolute_url_stop(self):
                     return reverse('url_stop_experiment', args=[str(self.id)])
             class Configuration(PolymorphicModel):
                 id              = models.AutoField(primary_key=True)
                 experiment      = models.CharField(default='empty', editable=False, max_length=64, null=True, blank=True)
                 experiment_date = models.DateTimeField(default=datetime.now, editable=False)
                 device          = models.ForeignKey('Device', verbose_name='Device', null=True, on_delete=models.CASCADE)
                 type            = models.PositiveSmallIntegerField(default=0, choices=CONF_TYPES)
                 created_date    = models.DateTimeField(auto_now_add=True)
                 programmed_date = models.DateTimeField(auto_now=True)
                 parameters      = models.TextField(default='{}')
                 author          = models.ForeignKey(User, null=True, blank=True,on_delete=models.CASCADE)
                 hash            = models.CharField(default='', max_length=64, null=True, blank=True)
                 message         = ""
                 class Meta:
                     db_table = 'db_configurations'
                     ordering = ('device__device_type__name',)
                 def __str__(self):
                     ret = u'{} '.format(self.device.device_type.name.upper())
                     if 'mix' in [f.name for f in self._meta.get_fields()]:
                         if self.mix:
                             ret = '{} MIX '.format(self.device.device_type.name.upper())
                     if 'label' in [f.name for f in self._meta.get_fields()]:
                         ret += '{}'.format(self.label)
                     return ret
                 @property
                 def name(self):
                     return str(self)
                 @property
                 def label(self):
                     return str(self)
                 def jsonify(self):
                     data = {}
                     ignored = ('type', 'polymorphic_ctype', 'configuration_ptr',
                                'created_date', 'programmed_date', 'device',
                                'experiment', 'author')
                     for field in self._meta.fields:
                         if field.name in ignored:
                             continue
                         data[field.name] = field.value_from_object(self)
                     data['device_type'] = self.device.device_type.name
                     return data
                 def clone(self, **kwargs):
                     before_id = self.id
                     self.pk = None
                     self.id = None
                     for attr, value in kwargs.items():
                         setattr(self, attr, value)
                     self.save()
                     self.id = before_id
                     return self
                 def parms_to_dict(self):
                     params = Params({})
                     params.add(self.jsonify(), 'configurations')
                     return params.data
                 def parms_to_text(self):
                     raise NotImplementedError("This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper())
                 def parms_to_binary(self):
                     raise NotImplementedError("This method should be implemented in %s Configuration model" %str(self.device.device_type.name).upper())
                 def dict_to_parms(self, parameters, id=None):
                     params = Params(parameters)
                     if id:
                         data = params.get_conf(id_conf=id)
                     else:
                         data = params.get_conf(dtype=self.device.device_type.name)
                     for key, value in data.items():
                         if key not in ('id', 'device_type'):
                             setattr(self, key, value)
                     self.save()
                 def export_to_file(self, format="json"):
                     content_type = ''
                     if format == 'racp':
                         content_type = 'text/plain'
                         filename = '%s_%s.%s' %(self.device.device_type.name, self.name, 'racp')
                         content = self.parms_to_text(file_format = 'racp')
                     if format == 'text':
                         content_type = 'text/plain'
                         filename = '%s_%s.%s' %(self.device.device_type.name, self.name, self.device.device_type.name)
                         content = self.parms_to_text()
                     if format == 'binary':
                         content_type = 'application/octet-stream'
                         filename = '%s_%s.bin' %(self.device.device_type.name, self.name)
                         content = self.parms_to_binary()
                     if not content_type:
                         content_type = 'application/json'
                         filename = '%s_%s.json' %(self.device.device_type.name, self.name)
                         content = json.dumps(self.parms_to_dict(), indent=2)
                     fields = {'content_type':content_type,
                               'filename':filename,
                               'content':content
                               }
                     return fields
                 def import_from_file(self, fp):
                     parms = {}
                     path, ext = os.path.splitext(fp.name)
                     if ext == '.json':
                         parms = json.load(fp)
                     return parms
                 def status_device(self):
                     self.message = 'Function not supported'
                     return False
                 def stop_device(self):
                     self.message = 'Function not supported'
                     return False
                 def start_device(self):
                     self.message = 'Function not supported'
                     return False
                 def write_device(self):
                     self.message = 'Function not supported'
                     return False
                 def read_device(self):
                     self.message = 'Function not supported'
                     return False
                 def get_absolute_url(self):
                     return reverse('url_%s_conf' % self.device.device_type.name, args=[str(self.id)])
                 def get_absolute_url_edit(self):
                     return reverse('url_edit_%s_conf' % self.device.device_type.name, args=[str(self.id)])
                 def get_absolute_url_delete(self):
                     return reverse('url_delete_dev_conf', args=[str(self.id)])
                 def get_absolute_url_import(self):
                     return reverse('url_import_dev_conf', args=[str(self.id)])
                 def get_absolute_url_export(self):
                     return reverse('url_export_dev_conf', args=[str(self.id)])
                 def get_absolute_url_write(self):
                     return reverse('url_write_dev_conf', args=[str(self.id)])
                 def get_absolute_url_read(self):
                     return reverse('url_read_dev_conf', args=[str(self.id)])
                 def get_absolute_url_start(self):
                     return reverse('url_start_dev_conf', args=[str(self.id)])
                 def get_absolute_url_stop(self):
                     return reverse('url_stop_dev_conf', args=[str(self.id)])
                 def get_absolute_url_status(self):
                     return reverse('url_status_dev_conf', args=[str(self.id)])

volumes/sirm/apps/pedestal/models.py +26 -5

             import os
             from datetime import datetime
             import json
             import requests
             import base64
             import struct
             from struct import pack
             import time
             from django.contrib import messages
             from django.db import models
             from django.urls import reverse
             from django.core.validators import MinValueValidator, MaxValueValidator
             from apps.main.models import Configuration
             MODE_VALUE = (
                     ('position', 'Position'),
                     ('speed', 'Speed'),
                     ('table', 'Table')
                 )
             class PedestalConfiguration(Configuration):
                 mode = models.CharField(
                     verbose_name='Mode',
                     max_length=10,
                     choices=MODE_VALUE,
                     null=False,
                     blank=False
                 )
                 axis = models.CharField(
                     verbose_name="Axis",
                     max_length=1000,
                     blank=False,
                     null=False,
                     help_text="Please separate the values with commas when using table mode"
                 )
                 speed = models.CharField(
                     verbose_name='Speed [°/s]',
                     max_length=1000,
                     blank=True,
                     null=True
                 )
                 angle = models.CharField(
                     verbose_name="Angle(s) [°]",
                     max_length=1000,
                     blank=True,
                     null=True,
                     help_text="Please separate the values with commas when using table mode"
                 )
                 min_value = models.FloatField(
                     verbose_name='Min angle [°]',
                     validators=[MinValueValidator(-5), MaxValueValidator(185)],
                     blank=True,
                     null=True
                 )
                 max_value = models.FloatField(
                     verbose_name='Max angle [°]',
                     validators=[MinValueValidator(-5), MaxValueValidator(185)],
                     blank=True,
                     null=True
                 )
                 class Meta:
                     db_table = 'pedestal_configurations'
                 def __str__(self):
                     if self.mode=='position':
                         return u'Position: {}º {}'.format(self.angle, self.axis.upper())
                     if self.mode=='speed':
                         return u'Speed: {}º/s {}'.format(self.speed, self.axis.upper())
                     if self.mode=='table':
                         axis = [x.strip().upper() for x in self.axis.split(',')]
                         speeds = [float(x.strip()) for x in self.speed.split(',')]
                         table = [float(x.strip()) for x in self.angle.split(',')]
                         return u'Table: Axis {}, Speed {}º/s, Steps {}'.format(axis, speeds, table)
                 @property
                 def label(self):
                     return str(self)
                 def get_absolute_url_plot(self):
                     return reverse('url_plot_pedestal_pulses', args=[str(self.id)])
                 def request(self, cmd, method='get', **kwargs):
                     req = getattr(requests, method)(self.device.url(cmd), **kwargs)
                     payload = req.json()
                     return payload
                 def status_device(self):
                     try:
                         payload = requests.get(self.device.url())
                         if payload:
                             self.device.status = 1
                         elif payload['status']=='disable':
                             self.device.status = 2
                         else:
                             self.device.status = 1
                             self.device.save()
                             self.message = 'Pedestal 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 = 'Pedestal status: {}'.format(str(e))
                         return False
                     self.device.save()
                     return True
-                def reset_device(self, axi, angle):
+                def reset_device(self):
+                    try:
+                        r = requests.get(self.device.url() + 'reset')
+                        if r:
+                            #self.device.status = 3
+                            #self.device.save()
+                            self.message = 'Pedestal restarted'
+                        else:
+                            return False
+                    except Exception as e:
+                        self.message = "Pedestal can't restarted: {}".format(str(e))
+                        return False
+                    return True
+                def initial_device(self, axi, angle):
                     try:
                         url = self.device.url() + "position?params="
                         payload_el = {'axis': 'elevation'}
                         payload_az = {'axis': 'azimuth'}
                         if axi == 'elevation':
                             # CORRECT AZ OFFSET
                             azi = angle - float(os.environ.get('AZ_OFFSET', 26.27))
                             if azi<0: azi += 360
                             payload_az['position'] = round(azi, 2)
                             payload_el['position'] = 0
                         elif axi == 'azimuth':
                             payload_el['position'] = angle
                             payload_az['position'] = 0
                         else:
                             payload_el['position'] = 0
                             payload_az['position'] = 0
                         json_data_el = json.dumps(payload_el)
                         json_data_az = json.dumps(payload_az)
                         base64_table_el = base64.standard_b64encode(json_data_el.encode('ascii'))
                         base64_table_az = base64.standard_b64encode(json_data_az.encode('ascii'))
                         time.sleep(0.1)
                         r = requests.get(url + base64_table_el.decode('ascii'))
                         time.sleep(0.1)
                         r = requests.get(url + base64_table_az.decode('ascii'))
                         if r:
                             self.device.status = 3
                             self.device.save()
-                            self.message = 'Pedestal reset'
+                            self.message = 'Pedestal - initial position'
                         else:
                             return False
                     except Exception as e:
-                        self.message = 'Pedestal reset: {}'.format(str(e))
+                        self.message = 'Pedestal - initial position: {}'.format(str(e))
                         return False
                     return True
                 def stop_device(self):
                     try:
                         command = self.device.url() + "stop"
                         r = requests.get(command)
                         if self.mode == 'table':
                             AX = {'az':'azimuth', 'el':'elevation'}
                             axis = [AX[x.lower().strip()] for x in self.axis.split(',')]
                             list_of_floats = [float(x.strip()) for x in self.angle.split(",")]
-                            self.reset_device(axis[0], list_of_floats[0])
+                            self.initial_device(axis[0], list_of_floats[0])
                         if r:
                             self.device.status = 4
                             self.device.save()
                             self.message = 'Pedestal stopped'
                         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 = 'Pedestal stop: {}'.format(str(e))
                         self.message = "Pedestal can't start, please check network/device connection or IP address/port configuration"
                         self.device.save()
                         return False
                     return True
                 def start_device(self, name_experiment=False):
                     if self.mode == 'table':
                         if len(self.angle.split(',')) > 1:
                             list_speed = []
                             list_axis = []
                             for _ in range(len(self.angle.split(','))):
                                 list_axis.append(self.axis)
                                 list_speed.append(self.speed)
                             if len(self.axis.split(',')) == 1:
                                 self.axis = ",".join(map(str, list_axis))
                             if len(self.speed.split(',')) == 1:
                                 self.speed = ",".join(map(str, list_speed))
                     AX = {'az':'azimuth', 'el':'elevation'}
                     axis = [AX[x.lower().strip()] for x in self.axis.split(',')]
                     if len(axis)==1:
                         axis = axis[0]
                     try:
                         if self.mode == 'position':
                             url = self.device.url() + "position?params="
                             payload = {'axis': axis, 'position': float(self.angle)}
                         elif self.mode == 'speed':
                             url = self.device.url() + "speed?params="
                             payload = {'axis': axis, 'speed': float(self.speed)}
                         elif self.mode == 'table':
                             url = self.device.url() + "combinedtable?params="
                             list_of_floats = [float(x.strip()) for x in self.angle.split(",")]
                             # CORRECT AZ OFFSET
                             for i, ax in enumerate(axis):
                                 if ax == 'elevation':
                                     azi = list_of_floats[i] - float(os.environ.get('AZ_OFFSET', 26.27))
                                     if azi<0: azi += 360
                                     list_of_floats[i] = round(azi, 2)
                             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])
                             coded_table = base64.standard_b64encode(bytes(byte_table))
                             coded_table_ascii = coded_table.decode('ascii')
                             speed = [float(x.strip()) for x in self.speed.split(',')]
                             if isinstance(axis, str):
                                 axis = [axis]
                             payload = {
                                 'arraylength': len(speed),
                                 'axis': axis,
                                 'speed': speed,
                                 'bottom': self.min_value,
                                 'top': self.max_value,
                                 'table': coded_table_ascii
                                 }
                         json_data = json.dumps(payload)
                         print(json_data)
                         base64_table = base64.standard_b64encode(json_data.encode('ascii'))
                         url += base64_table.decode('ascii')
                         print(url)
                         r = requests.get(url)
                         if self.mode == 'table':
                             payload['table'] = list_of_floats
                         if name_experiment:
                             name_experiment = name_experiment.split("@")
                             dt = datetime.strptime(name_experiment[1], '%Y-%m-%dT%H-%M-%S')
                             self.clone(experiment=name_experiment[0], experiment_date=dt, type=1)
                         else:
                             self.clone(type=1, experiment = 'empty', experiment_date=datetime.now())
                         if r:
                             self.device.status = 3
                             self.device.save()
                             self.message = 'Pedestal configured and started'
                         else:
                             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 = 'Pedestal start: {}'.format(str(e))
                         self.message = "Pedestal can't start, please check network/device connection or IP address/port configuration"
                         self.device.save()
                         return False
                     return payload
                 def get_absolute_url_import(self):
-                    return reverse('url_import_pedestal_conf', args=[str(self.id)])
  No newline at end of file
+                    return reverse('url_import_pedestal_conf', args=[str(self.id)])
+                def get_absolute_url_reset(self):
+                    return reverse('url_reset_pedestal_conf', args=[str(self.id)])
  No newline at end of file

volumes/sirm/apps/pedestal/templates/pedestal_conf.html +4 0

             {% extends "dev_conf.html" %}
             {% load static %}
             {% load bootstrap4 %}
             {% load main_tags %}
+            {% block extra-menu-actions %}
+            	<li><a href="{{ dev_conf.get_absolute_url_reset }}"><span class="fas fa-spinner" aria-hidden="true"></span> Reset </a></li>
+            {% endblock %}
             {% block content-detail %}
             <h2>Pedestal</h2>
             <table class="table table-bordered">
             	<tr>
             		<th>Status</th>
             		<td class="text-{{dev_conf.device.status_color}}"><strong>{{dev_conf.device.get_status_display}}</strong></td>
             	</tr>
             	{% for key in dev_conf_keys %}
             	<tr>
             		<th>{% get_verbose_field_name dev_conf key %}</th>
             		<td>{{dev_conf|attr:key}}</td>
             	</tr>
             	{% endfor %}
             </table>
             {% endblock %}
             {% block extra-js%}
             <script type="text/javascript">
               $("#bt_toggle").click(function() {
                 $(".panel-collapse").collapse('toggle')
               });
             </script>
             {% endblock %}

volumes/sirm/apps/pedestal/urls.py +1 0

             from django.urls import path
             from . import views
             urlpatterns = (
                 path('<int:conf_id>/', views.conf, name='url_pedestal_conf'),
                 path('<int:conf_id>/import/', views.import_file, name='url_import_pedestal_conf'),
                 path('<int:conf_id>/edit/', views.conf_edit, name='url_edit_pedestal_conf'),
+                path('<int:conf_id>/reset/', views.conf_reset, name='url_reset_pedestal_conf'),
                 #url(r'^(?P<id_conf>-?\d+)/write/$', 'apps.main.views.dev_conf_write', name='url_write_pedestal_conf'),
                 #url(r'^(?P<id_conf>-?\d+)/read/$', 'apps.main.views.dev_conf_read', name='url_read_pedestal_conf'),
             )

volumes/sirm/apps/pedestal/views.py +12 0

             import json
             from django.contrib import messages
             from django.utils.safestring import mark_safe
             from django.shortcuts import render, redirect, get_object_or_404, HttpResponse
             from django.contrib.auth.decorators import login_required
             from apps.main.models import Experiment, Device
             from apps.main.views import sidebar
             from .models import PedestalConfiguration
             from .forms import PedestalConfigurationForm, PedestalImportForm
             def conf(request, conf_id):
                 conf = get_object_or_404(PedestalConfiguration, pk=conf_id)
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 if conf.mode == 'position':
                     kwargs['dev_conf_keys'] = ['mode', 'axis', 'angle']
                 elif conf.mode == 'speed':
                     kwargs['dev_conf_keys'] = ['mode', 'axis', 'speed']
                 else:
                     kwargs['dev_conf_keys'] = ['mode', 'axis', 'speed', 'angle', 'min_value', 'max_value']
                 kwargs['title'] = 'Configuration'
                 kwargs['suptitle'] = 'Detail'
                 kwargs['button'] = 'Edit Configuration'
                 conf.status_device()
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'pedestal_conf.html', kwargs)
             @login_required
             def conf_edit(request, conf_id):
                 conf = get_object_or_404(PedestalConfiguration, pk=conf_id)
                 if request.method=='GET':
                     form = PedestalConfigurationForm(instance=conf)
                     if conf.mode == 'position':
                         form.fields['speed'].disabled = True
                         form.fields['max_value'].disabled = True
                         form.fields['min_value'].disabled = True
                     elif conf.mode == 'speed':
                         form.fields['angle'].disabled = True
                         form.fields['max_value'].disabled = True
                         form.fields['min_value'].disabled = True
                 elif request.method=='POST':
                     line_data = {}
                     conf_data = {}
                     clock_data = {}
                     extras = []
                     #classified post fields
                     form = PedestalConfigurationForm(request.POST, instance=conf)
                     if form.is_valid():
                         form.save()
                         messages.success(request, 'Pedestal configuration successfully updated')
                         return redirect(conf.get_absolute_url())
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 kwargs['form'] = form
                 kwargs['edit'] = True
                 kwargs['title'] = 'Pedestal Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Update'
                 return render(request, 'pedestal_conf_edit.html', kwargs)
             def import_file(request, conf_id):
                 conf = get_object_or_404(PedestalConfiguration, pk=conf_id)
                 if request.method=='POST':
                     form = PedestalImportForm(request.POST, request.FILES)
                     if form.is_valid():
                         try:
                             data = conf.import_from_file(request.FILES['file_name'])
                             conf.dict_to_parms(data)
                             messages.success(request, 'Configuration "%s" loaded succesfully' % request.FILES['file_name'])
                             return redirect(conf.get_absolute_url_edit())
                         except Exception as e:
                             messages.error(request, 'Error parsing file: "%s" - %s' % (request.FILES['file_name'], repr(e)))
                 else:
                     messages.warning(request, 'Your current configuration will be replaced')
                     form = PedestalImportForm()
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'Pedestal Configuration'
                 kwargs['suptitle'] = 'Import file'
                 kwargs['button'] = 'Upload'
                 kwargs['previous'] = conf.get_absolute_url()
                 return render(request, 'pedestal_import.html', kwargs)
+            @login_required
+            def conf_reset(request, conf_id):
+                conf = get_object_or_404(PedestalConfiguration, pk=conf_id)
+                if conf.reset_device():
+                    messages.success(request, conf.message)
+                else:
+                    messages.error(request, conf.message)
+                return redirect(conf.get_absolute_url())
             def conf_raw(request, conf_id):
                 conf = get_object_or_404(PedestalConfiguration, pk=conf_id)
                 raw = conf.write_device(raw=True)
                 return HttpResponse(raw, content_type='application/json')

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