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)
