def handler_ukcu_generate_rw(log, parsing_data, param_data) -> list:
code, packet_data = parsing_data
request_data, response_data, control_gui = param_data
ukcu_code_patch = globals().get('config_vars').get('ukcu_code_patch')
ukcu_shell_packets = globals().get('config_vars').get('ukcu_shell_packets')
# log.error('--- rw ---- {}'. format(len(globals().get('config_vars').get('ukcu_shell_packets'))))
if ukcu_code_patch[0] == request_data[0]:
cmd_hex = hex(ukcu_code_patch[0])[2:].upper()
if code == UKCU_COMMANDS.get(UKCU_SET_SIGNALS):
log.error(' * CODE: "0x{}", DOC: "{}"'.format(cmd_hex, request_data[1]))
ukcu_kvitok = globals().get('config_vars').get('ukcu_kvitok')
ukcu_code_patch[1] = False
return [str_hex2byte(ukcu_kvitok[0])]
ukcu_clear_shell_packets = globals().get('config_vars').get('ukcu_clear_shell_packets')
if isinstance(response_data, list) and len(response_data) == 2:
if ukcu_shell_packets[-2] == UKCU_READ_LOW_ADDRESS:
data = response_data[0]
elif ukcu_shell_packets[-2] == UKCU_READ_HIGH_ADDRESS:
data = response_data[1]
if len(ukcu_shell_packets) == 4:
ukcu_clear_shell_packets[0] = True
else:
data = 0 if response_data is None else response_data
ukcu_clear_shell_packets[0] = True
data_hex = hex(data)[2:].upper()
if ukcu_shell_packets[-2] == UKCU_READ_LOW_ADDRESS:
log.error('* Ответ на "0x{}" чтение мл. адреса: 0x{}'.format(cmd_hex, data_hex))
elif ukcu_shell_packets[-2] == UKCU_READ_HIGH_ADDRESS:
log.error('* Ответ на "0x{}" чтение стар. адреса: 0x{}'.format(cmd_hex, data_hex))
return [UkcuPacket(UKCU_RESP_REPLY, data << 8).to_bytes()]
def request_parser(request):
if not isinstance(request, str):
return None
str_packet_pure = re.sub(r'[: _]', '', request)
strbyte = bytearray.fromhex(str_packet_pure)
strhex = str_hex2byte(strbyte)
print(strbyte, strhex)
return strbyte
def handler_ukcu_reply_kvitok(log, parsing_data, param_data) -> list:
code, packet_data = parsing_data
request_data, response_data, control_gui = param_data
ukcu_shell_packets = globals().get('config_vars').get('ukcu_shell_packets')
ukcu_kvitok = globals().get('config_vars').get('ukcu_kvitok')
ukcu_code_patch = globals().get('config_vars').get('ukcu_code_patch')
# if code == UKCU_COMMANDS.get(UKCU_SET_SIGNALS) and len(ukcu_shell_packets) <= 8:
if code == UKCU_COMMANDS.get(UKCU_SET_SIGNALS) and len(ukcu_shell_packets) < 8 and not ukcu_code_patch[1]:
# log.error('======== kvitok ====== {} '.format(len(globals().get('config_vars').get('ukcu_shell_packets'))))
return [str_hex2byte(ukcu_kvitok[0])] # code: 0x011F, data: 0x1000100
def __generate_list_response(self, handler_dict_response, order, response, param_info):
list_resp = []
if isinstance(handler_dict_response, dict):
func_handler_response = load_handler(self.config_vars, **handler_dict_response)
if order == CH_ORDER_GENERATOR:
if isinstance(func_handler_response, list):
return func_handler_response, response
else:
return [func_handler_response], response
elif order == CH_ORDER_ZIP or order == CH_ORDER_SEMIDUPLEX:
return self.__genearate_list_packet(handler_dict_response, response, param_info)
else:
raise ValueError('!ERROR: wrong option "{}" for this settings. Using: {}'.format(order, set(
CHLIST_ORDER).symmetric_difference({CH_ORDER_GENERATOR_FULL})))
elif isinstance(response, list):
for resp in response:
list_resp.append(str_hex2byte(resp))
else:
list_resp.append(str_hex2byte(response))
return list_resp
def __genearate_list_packet(self, handler_func_dict, data_packet, param_info):
list_packet = []
doc, order, index = param_info
if isinstance(handler_func_dict, dict):
if handler_func_dict.get('module_name') and handler_func_dict.get('function_name'):
func_handler = load_handler(self.config_vars, **handler_func_dict)
try:
for func in func_handler:
if data_packet is None:
res = func(self._log)
else:
res = func(self._log, data_packet)
if res:
list_packet.extend(res)
except TypeError as e:
raise TypeError("Wrong defined type order interaction: doc={0}, order={1}, index = {2}, {3}".format(
doc, order, index, e.args))
else:
raise TypeError(
"Don't defined handler function: doc={0}, order={1}, index = {2}. Use keyword {3}".format(
doc, order, index, [KW_HANDLER_RESPONSE, KW_HANDLER_REQUEST]))
elif isinstance(data_packet, list):
for req in data_packet:
list_packet.append(str_hex2byte(req))
elif isinstance(data_packet, str):
list_packet.append(str_hex2byte(data_packet))
elif order == CH_ORDER_ZIP:
raise ValueError(
'!ERROR: not defined keyword "handler_request" for order = "{}": doc={}, data={}, index = {}'.format(
CH_ORDER_ZIP, doc, data_packet, index))
else:
raise ValueError(
'!Error: invalid type "req/resp" data for parsing (str, list, dict): doc={}, data={}, order={}, index ={}'.format(
doc, data_packet, order, index))
return list_packet
def handler_response(self, logger, bytes_recv, control_gui=None) -> [bytes]:
"""
:param bytes_recv: received bytes array
:return: list of bytes for writing to serial port or None to send nothing
:rtype: bytes
"""
is_not_found_packet = False
while self.__count_protocol < self.__len_list_protocol:
cmd = self.__lists_protocol[self.__count_protocol]
order = cmd[0]
list_req = cmd[1]
doc = cmd[3]
delay = cmd[5]
logger.debug("*** seek ---- order = {}, doc = {}".format(order, doc))
if order == "generator" and self.__count_req_generator_packet >= 0 and \
self.__count_req_zip_packet == 0 and self.__count_req_semiduplex_packet == 0:
list_generator_resp, response = cmd[2]
result = self.__process_generation_reponse(logger,
(list_generator_resp, response, list_req, bytes_recv),
(doc, order))
if result:
self.__delay_response(logger, delay)
return result
elif order == "zip" and self.__count_req_zip_packet >= 0 and \
self.__count_req_generator_packet == 0 and self.__count_req_semiduplex_packet == 0:
list_resp = cmd[2]
result = self.__process_zip_response(logger, (list_resp, list_req, bytes_recv), (doc, order))
if result:
self.__delay_response(logger, delay)
return result
elif order == "semiduplex" and self.__count_req_semiduplex_packet >= 0 and \
self.__count_req_generator_packet == 0 and self.__count_req_zip_packet == 0:
list_resp = cmd[2]
result = self.__process_semiduplex_response(logger, (list_resp, list_req, bytes_recv), (doc, order))
if result is not None:
self.__delay_response(logger, delay)
return result
if self.__count_protocol == self.__len_list_protocol - 1:
if self.__count_req_semiduplex_packet == 0 and \
self.__count_req_generator_packet == 0 and self.__count_req_zip_packet == 0:
is_not_found_packet = True
self.__count_protocol = 0
break
else:
self.__count_protocol += 1
else:
logger.error("Error: List protocol did not loaded. It is empty")
if len(self.__list_gen_full) > 0:
result = self.__process_full_generate_response_with_parser(logger, bytes_recv, control_gui)[0]
if result:
return result
if is_not_found_packet:
logger.error(
"!! Not found command of packet: {}, "
"amount viewed protocol command's = {} of {}".format(
str_hex2byte(bytes_recv), self.__count_protocol + 1, self.__len_list_protocol))