def get_dev_path(channel, chip_type): global _g_fwdl_config_list logger.warning(chip_type) protocol_name = None if _g_fwdl_config_list != None: for key in _g_fwdl_config_list["protocol_chip_support"].keys(): for item in _g_fwdl_config_list["protocol_chip_support"][key]: if chip_type == item: protocol_name = key logger.warning(protocol_name) break if protocol_name == key: break if protocol_name == None: return False dev_path = _g_fwdl_config_list["support_channel"][channel][ "protocol_driver_config"][protocol_name] spi_switch = _g_fwdl_config_list["support_channel"][channel][ "protocol_driver_config"]["spi_switch"] if spi_switch != "none": gpio_dev = Axi4Gpio("/dev/AXI4_GPIO_0") gpio_dev.gpio_set(eval(spi_switch)) logger.warning(protocol_name) logger.warning(dev_path) if os.path.exists(dev_path): logger.warning(dev_path) return dev_path else: return False return False
def dut_initial(self,instance_sequence = 0): "in:\ instance_sequence:unsigned int" params = {} params["instance_sequence"] = instance_sequence params["hearst_dut"] = 0 response = self.rpc_client_node.call("DutExit",**params) # pring(response) if response["state"] < 0: return dfu_common.get_error_return_state(response) response = self.rpc_client_node.call("DutInitial",**params) # pring(response) if response["state"] < 0: # logger.info(response["return"]) return dfu_common.get_error_return_state(response) #halt the system params["address"] = 0xE000EDF0 params["value"] = 0xA05F0003 response2 = self.rpc_client_node.call("RegWrite",**params) if response2["state"] < 0: # logger.info(response["return"]) return dfu_common.get_error_return_state(response2) logger.warning(response2["return"]) #read system state response2 = self.rpc_client_node.call("RegRead",**params) if response2["state"] < 0: # logger.info(response["return"]) return dfu_common.get_error_return_state(response2) logger.warning(response2["return"]) return dfu_common.get_correct_return_state(response)
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() # print cmd_list # doing if params[0] in cmd_list: try: if handle_params[0]: result = cmd_list[params[0]](handle_params[0].split(',')) else: result = cmd_list[params[0]](handle_params[0]) except Exception as e: result = utility.handle_error( utility.handle_errorno['handle_errno_call_handle_exception'], "call handle exception") logger.warning("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") if not result: result = "" return result
def get_channel(channel_name): global data_channels if channel_name in data_channels.keys(): return data_channels[channel_name] else: logger.warning("the %s channel does not exist" % (channel_name)) return False
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 ad7175_voltage_measure(self, channel): """Get voltage measure channel result Returns: result:(value,unit) value: voltage measure value unit: ('uV','mV','V') """ if not self.ad7175_device.samplerate_set( channel, self.profile["adc7175_samplerate"]): logger.warning( "%s AD7175[ chip voltage channel samplerate configure failed") return False if self.ad7175_device.voltage_channel_disable("all") is False: logger.warning( "ad7175[%s] chip channel reg all disable config failed" % (self.profile["adc7175_path"])) return False if not self.ad7175_device.single_sample_mode(): logger.warning("set ad7175 signal sample is false") return False # self.ad7175_device.voltage_channel_enable(channel,self.profile["adc7175_config"][channel]) # logger.warning(str(self.profile["adc7175_config"][channel])) if channel not in self.profile["adc7175_config"]: logger.warning("channel parameter error") return False volt = self.ad7175_device.voltage_get( channel, self.profile["adc7175_config"][channel]) if volt is False: logger.warning("ad7175 voltage measure voltage get failed!") return False return volt
def write_bytes(self, data): """ write byte string data to uart Args: data(string) : a string of bytes data Returns: on success, return True on error, return False """ if self.get_uart_status() is False: self._close() return False elif self.__is_use is False: return False elif self.is_open is False: self._open() length = len(data) logger.debug("write uart %s length:%d" % (self.name, length)) try: writen_len = self.__ser.write(data) except Exception as e: logger.error("write uart %s length:%d error:%s" % (self.name, length, repr(e))) return False if (writen_len != length): logger.warning( "write uart device:%s length fail,except length:%s, reality length:%s" % (self.name, length, writen_len)) return False return True
def single_sample_code_get(self): """ ADC chip single sample Returns: (channel,sample_code) """ rd_data = self.register_read(0x01) wr_data = rd_data & 0xFF0F | 0x0000 self.register_write(0x01, wr_data) rd_data = self.register_read(0x01) if ((rd_data & 0x00F0) != 0): logger.warning("AXI4 AD717X 0x01 ==%s" % (hex(rd_data))) return False wr_data = rd_data & 0xFF0F | 0x0010 self.register_write(0x01, wr_data) reg_data = self.register_read(0x04) rd_data = self.__axi4lite.read(0x26, 1) if (rd_data[0] & 0x08 == 0x08): sample_channel = (reg_data & 0x0000000F) sample_data = (reg_data & (0xFFFFFF00)) >> 8 else: sample_channel = 'Null' sample_data = reg_data & (0x00FFFFFF) return (sample_channel, sample_data)
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 register_read(self, reg_addr): """ Read value from ADC chip register Args: reg_addr: ADC chip register address(0x00-0xff) Returns: register value: (0x00-0xffffffff) """ rd_data = self.__axi4lite.read(0x26, 1) if (rd_data[0] & 0x01 == 0x00): logger.warning('AD717X Bus is busy now') return False com_data = (0x3F & reg_addr) | 0x40 wr_data = [com_data, 0x01] self.__axi4lite.write(0x24, wr_data, len(wr_data)) rd_data = [0x00] timeout_cnt = 0 while (rd_data[0] & 0x01 == 0x00) and (timeout_cnt < 1000): time.sleep(0.001) timeout_cnt = timeout_cnt + 1 rd_data = self.__axi4lite.read(0x26, 1) if (timeout_cnt == 1000): logger.warning('AD717X read register wait timeout') return False rd_data = self.__axi4lite.read(0x28, 4) rd_data = rd_data[0] | (rd_data[1] << 8) | (rd_data[2] << 16) |\ (rd_data[3] << 24) return rd_data
def register_write(self, reg_addr, reg_data): """ Write value to ADC chip register Args: reg_addr: ADC chip reg (0x00-0xff) reg_data: register value(0x00-0xffffffff) Returns: True | False """ rd_data = self.__axi4lite.read(0x26, 1) if (rd_data[0] & 0x01 == 0x00): logger.warning('AD717X Bus is busy now') return False wr_data = self.__data_deal.int_2_list(reg_data, 4) com_data = (0x3F & reg_addr) wr_data.append(com_data) wr_data.append(0x01) self.__axi4lite.write(0x20, wr_data, len(wr_data)) rd_data = [0x00] timeout_cnt = 0 while (rd_data[0] & 0x01 == 0x00) and (timeout_cnt < 1000): time.sleep(0.001) rd_data = self.__axi4lite.read(0x26, 1) timeout_cnt = timeout_cnt + 1 if (timeout_cnt == 1000): logger.warning('AD717X write register wait finish timeout') return False return True
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 continue_sample_capture(self): """ read continue sampld data Args: None Returns: sample_data(list): sample data """ rd_data = self.__axi4lite.read(0x26, 1) sample_state = rd_data[0] & 0x04 if (sample_state == 0): logger.warning('AD717X not in continue sample mode') return False self.__axi4lite.write(0x11, [0x01], 1) rd_data = self.__axi4lite.read(0x12, 1) if (rd_data[0] & 0x02 == 0x00): logger.warning('AD717X capture fifo reset failt') return False self.__axi4lite.write(0x11, [0x00], 1) time_out = 0 while time_out < 300: rd_data = self.__axi4lite.read(0x12, 1) if rd_data[0] & 0x01 == 0x01: break else: time_out = time_out + 1 time.sleep(0.01) if time_out == 3000: logger.error('@%s: capture data time out' % (self.name)) return False receive_list = self.__axi4lite.read_array(0x60, 2048, 32) return receive_list
def spi_config(bus_name, clk_frequency, clk_type, wait_time_us=1, spi_clk_polarity='high'): logger.warning( "spi config -->bus_name:%s, clk_frequency:%s, clk_type:%s, wait_time_us:%s " % (bus_name, clk_frequency, clk_type, wait_time_us)) """ Set spi bus parameter Args: spi_clk_frequency(int): spi bus clock frequency, unit is Hz spi_clk_type(str): 'pos' --sclk posedge send data, sclk negedge receive data 'neg' --sclk negedge send data, sclk posedge receive data wait_time_us(float): the wait time for new spi access spi_clk_polarity(str): 'high' --when CS is high, the SCLK is high 'low' --when CS is high, the SCLK is low Returns: None """ try: profile = Profile.get_bus_by_name(bus_name) bus = SpiFactory.create_object(SpiFactory, profile["path"]) return bus.config(clk_frequency, clk_type, wait_time_us, spi_clk_polarity) except Exception as e: logger.error("execute module spi_config False:" + repr(e)) return False
def data_analysis(self, data_count): """ Adc sample data analysis Args: data_count(int): sample data count Returns: get_data(list): sample data list """ rd_data = self.__axi4lite.read(0x26, 1) if ((rd_data[0] & 0x04) != 0x04): logger.warning('AD717X is not in continuous sample mode') return False wr_data = self.__data_deal.int_2_list(data_count, 2) self.__axi4lite.write(0x61, wr_data, len(wr_data)) self.__axi4lite.write(0x60, [0x01], 1) rd_data = [0x00] while (rd_data[0] & 0x01 == 0x00): time.sleep(0.001) rd_data = self.__axi4lite.read(0x63, 1) get_data = [] for i in range(0, data_count): #rw_addr = i + 0x1000; rw_addr = i * 4 + 0x1000 rd_data = self.__axi4lite.read(rw_addr, 4) #rd_int = self.__data_deal.list_2_int(rd_data) rd_int = rd_data[0] | (rd_data[1] << 8) | (rd_data[2] << 16) |\ (rd_data[3] << 24) #rd_int = rd_int - 0x8000 get_data.append(rd_int) return get_data
def rdwr(self, dev_addr, write_data_list, read_length): logger.debug( "rdwr i2c device %s addr:0x%x write length:%d data:%s read length:%d" % (self._name, dev_addr, len(write_data_list), logger.print_list2hex(write_data_list), read_length)) if not self.__open(): return False write_length = len(write_data_list) write_data = (ctypes.c_ubyte * write_length)(*write_data_list) read_data = (ctypes.c_char * read_length)() status = self._bus.sg_i2c_rdwr(self._fd, dev_addr, write_data, write_length, read_data, read_length) self.__close() if (status < 0): logger.warning( "rdwr i2c device %s addr:0x%x write length:%d data:%s read length:%d fail" % (self._name, dev_addr, len(write_data_list), logger.print_list2hex(write_data_list), read_length)) return False data = list(struct.unpack('%dB' % read_length, read_data.raw)) return data
def __set_gateway(net_information): if net_information: gate_str = "route add default gw " + net_information result = subprocess.Popen(gate_str, shell=True, stderr=subprocess.PIPE) strout, strerr = result.communicate() if strerr: logger.warning("set gateway %s False." % (net_information)) return False
def _create_conn(self): if self._mode == "tcp": return self.__create_tcp_conn() elif self._mode == "zmq": return self.__create_req_conn() else: logger.warning("no support mode:%s" % (msg_json["mode"])) return None
def run(self): try: if self._log: logger.init(self._log) self.__run() except Exception: logger.warning(traceback.format_exc()) return None
def __set_mask(net_information): if net_information: mask_str = "ifconfig eth0 netmask " + net_information result = subprocess.Popen(mask_str, shell=True, stderr=subprocess.PIPE) strout, strerr = result.communicate() if strerr: logger.warning("set mask %s Failed." % (net_information)) return False
def write(self, memory_addr, data): """ Write datas to EEPROM Args: memory_addr: memory address (0x0000-0xffff) data: list type [data1,...,data_n] Returns: bool: True | False, True for success, False for failed or to more data to write. """ write_len = len(data) if memory_addr + write_len > self._chip_size: logger.warning("no more then %s to write " % (str(self._chip_size))) return False data = list(data) write_addr = memory_addr write_bytes = 0 logger.debug("cat24cxx write " + str(write_addr) + ' len ' + str(write_len)) if write_len > self._page_size or (write_addr & (self._page_size - 1)) != 0: write_bytes = self._page_size - (write_addr & (self._page_size - 1)) else: write_bytes = write_len while write_len > 0: if self._device_type == "cat04" or self._device_type == "cat08" or self._device_type == "cat16": device_addr = self._device_addr | ( (write_addr >> 8) & self._mask) else: device_addr = self._device_addr mem_addr = self._memory_address_to_byte_list(write_addr) #FPGA i2c bus a frame max size is 32 bytes data. if write_bytes > (32 - 1 - len(mem_addr)): write_bytes = 32 - 1 - len(mem_addr) write_data = data[0:write_bytes] ret = self.iic_bus.write(device_addr, mem_addr + write_data) if not ret: return False del data[0:write_bytes] write_len -= write_bytes write_addr += write_bytes if write_len > self._page_size: write_bytes = self._page_size else: write_bytes = write_len time.sleep(cat24cxx_list[self._device_type]["wdelay"]) return True
def spi_enable(bus_name): logger.warning("spi enable -->bus name:%s " % (bus_name)) try: profile = Profile.get_bus_by_name(bus_name) bus = SpiFactory.create_object(SpiFactory, profile["path"]) return bus.enable() except Exception as e: logger.error("execute module spi_enable False:" + repr(e)) return False
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 read(self, memory_addr, length): """ Read datas from EEPROM Args: memory_addr: memory address (0x0000-0xffff) length: How many data you want to read int type Returns: False: read failed or too more data to read or list type: read data [data1,data2,...,datan] """ if memory_addr + length > self._chip_size: logger.warning("no more then %s to read" % (str(self._chip_size))) return False read_len = length read_addr = memory_addr read_bytes = 0 if (read_addr & (self._page_size - 1)) + read_len > self._page_size: read_bytes = self._page_size - (read_addr & (self._page_size - 1)) else: read_bytes = read_len result = [] while read_len > 0: if self._device_type == "cat04" or self._device_type == "cat08" or self._device_type == "cat16": device_addr = self._device_addr | ( (read_addr >> 8) & self._mask) else: device_addr = self._device_addr #memory address to list data type mem_addr = self._memory_address_to_byte_list(read_addr) #FPGA i2c bus a frame max size is 32 bytes data. if read_bytes > (32 - 1 - len(mem_addr)): read_bytes = 32 - 1 - len(mem_addr) read_result = self.iic_bus.rdwr(device_addr, mem_addr, read_bytes) if not read_result: return False result += read_result read_len -= read_bytes read_addr += read_bytes if read_len > self._page_size: read_bytes = self._page_size else: read_bytes = read_len return result
def create_target(self,dev_path,what_chip,frequency_hz): ret_str = "\r\n------------------------------------\r\n" ret_str += "Operating " #traverse #if rpc server support the chip type arch_type = dfu_common.get_chip_arch_type_support(self.dfu_rpc_node) for arch_keys in arch_type.keys(): chip_type = dfu_common.get_chip_type_support(self.dfu_rpc_node,arch_type[arch_keys]) if what_chip in chip_type.keys(): if arch_keys == "stm32": self.prog_instance = Stm32Prog(self.dfu_rpc_node) elif arch_keys == "cortexm": self.prog_instance = CortexMProg(self.dfu_rpc_node) elif arch_keys == "psoc4": self.prog_instance = Psoc4Prog(self.dfu_rpc_node) elif arch_keys == "nrf5xble": self.prog_instance = Nrf5XProg(self.dfu_rpc_node) elif arch_keys == "spiflash": self.arch_type = "spiflash" self.prog_instance = SpiFlash(self.dfu_rpc_node) elif arch_keys == "otp": self.arch_type = "otp" self.prog_instance = OtpProg(self.dfu_rpc_node) break #if other instance support the chip type if self.prog_instance == None: logger.warning("create other instance") if what_chip == "hearst": self.prog_instance = HearstProg(self.dfu_rpc_node) arch_keys = "cortexm" self.arch_type = "cortexm" else: ret_str += "error ,do not support this device ." return False,ret_str ret_str += arch_keys+":"+what_chip+"........\r\n" #create instance ret_str += "create target.....\r\n" ret = self.prog_instance.create_instance(dev_path,what_chip)#[0] true/false,[1] type,[2] return # ret_str += _return_to_str(ret) if ret[0] == False: self.destroy_target() return False,ret_str #instance initial ret = self.prog_instance.instance_initial(frequency_hz) ret_str += _return_to_str(ret) if ret[0] == False: self.destroy_target() return False,ret_str return True,ret_str
def get_prog_rpc_node(channel): global _g_fwdl_config_list prog_rpc_node = False if _g_fwdl_config_list != None: server_ip = _g_fwdl_config_list["support_channel"][channel][ "rpc_server_config"]["ip"] server_port = _g_fwdl_config_list["support_channel"][channel][ "rpc_server_config"]["port"] prog_rpc_node = Xavier.XavierRpcClient(server_ip, server_port, "tcp") logger.warning(server_ip) logger.warning(str(server_port)) return prog_rpc_node return False
def eval(self, name, method, *args, **kwargs): try: obj = XObject.get_object(name) func = getattr(obj, method) if args: result = func(*args) elif kwargs: result = func(**kwargs) else: result = func() except Exception: logger.warning("%s" % (traceback.format_exc())) return result
def write_byte(self, addr, data, length): if self._base_addr == 0: logger.error("fpga device:%s not opened" % (self._name)) return False status = self._libaxi4lite.sg_fpga_write(self._base_addr + addr, ctypes.c_char_p(data), length) if (status < 0): logger.warning("write fpga device:%s addr:0x%x length:%d fail" % (self._name, addr, length)) return False return True
def swd_freq_set(bus_id, freq_data): logger.warning("swd freq set ---> %s" % list((bus_id, freq_data))) """ Set swd clk freq parameter Args: freq_data(int): swd bus clock frequency, unit is Hz Returns: None """ try: profile = Profile.get_bus_by_name(bus_id) bus = SwdFactory.create_object(SwdFactory, profile["path"]) return bus.swd_freq_set(freq_data) except Exception as e: logger.error("execute module swd freq set False:" + repr(e)) return False