From 884ae042d9ee22aae78e136e1d541f21d308cae9 2016-03-16 17:49:03 From: Miguel Urco Date: 2016-03-16 17:49:03 Subject: [PATCH] git-svn-id: http://jro-dev.igp.gob.pe/svn/jro_hard/radarsys/trunk/webapp@72 aa17d016-51d5-4e8b-934c-7b2bbb1bbe71 --- diff --git a/devices/__init__.py b/devices/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/devices/__init__.py diff --git a/devices/dds/__init__.py b/devices/dds/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/devices/dds/__init__.py diff --git a/devices/dds/api.py b/devices/dds/api.py new file mode 100644 index 0000000..378ca85 --- /dev/null +++ b/devices/dds/api.py @@ -0,0 +1,153 @@ +''' +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 data + +from devices.jro_device import eth_device, 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) +def change_ip(ip, mask="255.255.255.0", gateway="0.0.0.0"): + + cmd = CMD_CHANGEIP + payload = ip + '/' + mask + '/' + gateway + + return cmd, payload + +@eth_device(ID_CLASS) +def status(): + + cmd = CMD_STATUS + payload = "" + + 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) + + return cmd, payload + +@eth_device(ID_CLASS) +def disable_rf(): + + cmd = DDS_CMD_ENABLE_RF + payload = chr(0x00) + + 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 enable_rf("127.0.0.1", 2000) + print read_config("127.0.0.1", 2000) \ No newline at end of file diff --git a/devices/dds/data.py b/devices/dds/data.py new file mode 100644 index 0000000..085c37c --- /dev/null +++ b/devices/dds/data.py @@ -0,0 +1,171 @@ +''' +Created on Feb 15, 2016 + +@author: Miguel Urco +''' +import struct + +DDS_NBITS = 48 + +def freq_to_binary(freq, mclock): + + binary = (float(freq)/mclock)*(2**DDS_NBITS) + + return binary + +def binary_to_freq(binary, mclock): + + freq = (float(binary)/(2**DDS_NBITS))*mclock + + return freq + +def phase_to_binary(phase): + + binary = float(phase)*8192/180.0 + + return binary + +def binary_to_phase(binary): + + phase = float(binary)*180.0/8192 + + return phase + +def dds_str_to_dict(registers): + + """ + Output: + parms : Dictionary with keys + multiplier : + frequencyA : + frequencyB : + frequencyA_Mhz : + frequencyB_Mhz : + modulation : + phaseA_degrees : + phaseB_degrees : + amplitudeI : + amplitudeQ : + + """ + + if not registers: + return {} + + if len(registers) != 0x28: + return {} + + phaseA = struct.unpack('>H', registers[0x0:0x2])[0] + phaseB = struct.unpack('>H', registers[0x2:0x4])[0] + + frequencyA = struct.unpack('>Q', '\x00\x00' + registers[0x04:0x0A])[0] + frequencyB = struct.unpack('>Q', '\x00\x00' + registers[0x0A:0x10])[0] + + delta_frequency = struct.unpack('>Q', '\x00\x00' + registers[0x10:0x16])[0] + + update_clock = struct.unpack('>I', registers[0x16:0x1A])[0] + + ramp_rate_clock = struct.unpack('>I', '\x00' + registers[0x1A:0x1D])[0] + + control_register = struct.unpack('>I', registers[0x1D:0x21])[0] + + amplitudeI = struct.unpack('>H', registers[0x21:0x23])[0] + amplitudeQ = struct.unpack('>H', registers[0x23:0x25])[0] + + amp_ramp_rate = ord(registers[0x25]) + + qdac = struct.unpack('>H', registers[0x26:0x28])[0] + + multiplier = (control_register & 0x001F0000) >> 16 + modulation = (control_register & 0x00000E00) >> 9 + amplitude_enabled = (control_register & 0x00000020) >> 5 + + parms = {'clock' : None, + 'multiplier' : multiplier, + 'frequencyA' : frequencyA, + 'frequencyB' : frequencyB, + 'frequencyA_Mhz' : None, + 'frequencyB_Mhz' : None, + 'phaseA' : phaseA, + 'phaseB' : phaseB, + 'phaseA_degrees' : binary_to_phase(phaseA), + 'phaseB_degrees' : binary_to_phase(phaseB), + 'modulation' : modulation, + 'amplitudeI' : amplitudeI, + 'amplitudeQ' : amplitudeQ, + 'amplitude_enabled' : amplitude_enabled, + 'delta_frequency' : delta_frequency, + 'update_clock' : update_clock, + 'ramp_rate_clock' : ramp_rate_clock, + 'amp_ramp_rate' : amp_ramp_rate, + 'qdac' : qdac + } + + return parms + +def dict_to_dds_str(parms): + """ + Input: + 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% + """ + + my_dict = {'clock' : None, + 'multiplier' : 1, + 'frequencyA' : 0, + 'frequencyB' : 0, + 'frequencyA_Mhz' : 0, + 'frequencyB_Mhz' : 0, + 'phaseA_degress' : 0, + 'phaseB_degress' : 0, + 'modulation' : 0, + 'amplitudeI' : 0, + 'amplitudeQ' : 0, + 'amplitude_enabled' : 0, + 'delta_frequency' : 0, + 'update_clock' : 0, + 'ramp_rate_clock' : 0, + 'amplitude_ramp_rate' : 0, + 'qdac' : 0 + } + + print "PArms", parms + + my_dict.update(parms) + my_dict['phaseA'] = phase_to_binary(my_dict['phaseA_degrees']) + my_dict['phaseB'] = phase_to_binary(my_dict['phaseB_degrees']) + + registers = "" + + control_register = (my_dict['multiplier'] << 16) + (my_dict['modulation'] << 9) + (my_dict['amplitude_enabled'] << 5) + + registers += struct.pack(">H", my_dict['phaseA']) + registers += struct.pack(">H", my_dict['phaseB']) + + registers += struct.pack(">Q", my_dict['frequencyA'])[2:] + registers += struct.pack(">Q", my_dict['frequencyB'])[2:] + + registers += struct.pack(">Q", my_dict['delta_frequency'])[2:] + + registers += struct.pack(">I", my_dict['update_clock']) + + registers += struct.pack(">I", my_dict['ramp_rate_clock'])[1:] + + registers += struct.pack(">I", control_register) + + registers += struct.pack(">H", my_dict['amplitudeI']) + + registers += struct.pack(">H", my_dict['amplitudeQ']) + + registers += chr(my_dict['amplitude_ramp_rate']) + + registers += struct.pack(">H", my_dict['qdac']) + + return registers \ No newline at end of file diff --git a/apps/dds/files.py b/devices/dds/files.py similarity index 68% rename from apps/dds/files.py rename to devices/dds/files.py index b21321f..3a66c95 100644 --- a/apps/dds/files.py +++ b/devices/dds/files.py @@ -5,6 +5,7 @@ Created on Feb 8, 2016 ''' import string +import data def read_dds_file(fp): """ @@ -36,8 +37,7 @@ def read_dds_file(fp): """ - kwargs = {} - dds_registers = [] + registers = "" for this_line in fp: this_line = str.strip(this_line) @@ -48,37 +48,11 @@ def read_dds_file(fp): if len(this_line) != 8: continue - dds_registers.append(string.atoi(this_line,2)) - - if len(dds_registers) != 40: - return kwargs - - kwargs['clock'] = 60.0 - - kwargs['phase_bin'] = dds_registers[0]*(2**8) + dds_registers[1] - kwargs['phase_mod_bin'] = dds_registers[2]*(2**8) + dds_registers[3] - - kwargs['frequency_bin'] = dds_registers[4]*(2**40) + dds_registers[5]*(2**32) + dds_registers[6]*(2**24) + dds_registers[7]*(2**16) + dds_registers[8]*(2**8) + dds_registers[9] - kwargs['frequency_mod_bin'] = dds_registers[10]*(2**40) + dds_registers[11]*(2**32) + dds_registers[12]*(2**24) + dds_registers[13]*(2**16) + dds_registers[14]*(2**8) + dds_registers[15] - - kwargs['delta_frequency'] = dds_registers[16]*(2**40) + dds_registers[17]*(2**32) + dds_registers[18]*(2**24) + dds_registers[19]*(2**16) + dds_registers[20]*(2**8) + dds_registers[21] + registers += chr(string.atoi(this_line,2)) - kwargs['update_clock'] = dds_registers[22]*(2**24) + dds_registers[23]*(2**16) + dds_registers[24]*(2**8) + dds_registers[25] + parms = data.dds_str_to_dict(registers) - kwargs['ramp_rate_clock'] = dds_registers[26]*(2**16) + dds_registers[27]*(2**8) + dds_registers[28] - - kwargs['control_register'] = dds_registers[29]*(2**24) + dds_registers[30]*(2**16) + dds_registers[31]*(2**8) + dds_registers[32] - - kwargs['multiplier'] = dds_registers[30] & 0x1F - kwargs['modulation'] = (dds_registers[31] & 0x0E) >> 1 - kwargs['amplitude_enabled'] = (dds_registers[32] & 0x20) >> 5 - - kwargs['amplitude_ch_A'] = (dds_registers[33]*(2**8) + dds_registers[34]) & 0x0FFF - kwargs['amplitude_ch_B'] = (dds_registers[35]*(2**8) + dds_registers[36]) & 0x0FFF - - kwargs['amplitude_ramp_rate'] = dds_registers[37] - - return kwargs + return parms def read_json_file(fp): diff --git a/devices/jro_device.py b/devices/jro_device.py new file mode 100644 index 0000000..e5e9170 --- /dev/null +++ b/devices/jro_device.py @@ -0,0 +1,396 @@ +''' +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 ** + ********************************** + + 1. Cabecera (5 bytes): Secuencia Fija que deber ser "$JRO$" + 2. Longitud (3 bytes): Cantidad de bytes de la Data, contados desde IdClass hasta el Xor + 3. Id class (1 byte) : Clase de dispositivo a configurar. Por defecto 0 + 4. Id device (1 byte): Identificar del dispositivo a configurar. Por defecto 0 + 5. Cmd (2 bytes): Identificador del comando a ejecutarse. + 3. Payload (n bytes): Carga Util conteniendo secuencia,comandos y parametros + 4. 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) + chr(self.id_dev) + cmd_cad + payload + + len_data = len(data) + 1 # + xor + len_cad = struct.pack('>I', len_data) + + lenAndData = len_cad + chr(self.id_class) + chr(self.id_dev) + cmd_cad + payload + + xor = self.__getXor(lenAndData) + + trama = self.__HEADER + lenAndData + chr(xor) + + self.tx_buffer = trama + + return trama + + def __decoder(self, rx_buffer): + ''' + Evalua la trama y la separa en los campos correspondientes + + 4Bytes | 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 + + rx_buffer = rx_buffer[index + len(self.__HEADER):] + + len_cad = rx_buffer[0:4] + + 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] + 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: + 0 : 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): + + sck = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sck.settimeout(2) + + try: + sck.connect(self.address) + except: + return None + +# print "TX: ", ascii2hex(cadena) + + sck.send(cadena) + + rx_buffer = "" + + ini = time.time() + + try: + while True: + + if time.time() - ini > 0.5: + break + + tmp = sck.recv(255) + + if len(tmp) < 1: + continue + + ini = time.time() + rx_buffer += tmp + + finally: + sck.close() + +# print "RX: ", ascii2hex(rx_buffer) + + return rx_buffer + + 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: ", ascii2hex(tx_buffer) + + self.client_connection.sendall(tx_buffer) + + else: + + tx_buffer = self.__encoder(cmd, payload) + + print "TX: ", 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: ", ascii2hex(rx_buffer) + + return self.__decoder_api(rx_buffer) + + def receiveData(self, rx_buffer): + + print "RX: ", 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 \ No newline at end of file diff --git a/devices/rc/__init__.py b/devices/rc/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/devices/rc/__init__.py diff --git a/devices/rc/api.py b/devices/rc/api.py new file mode 100644 index 0000000..2e13154 --- /dev/null +++ b/devices/rc/api.py @@ -0,0 +1,122 @@ +''' +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 data + +from devices.jro_device import eth_device, IdClass + +ID_CLASS = IdClass["rc"] + +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) +def change_ip(ip, mask="255.255.255.0", gateway="0.0.0.0"): + + cmd = CMD_CHANGEIP + payload = ip + '/' + mask + '/' + gateway + + return cmd, payload + +@eth_device(ID_CLASS) +def status(): + + cmd = CMD_STATUS + payload = "" + + return cmd, payload + +@eth_device(ID_CLASS) +def echo(): + + cmd = CMD_ECHO + payload = "" + + 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 + + """ + payload = read_all_device(ip, port) + + return data.rc_str_to_dict(payload) + +def write_config(ip, port, parms): + """ + Input: + ip : + port : + parms : Dictionary with keys + + """ + + payload = data.dict_to_rc_str(parms) + + answer = write_all_device(ip, port, payload) + + return answer + +if __name__ == '__main__': + ip = "10.10.20.150" + port = 2000 + + print status(ip, port) + print read_config(ip, port) \ No newline at end of file diff --git a/devices/rc/data.py b/devices/rc/data.py new file mode 100644 index 0000000..1c44791 --- /dev/null +++ b/devices/rc/data.py @@ -0,0 +1,26 @@ +''' +Created on Feb 15, 2016 + +@author: Miguel Urco +''' +import struct + +def rc_str_to_dict(registers): + + parms = {'clock' : 10 + } + + return parms + +def dict_to_rc_str(parms): + """ + Input: + parms : Dictionary with keys + """ + + my_dict = {'clock' : 10 + } + + registers = ord(my_dict['clock']) + + return registers \ No newline at end of file diff --git a/devices/rc/files.py b/devices/rc/files.py new file mode 100644 index 0000000..e6ef6ba --- /dev/null +++ b/devices/rc/files.py @@ -0,0 +1,67 @@ +''' +Created on Feb 8, 2016 + +@author: Miguel Urco +''' + +import string +import data + +def read_rc_file(fp): + """ + Function to extract the parameters from a text file with the next format: + + Input: + + File with the next content: + + Phase Adjust Register 1 + ----------------------- + 00000000 + 00000000 + + ..... + + ----------------------- + Frequency Tuning Word 1 + ----------------------- + 00110101 + 01111111 + 11111111 + 11111111 + 10100000 + 00000000 + + Output: + Return configuration parameters for DDS: multiplier, frequency, phase, amplitude, etc. + + """ + + registers = "" + + for this_line in fp: + this_line = str.strip(this_line) + + if not str.isdigit(this_line): + continue + + if len(this_line) != 8: + continue + + registers += chr(string.atoi(this_line,2)) + + parms = data.rc_str_to_dict(registers) + + return parms + +def read_json_file(fp): + + kwargs = {} + + return kwargs + +def write_cr_file(filename): + pass + +def write_json_file(filename): + pass \ No newline at end of file