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)["psoc4"]
chip_type = dfu_common.get_chip_type_support(self.rpc_client_node,
arch_type)[what_chip]
logger.info(dfu_common.get_protocol_type_support(self.rpc_client_node))
logger.info(dfu_common.get_chip_arch_type_support(
self.rpc_client_node))
logger.info(
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 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 list_support_target(self):
support_chip = ""
#from the rpc server get support
arch_type = dfu_common.get_chip_arch_type_support(self.dfu_rpc_node)
for arch_keys in arch_type.keys():
support_chip += arch_keys+":"
chip_type = dfu_common.get_chip_type_support(self.dfu_rpc_node,arch_type[arch_keys])
for chip_keys in chip_type.keys():
support_chip += chip_keys+" "
pass
#from the python layer get support
support_chip += HearstProg.chip_type_name()
support_chip += "\r\n"
#print(support_chip)
return True,support_chip
def distinguish_chip_architecture(self,what_chip,arch_type):
arch_type = dfu_common.get_chip_arch_type_support(self.dfu_rpc_node)
#if rpc server support the chip type
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 == arch_type:
return True
else:
return False
#if other instance support the chip type
arch_keys = None
if what_chip == "hearst":
self.prog_instance = HearstProg(self.dfu_rpc_node)
arch_keys = "cortexm"
if arch_keys == arch_type:
return True
else:
return False
return False