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
