radarsys Commit - r407:c93b3c968e19 · Jicamarca Repository

ver_3Julio :: Fix IP bug in ABS

jespinoza -

r407:c93b3c968e19

parent child

Context file:

r407:c93b3c968e19

Collapse all files

apps/abs/views.py +1 0

             from django.shortcuts import render_to_response
             from django.template import RequestContext
             from django.shortcuts import redirect, render, get_object_or_404
             from django.contrib import messages
             from django.conf import settings
             from django.http import HttpResponse
             from django.urls import reverse
             from django.views.decorators.csrf import csrf_exempt
             from django.utils.safestring import mark_safe
             from datetime import datetime
             from time import sleep
             import os
             import io
             from apps.main.models import Device, Configuration, Experiment
             from apps.main.views import sidebar
             from .models import ABSConfiguration, ABSBeam
             from .forms import ABSConfigurationForm, ABSBeamEditForm, ABSBeamAddForm, ABSImportForm
             from .utils.overJroShow import overJroShow
             #from .utils.OverJRO import OverJRO
             #Create your views here.
             import json, ast
             def get_values_from_form(form_data):
                 sublistup     = []
                 sublistdown   = []
                 subtxlistup   = []
                 subtxlistdown = []
                 subrxlistup   = []
                 subrxlistdown = []
                 up_values_list     = []
                 down_values_list   = []
                 up_txvalues_list   = []
                 down_txvalues_list = []
                 up_rxvalues_list   = []
                 down_rxvalues_list = []
                 values_list = {}
                 cont = 1
                 for i in range(1,65):
                     x = float(form_data['abs_up'+str(i)])
                     y = float(form_data['abs_down'+str(i)])
                     sublistup.append(x)
                     sublistdown.append(y)
                     if str(i) in form_data.getlist('uptx_checks'):
                         subtxlistup.append(1)
                     else:
                         subtxlistup.append(0)
                     if str(i) in form_data.getlist('downtx_checks'):
                         subtxlistdown.append(1)
                     else:
                         subtxlistdown.append(0)
                     if str(i) in form_data.getlist('uprx_checks'):
                         subrxlistup.append(1)
                     else:
                         subrxlistup.append(0)
                     if str(i) in form_data.getlist('downrx_checks'):
                         subrxlistdown.append(1)
                     else:
                         subrxlistdown.append(0)
                     cont = cont+1
                     if cont == 9:
                         up_values_list.append(sublistup)
                         down_values_list.append(sublistdown)
                         sublistup   = []
                         sublistdown = []
                         up_txvalues_list.append(subtxlistup)
                         down_txvalues_list.append(subtxlistdown)
                         subtxlistup   = []
                         subtxlistdown = []
                         up_rxvalues_list.append(subrxlistup)
                         down_rxvalues_list.append(subrxlistdown)
                         subrxlistup   = []
                         subrxlistdown = []
                         cont = 1
                 list_uesup   = []
                 list_uesdown = []
                 for i in range(1,5):
                     if form_data['ues_up'+str(i)] == '':
                         list_uesup.append(0.0)
                     else:
                         list_uesup.append(float(form_data['ues_up'+str(i)]))
                     if form_data['ues_down'+str(i)] == '':
                         list_uesdown.append(0.0)
                     else:
                         list_uesdown.append(float(form_data['ues_down'+str(i)]))
                 onlyrx_list = form_data.getlist('onlyrx')
                 only_rx = {}
                 if '1' in onlyrx_list:
                     only_rx['up'] = True
                 else:
                     only_rx['up'] = False
                 if '2' in onlyrx_list:
                     only_rx['down'] = True
                 else:
                     only_rx['down'] = False
                 antenna = {'antenna_up': up_values_list, 'antenna_down': down_values_list}
                 tx      = {'up': up_txvalues_list, 'down': down_txvalues_list}
                 rx      = {'up': up_rxvalues_list, 'down': down_rxvalues_list}
                 ues     = {'up': list_uesup, 'down': list_uesdown}
                 name    = str(form_data['beam_name'])
                 beam_data = {'name': name, 'antenna': antenna, 'tx': tx, 'rx': rx, 'ues': ues, 'only_rx': only_rx}
                 return beam_data
             def abs_conf(request, id_conf):
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beams = ABSBeam.objects.filter(abs_conf=conf)
                 #------------Colors for Active Beam:-------------
                 all_status = {}
                 module_messages = json.loads(conf.module_messages)
                 color_status   = {}
                 for i, status in enumerate(conf.module_status):
                     if status == '3':    #Running background-color: #00cc00;
                         all_status['{}'.format(i+1)] = 2
                         color_status['{}'.format(i+1)] = 'class=text-success'#'bgcolor=#00cc00'
                     elif status == '2':
                         all_status['{}'.format(i+1)] = 1
                         color_status['{}'.format(i+1)] = 'class=text-info'
                     elif status == '1':  #Connected background-color: #ee902c;
                         all_status['{}'.format(i+1)] = 1
                         color_status['{}'.format(i+1)] = 'class=text-warning'#'bgcolor=#ee902c'
                     else:                #Disconnected background-color: #ff0000;
                         all_status['{}'.format(i+1)] = 0
                         color_status['{}'.format(i+1)] = 'class=text-danger'#'bgcolor=#FF0000'
                 #------------------------------------------------
                 kwargs = {}
                 kwargs['connected_modules'] = str(conf.connected_modules())+'/64'
                 kwargs['dev_conf'] = conf
                 if conf.operation_mode == 0:
                     kwargs['dev_conf_keys'] = ['label', 'operation_mode']
                 else:
                     kwargs['dev_conf_keys'] = ['label', 'operation_mode', 'operation_value']
                 kwargs['title'] = 'ABS Configuration'
                 kwargs['suptitle'] = 'Details'
                 kwargs['button'] = 'Edit Configuration'
                 if conf.active_beam != 0:
                     kwargs['active_beam'] = int(conf.active_beam)
                 kwargs['beams'] = beams
                 kwargs['modules_status'] = all_status
                 kwargs['color_status']   = color_status
                 kwargs['module_messages'] = module_messages
                 ###### SIDEBAR ######
                 kwargs.update(sidebar(conf=conf))
                 return render(request, 'abs_conf.html', kwargs)
             def abs_conf_edit(request, id_conf):
                 conf     = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beams = ABSBeam.objects.filter(abs_conf=conf)
                 if request.method=='GET':
                     form = ABSConfigurationForm(instance=conf)
                 if request.method=='POST':
                     form = ABSConfigurationForm(request.POST, instance=conf)
                     if form.is_valid():
                         conf = form.save(commit=False)
                         conf.save()
                         return redirect('url_abs_conf', id_conf=conf.id)
                 ###### SIDEBAR ######
                 kwargs = {}
                 kwargs['dev_conf'] = conf
                 #kwargs['id_dev'] = conf.id
                 kwargs['id_conf'] = conf.id
                 kwargs['form'] = form
                 kwargs['abs_beams'] = beams
                 kwargs['title'] = 'Device Configuration'
                 kwargs['suptitle'] = 'Edit'
                 kwargs['button'] = 'Save'
                 kwargs['edit'] = True
                 return render(request, 'abs_conf_edit.html', kwargs)
             @csrf_exempt
             def abs_conf_alert(request):
                 if request.method == 'POST':
                     print (request.POST)
                     return HttpResponse(json.dumps({'result':1}), content_type='application/json')
                 else:
                     return redirect('index')
             def import_file(request, id_conf):
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 if request.method=='POST':
                     form = ABSImportForm(request.POST, request.FILES)
                     if form.is_valid():
                         try:
                             parms = conf.import_from_file(request.FILES['file_name'])
                             if parms:
                                 conf.update_from_file(parms)
                                 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'], e))
                 else:
                     messages.warning(request, 'Your current configuration will be replaced')
                     form = ABSImportForm()
                 kwargs = {}
                 kwargs['form'] = form
                 kwargs['title'] = 'ABS Configuration'
                 kwargs['suptitle'] = 'Import file'
                 kwargs['button'] = 'Upload'
                 kwargs['previous'] = conf.get_absolute_url()
                 return render(request, 'abs_import.html', kwargs)
             def start(request, id_conf, id_beam):
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beams_list = ABSBeam.objects.filter(abs_conf=conf)
                 if id_beam>=len(beams_list):
                     return HttpResponse(json.dumps({'result':0}), content_type='application/json')
                 conf.start_device(id_beam)
                 for i, beam in enumerate(beams_list):
                     if i==int(id_beam):
                         conf.active_beam = beam.pk
+                        conf.save()
                         break
                 return HttpResponse(json.dumps({'result':1}), content_type='application/json')
             def send_beam(request, id_conf, id_beam):
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 abs = Configuration.objects.filter(pk=conf.device.conf_active).first()
                 if abs!=conf:
                     url = '#' if abs is None else abs.get_absolute_url()
                     label = 'None' if abs is None else abs.label
                     messages.warning(
                         request,
                         mark_safe('The current configuration has not been written in the modules, the active configuration is <a href="{}">{}</a>'.format(
                             url,
                             label
                             ))
                         )
                     return redirect(conf.get_absolute_url())
                 beam = get_object_or_404(ABSBeam, pk=id_beam)
                 if request.method == 'POST':
                     beams_list = ABSBeam.objects.filter(abs_conf=conf)
                     conf.active_beam = id_beam
                     i = 0
                     for b in beams_list:
                         if b.id == int(id_beam):
                             break
                         else:
                             i += 1
                     beam_pos = i + 1 #Estandarizar
                     print ('%s Position: %s') % (beam.name, str(beam_pos))
                     conf.send_beam(beam_pos)
                     return redirect('url_abs_conf', conf.id)
                 kwargs = {
                     'title': 'ABS',
                     'suptitle': conf.label,
                     'message': 'Are you sure you want to change ABS Beam to: {}?'.format(beam.name),
                     'delete': False
                 }
                 kwargs['menu_configurations'] = 'active'
                 return render(request, 'confirm.html', kwargs)
             def add_beam(request, id_conf):
                 conf     = get_object_or_404(ABSConfiguration, pk=id_conf)
                 confs    = Configuration.objects.all()
                 if request.method=='GET':
                     form = ABSBeamAddForm()
                 if request.method=='POST':
                     form = ABSBeamAddForm(request.POST)
                     beam_data = get_values_from_form(request.POST)
                     new_beam = ABSBeam(
                                name     = beam_data['name'],
                                antenna  = json.dumps(beam_data['antenna']),
                                abs_conf = conf,
                                tx       = json.dumps(beam_data['tx']),
                                rx       = json.dumps(beam_data['rx']),
                                ues      = json.dumps(beam_data['ues']),
                                only_rx  = json.dumps(beam_data['only_rx'])
                                )
                     new_beam.save()
                     messages.success(request, 'Beam: "%s" has been added.'  % new_beam.name)
                     return redirect('url_edit_abs_conf', conf.id)
                 ###### SIDEBAR ######
                 kwargs = {}
                 #kwargs['dev_conf']  = conf.device
                 #kwargs['id_dev']    = conf.device
                 #kwargs['previous']  = conf.get_absolute_url_edit()
                 kwargs['id_conf']    = conf.id
                 kwargs['form']       = form
                 kwargs['title']      = 'ABS Beams'
                 kwargs['suptitle']   = 'Add Beam'
                 kwargs['button']     = 'Add'
                 kwargs['no_sidebar'] = True
                 kwargs['edit']       = True
                 return render(request, 'abs_add_beam.html', kwargs)
             def edit_beam(request, id_conf, id_beam):
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beam = get_object_or_404(ABSBeam, pk=id_beam)
                 if request.method=='GET':
                     form = ABSBeamEditForm(initial={'beam': beam})
                 if request.method=='POST':
                     form = ABSBeamEditForm(request.POST)
                     beam_data = get_values_from_form(request.POST)
                     beam.dict_to_parms(beam_data)
                     beam.save()
                     messages.success(request, 'Beam: "%s" has been updated.'  % beam.name)
                     return redirect('url_edit_abs_conf', conf.id)
                 ###### SIDEBAR ######
                 kwargs = {}
                 kwargs['id_conf'] = conf.id
                 kwargs['form'] = form
                 kwargs['title'] = 'ABS Beams'
                 kwargs['suptitle'] = 'Edit Beam'
                 kwargs['button'] = 'Save'
                 kwargs['no_sidebar'] = True
                 #kwargs['previous'] = conf.get_absolute_url_edit()
                 kwargs['edit'] = True
                 return render(request, 'abs_edit_beam.html', kwargs)
             def remove_beam(request, id_conf, id_beam):
                 conf     = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beam     = get_object_or_404(ABSBeam, pk=id_beam)
                 if request.method=='POST':
                     if beam:
                         try:
                             beam.delete()
                             messages.success(request, 'Beam: "%s" has been deleted.'  % beam)
                         except:
                             messages.error(request, 'Unable to delete beam: "%s".' % beam)
                     return redirect('url_edit_abs_conf', conf.id)
                 ###### SIDEBAR ######
                 kwargs = {}
                 kwargs['object'] = beam
                 kwargs['delete'] = True
                 kwargs['title'] = 'Delete'
                 kwargs['suptitle'] = 'Beam'
                 kwargs['previous'] = conf.get_absolute_url_edit()
                 return render(request, 'confirm.html', kwargs)
             def plot_patterns(request, id_conf, id_beam=None):
                 kwargs = {}
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beams = ABSBeam.objects.filter(abs_conf=conf)
                 if id_beam:
                     beam  = get_object_or_404(ABSBeam, pk=id_beam)
                     kwargs['beam'] = beam
                 ###### SIDEBAR ######
                 kwargs['dev_conf']   = conf.device
                 kwargs['id_dev']     = conf.device
                 kwargs['id_conf']    = conf.id
                 kwargs['abs_beams']  = beams
                 kwargs['title']      = 'ABS Patterns'
                 kwargs['suptitle']   = conf.name
                 kwargs['no_sidebar'] = True
                 return render(request, 'abs_patterns.html', kwargs)
             def plot_pattern(request, id_conf, id_beam, antenna):
                 if antenna=='down':
                     sleep(3)
                 conf = get_object_or_404(ABSConfiguration, pk=id_conf)
                 beam = get_object_or_404(ABSBeam, pk=id_beam)
                 just_rx = 1 if json.loads(beam.only_rx)[antenna] else 0
                 phases = json.loads(beam.antenna)['antenna_{}'.format(antenna)]
                 gain_tx = json.loads(beam.tx)[antenna]
                 gain_rx = json.loads(beam.rx)[antenna]
                 ues = json.loads(beam.ues)[antenna]
                 newOverJro = overJroShow(beam.name)
                 fig = newOverJro.plotPattern2(datetime.today(), phases, gain_tx, gain_rx, ues, just_rx)
                 buf = io.BytesIO()
                 fig.savefig(buf, format='png')
                 response = HttpResponse(buf.getvalue(), content_type='image/png')
                 return response

devices/dds/api.py +8 -3

             '''
             Created on Dec 2, 2014
             @author: Miguel Urco
             eth_device decorator is used to implement an api to ethernet devices.
             When eth_device decorator is used it adds two parameters to any function (ip and port)
             #Definition
             @eth_device
             def enable_rf()
                 cmd = "xxxxx"
                 payload = "xxxxxx"
                 return cmd, payload
             #How to call this function:
             answer = enable_rf(ip, port)
             '''
             import json
             from devices.dds import data
-            from devices.jro_device import eth_device, IdClass
+            from devices.jro_device import eth_device, eth_devices, IdClass
             ID_CLASS = IdClass["dds"]
             CMD_RESET           =0X01
             CMD_ENABLE          =0X02
             CMD_CHANGEIP        =0X03
             CMD_STATUS          =0X04
             CMD_ECHO            =0XFE
             DDS_CMD_RESET       =0X10
             DDS_CMD_ENABLE_RF   =0x11
             # DDS_CMD_MULTIPLIER  =0X12
             # DDS_CMD_MODE        =0x13
             # DDS_CMD_FREQUENCY_A  =0X14
             # DDS_CMD_FREQUENCY_B  =0x15
             # DDS_CMD_PHASE_A      =0X16
             # DDS_CMD_PHASE_B      =0x17
             # DDS_CMD_AMPLITUDE_1  =0X19      #Se han invertido la posicion de los canales
             # DDS_CMD_AMPLITUDE_2  =0x18      #en el PCB
             DDS_CMD_WRITE        =0x50
             DDS_CMD_READ        =0x8000
             @eth_device(ID_CLASS)
             def reset():
                 cmd = CMD_RESET
                 payload = ""
                 return cmd, payload
-            @eth_device(ID_CLASS)
+            @eth_devices(ID_CLASS)
             def change_ip(new_ip, mask="255.255.255.0", gateway="0.0.0.0"):
                 cmd = CMD_CHANGEIP
-                payload = new_ip + '/' + mask + '/' + gateway
+                payload = b''
+                payload += new_ip.encode()
+                payload += b'/'
+                payload += mask.encode()
+                payload += b'/'
+                payload += gateway.encode()
                 return cmd, payload
             @eth_device(ID_CLASS)
             def status():
                 cmd = CMD_STATUS
                 payload = b''
                 return cmd, payload
             @eth_device(ID_CLASS)
             def echo():
                 cmd = CMD_ECHO
                 payload = ""
                 return cmd, payload
             @eth_device(ID_CLASS)
             def enable_rf():
                 cmd = DDS_CMD_ENABLE_RF
                 payload = chr(0x01).encode()
                 return cmd, payload
             @eth_device(ID_CLASS)
             def disable_rf():
                 cmd = DDS_CMD_ENABLE_RF
                 payload = chr(0x00).encode()
                 return cmd, payload
             @eth_device(ID_CLASS)
             def read_all_device():
                 payload = ""
                 return DDS_CMD_READ, payload
             @eth_device(ID_CLASS)
             def write_all_device(payload):
                 return DDS_CMD_WRITE, payload
             def read_config(ip, port):
                 """
                 Output:
                     parms   : Dictionary with keys
                         multiplier        :
                         frequencyA        :
                         frequencyB        :
                         frequencyA_Mhz        :
                         frequencyB_Mhz        :
                         modulation        :
                         phaseA_degrees    :
                         phaseB_degrees    :
                         amplitudeI        :
                         amplitudeQ        :
                 """
                 payload = read_all_device(ip, port)
                 return data.dds_str_to_dict(payload)
             def write_config(ip, port, parms):
                 """
                 Input:
                     ip      :
                     port    :
                     parms   : Dictionary with keys
                         multiplier        :    4 to 20
                         frequencyA        :    0 to (2**48-1) equivalent to: 0 - "Master clock"
                         frequencyB        :    0 to (2**48-1) equivalent to: 0 - "Master clock"
                         modulation        :    0 to 3
                         phaseA_degrees    :    0 - 360 degrees
                         phaseB_degrees    :    0 - 360 degrees
                         amplitudeI        :    0 to (2**12-1) equivalent to: 0 - 100%
                         amplitudeQ        :    0 to (2**12-1) equivalent to: 0 - 100%
                 """
                 payload = data.dict_to_dds_str(parms)
                 answer = write_all_device(ip, port, payload)
                 return answer
             if __name__ == '__main__':
                 print(read_config("127.0.0.1", 2000))

devices/jro_device.py +15 0

             '''
             Created on Dec 2, 2014
             @author: Miguel Urco
             '''
             import time
             import struct
             import socket
             DEBUG = False
             CMD_RESET           =0X01
             CMD_ENABLE          =0X02
             CMD_CHANGEIP        =0X03
             IdClass={
                 "rc"        : 0x01,
                 "dds"       : 0x02,
                 "jars"      : 0x03,
                 "usrp"      : 0x04,
                 "echotek"   : 0x05,
                 "abs"       : 0x06,
                 "clk_gen"   : 0x07
                 }
             def ascii2hex(cadena):
                 hex_cad = ''
                 for c in cadena:
                     hex_cad += hex(ord(c))[2:].rjust(2,'0') + ' '
                 return hex_cad
             def ping(host):
                 """
                 Returns True if host responds to a ping request
                 """
                 import os, platform
                 # Ping parameters as function of OS
                 ping_str = "-n 1" if  platform.system().lower()=="windows" else "-c 1"
                 # Ping
                 return os.system("ping " + ping_str + " " + host) == 0
             class IPData(object):
                 '''
                 Clase para manejar la trama de datos provenientes del/hacia un dispositivo Ethernet.
                 La trama de datos es la siguiente:
                 **********************************
                 ** FORMATO GENERAL DE UNA TRAMA **
                 **********************************
 . Cabecera (5 bytes):    Secuencia Fija que deber ser "$JRO$"
 . Longitud (3 bytes):    Cantidad de bytes de la Data, contados desde IdClass hasta el Xor
 . Id class (1 byte) :    Clase de dispositivo a configurar. Por defecto 0
 . Id device (1 byte):    Identificar del dispositivo a configurar. Por defecto 0
 . Cmd (2 bytes):         Identificador del comando a ejecutarse.
 . Payload (n bytes):     Carga Util conteniendo secuencia,comandos y parametros
 . Xor (1 byte):          Byte de revision de consistencia de la data al aplicar Xor a todos los bytes,
                                           desde la longitud hasta el payload.
                 '''
                 __HEADER = "$JRO$"
                 def __init__(self, ip, port, id_class=0, id_dev=0):
                     '''
                     '''
                     self.id_class = id_class
                     self.id_dev = id_dev
                     self.address = (str(ip), int(port))
                     self.__iniVariables()
                 def __iniVariables(self):
                     self.tx_buffer = None
                     self.rx_buffer = None
                     #self.header = None
                     self.len = None
                     self.cmd = None
                     self.payload = None
                     self.invalid = True
                     self.errormsg = ''
                     self.hasPayload = False
                 def __getXor(self, cadena):
                     '''
                     '''
                     #trama = '%03d' %lenght + ipPayload
                     xor = 0
                     for character in cadena:
                         xor = xor ^ ord(character)
             #         xor_hex = hex(xor)
             #         xor_hex = xor_hex[2:]
             #         xor_hex = xor_hex.rjust(2,'0')
                     return xor
                 def __verifyXor(self, cadena):
                     xor = self.__getXor(cadena)
                     if xor != 0:
                         return 0
                     return 1
                 def __encoder(self, cmd, payload):
                     '''
                     Inputs:
                         cmd            :    Entero que indica el tipo de comando
                         payload        :    Cadena de caracteres con informacion, depende del comando
                     '''
                     #seq = '%04d' %(sequence)
                     #conf = '%04d' %(confcode)
                     #Number to Cad: 2 Bytes <> H, 4 Bytes <> I
                     cmd_cad = struct.pack(">H", cmd)
                     data = chr(self.id_class).encode() + chr(self.id_dev).encode() + cmd_cad + payload
                     len_data = len(data) + 1 # + xor
                     len_cad = struct.pack('>I', len_data)
                     lenAndData = len_cad + chr(self.id_class).encode() + chr(self.id_dev).encode() + cmd_cad + payload
                     lenAndData = list(lenAndData)
                     new = ''
                     for u in lenAndData:
                         new += chr(u)
                     xor = self.__getXor(new)
                     trama = self.__HEADER + new + chr(xor)
                     self.tx_buffer = trama
                     return trama
                 def __decoder(self, rx_buffer):
                     '''
                     Evalua la trama y la separa en los campos correspondientes
 Bytes    |    4Bytes    | 1Byte    | 1 Byte |  2 Bytes |    n Bytes          |    1 Byte
                     Header    |    Len       | Id class | Id dev |   Cmd    |   Payload           |    Xor
                     '''
                     self.invalid = True
                     self.hasPayload = False
                     self.rx_buffer = rx_buffer
                     try:
                         index = rx_buffer.find(self.__HEADER)
                     except:
                         self.errormsg = "rx_buffer is not a string"
                         return 0
                     if index == -1:
                         self.errormsg = "No header found: %s" %ascii2hex(rx_buffer)
                         return 0
                     #print('???????', flush=True)
                     rx_buffer = rx_buffer[index + len(self.__HEADER):]
                     len_cad = rx_buffer[0:4].encode()
                     len_data = struct.unpack('>I',len_cad)[0]
                     lenAndDataAndXor = rx_buffer[0:len_data + 4]    #Incluye los 4 bytes de la longitud
                     dataAndXor = lenAndDataAndXor[4:]
                     if len(dataAndXor) < len_data:
                         self.errormsg = "Data length is lower than %s" %(len_data)
                         return 0
             #         print self.header, ", ", ascii2hex(lenCad), ", ", ascii2hex(ipDataAndXor), ", ", hex(self.xor)
                     if not self.__verifyXor(lenAndDataAndXor):
                         self.errormsg = "Invalid xor: %s" %lenAndDataAndXor[-1]
                         return 0
                     self.invalid = False
                     len_payload = len_data - 5  #Decrementar 1B (id_class), 1B (id_dev), 2B (cmd) y 1B (xor)
                     id_class = ord(dataAndXor[0])
                     id_dev = ord(dataAndXor[1])
                     cmd_cad = dataAndXor[2:4].encode()
                     payload = dataAndXor[4:4+len_payload]
                     cmd = struct.unpack('>H',cmd_cad)[0]
                     self.id_class = id_class
                     self.id_dev = id_dev
                     self.cmd = cmd
                     if len(payload) < 1:
                         self.errormsg = "IP data is valid but it hasn't payload"
                         return 1
                     self.hasPayload = True
                     self.payload = payload
                     self.errormsg = "Successful"
                     return 1
                 def __decoder_api(self, rx_buffer, debug = DEBUG):
                     """
                     Input:
                         rx_buffer    :    Trama recibida como respuesta a un comando enviada a un dispositivo.
                     Return:
 :    Trama recibida incorrecta. La cadena "rx_buffer" no ha sido decodificada correctamente.
                         -1    :    Dispositivo no inicializado. El dispositivo, dds o rc, no ha sido inicializado
                                     correctamente.
                         -2    :    Trama enviada no reconocida. La cadena recibida es correcta y el dispositivo ha sido
                                     inicializaado correctamente pero la trama enviada no ha sido reconocida por el
                                     dispositivo o el comando enviado no ha sido implementado.
                         >0    :    Trama enviada y recibida correctamente
                     """
                     if not self.__decoder(rx_buffer):
                         return "0:Error decoding eth data: " + ascii2hex(self.rx_buffer)
             #         if self.getPayload() == "OK":
             #             return 1
             #
             #         if self.getPayload() == "NI":
             #             return -1
             #
             #         if self.getPayload() == "KO":
             #             return -2
                     if debug:
                         print(ascii2hex(self.rx_buffer))
                     return self.payload
                 def getRxBufferHex(self):
                     if self.rx_buffer == None:
                         return ''
                     cad = ascii2hex(self.rx_buffer)
                     return cad
                 def getTxBufferHex(self):
                     if self.tx_buffer == None:
                         return ''
                     cad = ascii2hex(self.tx_buffer)
                     return cad
                 def isInvalid(self):
                     return self.invalid
                 def getCmd(self):
                     return self.cmd
                 def getPayload(self):
                     return self.payload
                 def getErrorMessage(self):
                     return self.errormsg
                 def getTxBuffer(self):
                     return self.tx_buffer
                 def getRxBuffer(self):
                     return self.rx_buffer
                 def __encodeIpCmd(self, ip, mask, gateway):
                     payload = ip + '/' + mask + '/' + gateway
                     return self.__encoder(CMD_CHANGEIP, payload)
                 def __encodeResetCmd(self):
                     payload = ""
                     return self.__encoder(CMD_RESET, payload)
                 def __sendTCPData(self, cadena=b''):
                     sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                     sck.settimeout(3)
                     try:
                         sck.connect(self.address)
                     except:
                         return None
                     #print('trama', cadena.encode('raw_unicode_escape'), flush=True)
                     sck.send(cadena.encode('raw_unicode_escape'))
                     rx_buffer = b''
                     ini = time.time()
                     try:
                         while True:
                             if time.time() - ini > 0.5:
                                 break
                             try:
                                 tmp = sck.recv(4096)
                             except:
                                 break
                             if len(tmp) < 1:
                                 continue
                             ini = time.time()
                             rx_buffer += tmp
                     finally:
                         sck.close()
                     rx_buffer = list(rx_buffer)
                     #print('-**********-')
                     #print(rx_buffer, flush=True)
                     #print('-**********-')
                     new = ''
                     for u in rx_buffer:
                         new += chr(u)
                     return new
                 def changeIP(self, ip, mask, gateway):
                     tx_buffer = self.__encodeIpCmd(ip, mask, gateway)
                     rx_buffer = self.__sendTCPData(tx_buffer)
                     sts = self.__decoder_api(rx_buffer)
                     if sts > 0:
                         self.address = (ip, self.address[1])
                     return sts
                 def reset(self):
                     tx_buffer = self.__encodeResetCmd()
                     rx_buffer = self.__sendTCPData(tx_buffer)
                     return self.__decoder_api(rx_buffer)
                 def sendData(self, cmd, payload, server=False):
                     if server:
                         tx_buffer = self.__encoder(cmd, payload)
                         print('TX:{}'.format(ascii2hex(tx_buffer)))
                         self.client_connection.sendall(tx_buffer)
                     else:
                         tx_buffer = self.__encoder(cmd, payload)
                         print('TX:{}'.format(ascii2hex(tx_buffer)))
                         rx_buffer = self.__sendTCPData(tx_buffer)
                         if not rx_buffer:
                             msg =  "0:Could not connect to Device %s" %str(self.address)
                             return msg
                         print('RX:{}'.format(ascii2hex(rx_buffer)))
                         return self.__decoder_api(rx_buffer)
                 def receiveData(self, rx_buffer):
                     print('RX:{}'.format(ascii2hex(rx_buffer)))
                     return self.__decoder(rx_buffer)
             def eth_device(id_class):
                 def inner_func(func):
                     def func_wrapper(ip, port, *args):
                         cmd, payload = func(*args)
                         ipObj = IPData(ip, port, id_class=id_class)
                         rx = ipObj.sendData(cmd, payload)
                         return rx
                     return func_wrapper
                 return inner_func
+            def eth_devices(id_class):
+                def inner_func(func):
+                    def func_wrapper(ip, port, **kwargs):
+                        cmd, payload = func(**kwargs)
+                        ipObj = IPData(ip, port, id_class=id_class)
+                        rx = ipObj.sendData(cmd, payload)
+                        return rx
+                    return func_wrapper
+                return inner_func

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