def action_init(self, kwargs):
testcasexml = kwargs.get("testcase")
node = self.parameter.find(self.item_type)
node = analyse_fw_node(testcasexml, node, self.item_type)
#node_combined = analyse_ses_command_node(testcasexml, node, self.item_type)
# Set command
name = node.find("version").get("name")
version = node.find("version").get("ver")
item = {name: version}
self.dict.update(item)
cmd_node = node.find("cmd")
cmd = cmd_node.get("value")
cmd_timeout = cmd_node.get("timeout")
cmd_recv = cmd_node.get("recv")
self.product_id = node.find("product_id").get("name")
proxy = node.get("proxy")
if proxy == "uart":
uart_node = node.find("uart")
uart_port = uart_node.get("port")
uart_baudrate = uart_node.get("baudrate")
uart_timeout = uart_node.get("timeout")
uart_end_of_line = uart_node.get("end-of-line")
endmarks = []
for endmark_node in node.findall("end-mark"):
endmark = endmark_node.get("keyword")
endmarks.append(endmark)
error_filters = []
for error_filter_node in node.findall("error-filter"):
error_filter = command.ErrorFilters[error_filter_node.get(
"type")](error_filter_node.get("operation"),
error_filter_node.get("value"))
error_filters.append(error_filter)
self.cmd = lsises.LSICommand(cmd, uart_port, uart_baudrate,
uart_timeout, uart_end_of_line,
cmd_timeout, cmd_recv, endmarks,
error_filters)
elif proxy == "uart-daemon":
self.cmd = SESCommandUartDaemon()
else:
raise ValueError("Unknown proxy type '%s'", proxy)
list_cmd = [
"cmdsvr_mode 0", "dbg set on", "dd_dbg -gpio r 9",
"dd_dbg -gpio r 10", "cmdsvr_mode 1"
]
self.list = []
for opt in list_cmd:
cmd_opt = lsises.LSICommand(opt, uart_port, uart_baudrate,
uart_timeout, uart_end_of_line,
cmd_timeout, cmd_recv, endmarks,
error_filters)
self.list.append(cmd_opt)
return True
def action_init(self, kwargs):
testcasexml = kwargs.get("testcase")
node = self.parameter.find(self.item_type)
node_combined = analyse_i2c_node(testcasexml, node, self.item_type)
cmd_timeout = int(node_combined.get("timeout"))
proxy = node_combined.get("proxy")
# Set command
bus = int(node_combined.find("ChannelNumber").get("value"), 0)
chip = hex(int(node_combined.find("SlaveAddress").get("value"), 0))
self.data_len = int(
node_combined.find("number_bytes_to_read").get("value"), 0)
writedata = node_combined.find("WriteData").get("value")
cmd = "iicwr " + chip + " " + str(bus) + " " + str(
self.data_len) + " " + writedata
# Set condition_type
self.condition_type = node_combined.get("condition_type").lower()
if (self.condition_type == "and") or (self.condition_type == "or"):
pass
else:
raise ValueError("Unknown I2C condition type '%s'",
self.condition_type)
#set condition
for cnode in node_combined.findall("condition"):
operation = cnode.get("operation")
value_type = cnode.get("value_type")
value = cnode.get("value")
self.conditions.append(I2CCondition(value_type, operation, value))
#send command
if proxy == "uart":
uart_node = node_combined.find("uart")
uart_port = uart_node.get("port")
uart_baudrate = uart_node.get("baudrate")
uart_newline_transmit = uart_node.get("new_line_transmit")
endmarks = []
for endmark_node in node_combined.findall("end-mark"):
endmark = endmark_node.get("keyword")
endmarks.append(endmark)
error_filters = []
for error_filter_node in node_combined.findall("error-filter"):
error_filter = command.ErrorFilters[error_filter_node.get(
"type")](error_filter_node.get("operation"),
error_filter_node.get("value"))
error_filters.append(error_filter)
self.cmd = lsises.LSICommand(cmd, uart_port, uart_baudrate, None,
uart_newline_transmit, cmd_timeout,
None, endmarks, error_filters)
elif proxy == "uart-daemon":
_LOGGER.info("uart-daemon not support")
else:
raise ValueError("Unknown proxy type '%s'", proxy)
return True
def check_block(self):
"""
return checked length
> 0, SUCCESS,checked length
= 0, SUCCESS,EOF
< 0, ERROR
"""
remain_bytes = self.number_bytes_to_do - self.number_bytes_done
if remain_bytes <= 0:
return 0
#build and apply cmd
offset_str = get_offset_bytes(self.offset + self.number_bytes_done, self.offset_width)
read_bytes = min(self.block_size, remain_bytes)
cmd = "iicwr" + " " + self.device_addr + " " + (str(self.port_id)) + " " + (str(read_bytes)) + " " + offset_str
_LOGGER.info("%s ", cmd)
self.cmd = lsises.LSICommand( cmd, self.uart_port,
self.uart_baudrate, None,
self.uart_newline_transmit,
self.cmd_timeout, None,
self.endmarks, self.error_filters)
if _UNIT_TEST is not None:
raw_value = apply()
else:
raw_value = self.cmd.apply()
#convert and check value length
value = extract_rawdata(raw_value)
if value == "":
_LOGGER.info("Error: No value read from UART!")
return -1
ret_bytes = len(value)/2
if ret_bytes != read_bytes:
_LOGGER.info("Error: read %d bytes but return %d bytes!", read_bytes, ret_bytes)
return -2
#compare return values
if self.binary_fd is not None:
compare_value = self.binary_fd.read(read_bytes * 2)
if compare_value != value:
_LOGGER.info("Error: read data differ with file data!")
_LOGGER.info("Read data: %s", value)
_LOGGER.info("File data: %s", compare_value)
return -3
if self.binary_data != None:
compare_value=""
for i in range(0, read_bytes):
compare_value += self.binary_data
if compare_value != value:
_LOGGER.info("Error: read data differ with set binary_data!")
_LOGGER.info("Read data: %s", value)
_LOGGER.info("Binary_data: %s", compare_value)
return -4
self.number_bytes_done += read_bytes
return read_bytes
def write_block(self):
"""
return writed length
> 0, SUCCESS,writen length
= 0, SUCCESS,EOF
< 0, ERROR
"""
remain_bytes = self.number_bytes_to_do - self.number_bytes_done
if remain_bytes <= 0:
return 0
offset_str = get_offset_bytes(self.offset + self.number_bytes_done, self.offset_width)
write_bytes = min(self.block_size, remain_bytes)
#build write values
write_values=""
if self.binary_fd is not None:
file_values = self.binary_fd.read(write_bytes * 2)
write_bytes = len(file_values)
if write_bytes==0 or write_bytes%2!=0:
_LOGGER.info("Error: read file return EOF or odd number data:%s", file_values)
return -1;
write_bytes /= 2
for i in range(0, write_bytes):
write_values += file_values[i*2] + file_values[i*2+1] + " "
elif self.binary_data != None:
for i in range(0, write_bytes):
write_values += self.binary_data + " "
else:
_LOGGER.info("Error: No binary_file or binary_data set!")
return -1
#build and apply cmd
cmd = "iicw" + " " + self.device_addr + " " + (str(self.port_id)) + " " + offset_str + " " + write_values
_LOGGER.info("%s ", cmd)
self.cmd = lsises.LSICommand( cmd, self.uart_port,
self.uart_baudrate, None,
self.uart_newline_transmit,
self.cmd_timeout, None,
self.endmarks, self.error_filters)
if _UNIT_TEST is not None:
raw_value = apply()
else:
raw_value = self.cmd.apply()
self.number_bytes_done += write_bytes
return write_bytes
def read_block(self):
"""
return readed length
> 0, SUCCESS,readed length
= 0, SUCCESS,EOF
< 0, ERROR
"""
remain_bytes = self.number_bytes_to_do - self.number_bytes_done
if remain_bytes <= 0:
return 0
#build and apply cmd
offset_str = get_offset_bytes(self.offset + self.number_bytes_done, self.offset_width)
read_bytes = min(self.block_size, remain_bytes)
cmd = "iicwr" + " " + self.device_addr + " " + (str(self.port_id)) + " " + (str(read_bytes)) + " " + offset_str
_LOGGER.info("%s ", cmd)
self.cmd = lsises.LSICommand( cmd, self.uart_port,
self.uart_baudrate, None,
self.uart_newline_transmit,
self.cmd_timeout, None,
self.endmarks, self.error_filters)
if _UNIT_TEST is not None:
raw_value = apply()
else:
raw_value = self.cmd.apply()
#convert and check value length
value = extract_rawdata(raw_value)
if value == "":
_LOGGER.info("Error: No value read from UART!")
return -1
ret_bytes = len(value)/2
if ret_bytes != read_bytes:
_LOGGER.info("Error: read %d bytes but return %d bytes!", read_bytes, ret_bytes)
return -2
#store value to file
if self.binary_fd is not None:
self.binary_fd.write(value)
self.number_bytes_done += read_bytes
return read_bytes