def _net_to_uart(self): try: data = self._connect_socket.recv(2048) except socket.error as e: logger.warning("read %d socket error:%s" % (self._connect_socket.fileno(), repr(e))) self._del_connect_socket() return 0 if len(data) == 0: self._del_connect_socket() return 0 self._total_net_size += len(data) logger.info("recev %s net byte size %d total recev :%d"%(self._uartname ,len(data),\ self._total_net_size)) logger.info("net to uart data:%s" % (logger.print_list2hex( list(bytearray.fromhex(data.encode("hex")))))) try: self._uart_device.write((data)) except Exception as e: logger.warning("write %s device error %s" % (self._uartname, repr(e))) return 0 return 1
def _tcp_to_device(self): try: data = self._connect_socket.recv(2048) except socket.error as e: logger.warning("read %d socket error:%s" % (self._connect_socket.fileno(), repr(e))) self._del_connect_socket() return 0 if len(data) == 0: self._del_connect_socket() return 0 self._total_net_size += len(data) logger.info("recev tcp port %s byte size %d, total recev :%d"%(self._port ,len(data),\ self._total_net_size)) logger.info("tcp to device data:%s" % (logger.print_list2hex( list(bytearray.fromhex(data.encode("hex")))))) try: self._device.write((data)) except Exception as e: logger.warning("device write data byte size %d error :%s" % (len(data), repr(e))) return 0 return 1
def dut_storage_checkout(self, target_file_name, target_address, file_offset, size, instance_sequence=0): "in:\ target_file_name:str,the file path\ target_address: unsigned int,the DUT target checkout address\ file_offset:unsigned int,loading the firmware file start address\ size:unsigned int,program size\ instance_sequence:unsigned int\ " params = {} params["target_file_name"] = target_file_name params["target_address"] = target_address params["file_offset"] = file_offset params["size"] = size params["instance_sequence"] = instance_sequence response = self.rpc_client_node.call("DutStorageCheckout", **params) # pring(response) if response["state"] < 0: logger.info(response["return"]) return dfu_common.get_error_return_state(response) return dfu_common.get_correct_return_state(response)
def config(self, baud_rate=115200, data_bits=8, parity='NONE', stop_bits=1, flow_ctrl="SgUartHardStreamDisable"): logger.info("uart set baud_rate: %s ; flow_ctrl : %s ; data_bits: %s; stop_bits : %s ;parity: %s;"\ %(baud_rate, flow_ctrl, data_bits,stop_bits,parity)) self.__ser.baudrate = baud_rate self.__ser.bytesize = uart_data_bits[data_bits] self.__ser.parity = uart_parity[parity] self.__ser.stopbits = uart_stop_bit[stop_bits] if flow_ctrl == "SgUartHardStreamEnable": self.__ser.rtscts = True elif flow_ctrl == "SgUartFlowCtrlEnable": self.__ser.xonxoff = True self.__is_use = True if self.get_uart_status() is False: logger.warning("uart device:%s does not exist" % (str(self.name))) self._close() return False elif self.is_open is True: self._close() status = self._open() if status is False: logger.error("uart %s set param error" % (self.name)) return False else: return True
def create_instance(self, dev_path, what_chip): "in : \ dev_path:string" protocol_type = dfu_common.get_protocol_type_support( self.rpc_client_node)["swd"] arch_type = dfu_common.get_chip_arch_type_support( self.rpc_client_node)["nrf5xble"] chip_type = dfu_common.get_chip_type_support(self.rpc_client_node, arch_type)[what_chip] print(dfu_common.get_protocol_type_support(self.rpc_client_node)) print(dfu_common.get_chip_arch_type_support(self.rpc_client_node)) print(dfu_common.get_chip_type_support(self.rpc_client_node, arch_type)) params = {} params["driver_name"] = dev_path params["protocol_type"] = protocol_type params["chip_arch_type"] = arch_type params["chip_type"] = chip_type response = self.rpc_client_node.call("DfuProgInstanceCreate", **params) logger.info(response) if response["state"] < 0: # logger.info(response["return"]) return dfu_common.get_error_return_state(response) return dfu_common.get_correct_return_state(response)
def run(self): logger.boot('embedded engine starting') while True: try: self.rpc_server.serve_forever() except Exception: logger.warning("rpc server exception: %s"%(traceback.format_exc())) logger.info("embedded engine stopping")
def uart_config_handle(params): UART_CHANNEL_LIST = get_uart_device_list() uart_string = '' for uart_name in UART_CHANNEL_LIST.keys(): uart_string += uart_name uart_string += "," help_info = "uart config(<channel>,<baud>,<bits>,<stop>,<parity>,{<timestamp>})$\r\n\ \tchannel=("+uart_string[:-1] +")$\r\n\ \tbaud=(115200,38400,19200,9600,4800,2400,1200,300)$\r\n\ \tbits=(5,6,7,8)$\r\n\ \tstop=(1,1.5,2)$\r\n\ \tparity=(odd,even,none)$\r\n\ \ttimestamp=(ON,OFF)$\r\n\ \t\tdefault:OFF" '''help''' if Utility.is_ask_for_help(params) is True: return Utility.handle_done(help_info) timestamp = "OFF" '''params analysis ''' param_count = len(params) if param_count < 5 or param_count > 6: return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'] - param_count,"param count error") for index in range(0, param_count): if index == 0: channel = params[index] elif index == 1: baud = int(params[index]) elif index == 2: bits = int(params[index]) elif index == 3: stop = float(params[index]) elif index == 4: parity = params[index].upper() elif index == 5: timestamp = params[index] else : return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'] - index,"param error") logger.info(str(channel) + " " + str(baud) + " " + str(bits) + " " + str(stop) + " " + str(parity) + " " + str(timestamp)) if channel not in UART_CHANNEL_LIST: return Utility.handle_error(Utility.handle_errorno['handle_errno_parameter_invalid'],"channel param error") if timestamp.upper() == "OFF": timestamp = "NONE" else: timestamp = "TS" logger.warning("cmd uart") result = Xavier.call("uart_param_config",channel, baud, bits, parity, stop, timestamp) if result == False: return Utility.handle_error(Utility.handle_errorno['handle_errno_execute_failure'],"execute error") return Utility.handle_done()
def led_flicker(): try: gpio = GPIO(913, "out") except SeGpioFaultError: logger.info("can not export gpio913") return None while True: gpio.write_value(1) time.sleep(1) gpio.write_value(0) time.sleep(1)
def _open(self): logger.info("uart open:" + str(self.name)) try: self.__ser.open() except Exception as e: logger.error("uart open device name :%s error:%s" % (str(self.name), repr(e))) return False else: logger.info("open uart %s success fileno : %d:" % (str(self.name), self.__ser.fileno())) return True
def logupload_close_handle(params): help_info = "logupload close({<name>})$\r\n\ \tname: log's name $\r\n" ''' help ''' if utility.is_ask_for_help(params) is True: return utility.handle_done(help_info) ''' parametr analysis ''' params_count = len(params) if not params_count == 1: return utility.handle_error( utility.handle_errorno['handle_errno_parameter_invalid'], "param length error") name = params[0] if False == isinstance(name, str): return utility.handle_error( utility.handle_errorno['handle_errno_parameter_invalid'], "param error") if False == _check_log_name(name): return utility.handle_error( utility.handle_errorno['handle_errno_parameter_invalid'], "%s did not register information for upload" % (name)) context = zmq.Context() # Socket to talk to clients publisher = context.socket(zmq.PUB) # bind port try: publisher.bind('tcp://*:22730') msg = json.dumps( {b'%s' % ((name.split(".log")[0]).upper()): { b"upload": False }}) for i in range(0, 3): publisher.send(msg) time.sleep(0.1) except Exception: return utility.handle_error( utility.handle_errorno['handle_errno_execute_failure'], "open log upload error[socket invalid]") logger.info("logupload_close_handle success") return utility.handle_done()
def read_byte(self, addr, length): if self._base_addr == 0: logger.error("fpga device:%s not opened" % (self._name)) return False read_data = (ctypes.c_char * length)() status = self._libaxi4lite.sg_fpga_read(self._base_addr + addr, read_data, length) if (status < 0): logger.info("read fpga device:%s addr:0x%x length:%s fail" % (self._name, addr, length)) return False data = read_data.raw #logger.debug("read fpga device:%s addr:0x%x length:%s data : %s " #%(self._name, addr, length, logger.print_list2hex(data))) return data
def config(self, baud_rate=115200, data_bits=8, parity_type='NONE', stop_bits=1, time_insert='NONE'): """ Set uart bus parameter Args: baud_rate(int) : UART baud rate data_bits(int) : Data width 5/6/7/8 parity_type(str) : parity type. "ODD"/"EVNE"/"NONE" stop_bits(float) : stop bit width. 1/1.5/2 time_insert(str) : Insert timestamp Control, "TS"/"NONE" Returns: None """ logger.info("%s set baud_rate: %s ; data_bits: %s; stop_bits : %s ;parity: %s; time_insert: %s;"\ %(self.name, baud_rate, data_bits,stop_bits,parity_type,time_insert)) baud_rate_temp = int( pow(2, 32) * baud_rate / self.__axi4_clk_frequency) wr_data = self.__data_deal.int_2_list(baud_rate_temp, 4) self.__axi4lite.write(0x20, wr_data, len(wr_data)) if (parity_type == 'ODD'): parity_data = 0x01 elif (parity_type == 'EVNE'): parity_data = 0x00 else: parity_data = 0x02 if (stop_bits == 1): stop_bits_data = 0x04 elif (stop_bits == 1.5): stop_bits_data = 0x08 else: stop_bits_data = 0x0C data_bits_data = (data_bits - 1) << 4 wr_data_temp = parity_data | stop_bits_data | data_bits_data self.__axi4lite.write(0x24, [wr_data_temp], 1) if (time_insert == "TS"): self.__axi4lite.write(0x25, [0x01], 1) else: self.__axi4lite.write(0x25, [0x00], 1) self.__axi4lite.write(0x26, [0x11], 1) return None
def open(self): read_data = ctypes.c_uint() logger.info('open fpga device %s register number %d' % (self._name, self._register_num)) status = self._libaxi4lite.sg_fpga_open(self._name, self._register_num, ctypes.byref(read_data)) if (status < 0): logger.warning('open %s fail,return value is %d' % (self._name, status)) return False # TODO return address directly addr = read_data.value logger.info("\"%s\" map addr is %#x" % (self._name, addr)) if addr == 0: return False else: self._base_addr = addr return True
def _uart_to_net(self): uart_data = self._uart_device.read() if self._connect_socket is None: return 0 if not uart_data: return 0 else: self._total_uart_size += len(uart_data) logger.info(" read %s data byte size :%d total read size : %d"%\ (self._uartname,len(uart_data),self._total_uart_size)) try: self._connect_socket.send(bytes(uart_data)) logger.info("client %d send byte size : %d" % (self._connect_socket.fileno(), len(uart_data))) except socket.error as e: logger.warning("device %s net send error" % (self._uartname)) self._del_connect_socket() return 1
def _device_to_tcp(self): device_data = self._device.read() if self._connect_socket is None: return 0 if not device_data: return 0 else: self._total_device_size += len(device_data) logger.info("device read data byte size :%d, total read size : %d"%\ (len(device_data),self._total_device_size)) try: self._connect_socket.send(bytes(device_data)) logger.info("client %d send byte size : %d" % (self._connect_socket.fileno(), len(device_data))) except socket.error as e: logger.warning("device send to tcp port %s error" % (self._port)) self._del_connect_socket() return 1
def log_level_handle(params): help_info = "set log level({<name>},{<locallevel>,<uploadlevel>})$\r\n\ \tname: log's name $\r\n \ \tlocallevel=(debug,info,warning,error,critical)$\r\n \ \tuploadlevel=(debug,info,warning,error,critical)\r\n" levels = ["info", "debug", "warning", "error", "critical"] ''' help ''' if utility.is_ask_for_help(params) is True: return utility.handle_done(help_info) ''' parametr analysis ''' params_count = len(params) if not 3 == params_count: return utility.handle_error( utility.handle_errorno['handle_errno_parameter_invalid'], "param length error") name = "" locallevel = "" uploadlevel = "" for index in range(0, params_count): if index == 0: name = params[index] elif index == 1: locallevel = params[index] elif index == 2: uploadlevel = params[index] else: return utility.handle_error( utility.handle_errorno['handle_errno_parameter_invalid'], "param length error") if not name: return utility.handle_error( utility.handle_errorno['handle_errno_parameter_invalid'], "log's name must is not null") if locallevel not in levels: return utility.handle_error(utility.handle_errorno['handle_errno_parameter_invalid'], \ "locallevel must is one of (debug,info,warning,error,critical)") if uploadlevel and uploadlevel not in levels: return utility.handle_error(utility.handle_errorno['handle_errno_parameter_invalid'], \ "uploadlevel must is one of (debug,info,warning,error,critical)") context = zmq.Context() # Socket to talk to clients publisher = context.socket(zmq.PUB) # bind port publisher.bind('tcp://*:22730') msg = json.dumps({ b'%s' % ((name.split(".log")[0]).upper()): { b"locallevel": b"%s" % (locallevel.upper()), b"uploadlevel": b"%s" % (uploadlevel.upper()) } }) for i in range(0, 3): publisher.send(msg) time.sleep(0.1) logger.info("log_level_handle success") return utility.handle_done()
def call_handle(*params): # deal params handle_params = list(params) #print(handle_params) del handle_params[0] # get cmd list cmd_list = get_cmd_list() # logger.info("enter command") # # print cmd_list # doing if params[0] in cmd_list : # logger.info(str(params[0])) logger.info(str(handle_params)) # try: if handle_params[0]: result = cmd_list[params[0]](handle_params[0].split(',')) else: result = cmd_list[params[0]](handle_params[0]) # logger.info(str(result)+"params[0]") # except Exception as e: result = utility.handle_error(utility.handle_errorno['handle_errno_call_handle_exception'],"call handle exception") logger.info("call_handle Exception : %s"%(traceback.format_exc())) else : result = utility.handle_error(utility.handle_errorno['handle_errno_not_have_this_command'],"not have this command") # logger.info(str(result)+"result error") # # logger.info("exit command") # if not result: result = "" return result
def dut_storage_checkout(self,target_file_name,target_address,file_offset,size,instance_sequence = 0): "in:\ target_file_name:str,the file path\ target_address: unsigned int,the DUT target checkout address\ file_offset:unsigned int,loading the firmware file start address\ size:unsigned int,program size\ instance_sequence:unsigned int\ " params = {} params["target_file_name"] = target_file_name params["target_address"] =target_address params["file_offset"] =file_offset params["size"] =size params["instance_sequence"] =instance_sequence response = self.rpc_client_node.call("DutStorageCheckout",**params) # pring(response) if response["state"] < 0: logger.info(response["return"]) return dfu_common.get_error_return_state(response) #------abort? #------- params["address"] = 0x44443044 params["value"] = 0x01 response = self.rpc_client_node.call("RegWrite",**params) if response["state"] < 0: # logger.info(response["return"]) return dfu_common.get_error_return_state(response) params["address"] = 0x440090C4 params["value"] = 0x0071C030 response = self.rpc_client_node.call("RegWrite",**params) if response["state"] < 0: # logger.info(response["return"]) return dfu_common.get_error_return_state(response) params["address"] = 0x440090C8 params["value"] = 0x0071C030 response = self.rpc_client_node.call("RegWrite",**params) if response["state"] < 0: # logger.info(response["return"]) return dfu_common.get_error_return_state(response) params["address"] = 0x440090CC params["value"] = 0x0071C030 response = self.rpc_client_node.call("RegWrite",**params) if response["state"] < 0: # logger.info(response["return"]) return dfu_common.get_error_return_state(response) params["address"] = 0x440090D0 params["value"] = 0x0071C030 response = self.rpc_client_node.call("RegWrite",**params) if response["state"] < 0: # logger.info(response["return"]) return dfu_common.get_error_return_state(response) params["address"] = 0x440090D4 params["value"] = 0x0075C001 response = self.rpc_client_node.call("RegWrite",**params) if response["state"] < 0: # logger.info(response["return"]) return dfu_common.get_error_return_state(response) params["address"] = 0x440090D8 params["value"] = 0x0075C001 response = self.rpc_client_node.call("RegWrite",**params) if response["state"] < 0: # logger.info(response["return"]) return dfu_common.get_error_return_state(response) return dfu_common.get_correct_return_state(response)
subscriber = self._create_subscriber(self._sub_filters) poller = zmq.Poller() self._poller = poller poller.register(listener.fileno(), zmq.POLLIN) poller.register(subscriber, zmq.POLLIN) while not self._channel_stop: socks = dict(poller.poll()) # accept the new connect if listener.fileno() in socks: conn, addr = listener.accept() logger.info( "%s channel accept connection from %s, %d, fd = %d" % (self._name, addr[0], addr[1], conn.fileno())) if self._connector is not None: logger.error( "%s channel remote connector socket replaced by %d with %d" % (self._name, self._connector.fileno(), conn.fileno())) self.remove_connector() self._connector = conn poller.register(self._connector.fileno(), zmq.POLLIN) self._connector.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self._connector.settimeout(2) # receive packet from data acquisitor publisher
def _close(self): logger.info("close fpga device %s " % (self._name)) if self._base_addr != 0: self._libaxi4lite.sg_fpga_close(self._base_addr, self._register_num)
def _add_connect_socket(self, client): if self._connect_socket is not None: self._del_connect_socket() self._inputs.append(client) self._connect_socket = client logger.info("add connected socket fd = %d" % (client.fileno()))
def SG_sn_read_handle(params): if board_sn_list is None: get_board_sn_list() help_info = "sn read(<board_name>,)$\r\n\ \tboard-name:(" + ",".join(board_sn_list) + ")$\r\n" ''' default operation ''' key_n = 247 key_d = 11 ''' help ''' if utility.is_ask_for_help(params) is True: return utility.handle_done(help_info) ''' params analysis ''' param_count = len(params) if param_count != 1: return utility.handle_error( utility.handle_errorno["handle_errno_parameter_invalid"], "param length error") for index in range(0, param_count): if index == 0: board_name = params[0] if board_name not in board_sn_list: return utility.handle_error( utility.handle_errorno["handle_errno_parameter_invalid"], "param board_name error") result = "" if board_name == "zynq": if os.path.exists(sn_file_name): logger.info("sn file is exist ") #1) file exist : read vendor message with open(sn_file_name) as sn_file: result = list(sn_file.read(sn_max_len)) sn_file.close() for index in range(0, len(result)): result[index] = ord(result[index]) else: result = Xavier.call('eeprom_read', board_name, sn_address, sn_max_len) if result is False: return utility.handle_error( utility.handle_errorno["handle_errno_execute_failure"], "read failed") msg = "" msg += '\"' result_flag = True for index in range(0, len(result)): if result[index] == 0x00: break de_crypt = pow(result[index], key_d) % key_n if de_crypt & 0x80 != 0x00: result_flag = False msg += chr(de_crypt) msg += '\"' msg += '\0' if result_flag: return utility.handle_done(msg) else: return utility.handle_error( utility.handle_errorno["handle_errno_crc_checksum_failure"], msg)