def send_request(self, input_payload):
from PyCRC.CRC16 import CRC16
crc = CRC16(modbus_flag=True).calculate(bytes(input_payload))
# first byte is length, +2 for CRC16
request_payload = bytearray([len(input_payload) + 2, 0x00])
request_payload.extend(input_payload)
# append CRC
request_payload.append(crc & 0xFF)
request_payload.append((crc >> 8) & 0xFF)
# send to device
response = self.send_packet(0x6a, request_payload)
# check for error
err = response[0x22] | (response[0x23] << 8)
if err:
raise ValueError('broadlink_response_error', err)
response_payload = bytearray(self.decrypt(bytes(response[0x38:])))
# experimental check on CRC in response (first 2 bytes are len, and trailing bytes are crc)
response_payload_len = response_payload[0]
if response_payload_len + 2 > len(response_payload):
raise ValueError('hysen_response_error', 'first byte of response is not length')
crc = CRC16(modbus_flag=True).calculate(bytes(response_payload[2:response_payload_len]))
if (response_payload[response_payload_len] == crc & 0xFF) and (
response_payload[response_payload_len + 1] == (crc >> 8) & 0xFF):
return response_payload[2:response_payload_len]
raise ValueError('hysen_response_error', 'CRC check on response failed')
def getCRCValue(self, payload = b'',lastPack = False):
if (lastPack == False):
crcValue = CRC16().calculate(self.txBuffer[self.byteSlice:self.byteSlice+128])
# Forçando um erro para checar o funcionamento:
#crcValue = 39232
else:
crcValue = CRC16().calculate(payload)
return crcValue
def inject_firm(blowfish, firm, buf):
# secure block order will shuffled using 0xFFFFE184
# ref: 0xFFFF9B70
# zero fill will avoid encryption; gbatek.htm#dscartridgesecurearea
# 0x7E00(0x9E00): firm header offset
decrypted = b'\x00' * 0xE00
decrypted += firm[:0x200]
secure = decrypted * 4
secure_crc = CRC16(modbus_flag=True).calculate(secure)
flags = [
# normal card control register settings
(
0
| (1 << 27) # NTRCARD_CLK_SLOW
#| (1 << 22) # NTRCARD_SEC_CMD
#| (0x18 << 16) # NTRCARD_DELAY2(0x18)
#| (1 << 14) # NTRCARD_SEC_EN
#| (1 << 13) # NTRCARD_SEC_DAT
| 0x18 # NTRCARD_DELAY1(0x18)
),
# secure card control register settings
(
0
| (1 << 27) # NTRCARD_CLK_SLOW
| (0x18 << 16) # NTRCARD_DELAY2(0x18)
| 0x8F8 # NTRCARD_DELAY1(0x8F8)
),
#0, # icon banner offset
struct.unpack(
'<I', buf[AK2I_HEADER_OFFSET + 0x68:AK2I_HEADER_OFFSET + 0x68 + 4])
[0],
#0, # low: secure area crc, high: secure transfer timeout
(0x0D7E << 16) | secure_crc,
]
firm_sections = firm[0x200:]
header = (buf[AK2I_HEADER_OFFSET:AK2I_HEADER_OFFSET + 0x60] +
int_list_to_buf(flags) +
buf[AK2I_HEADER_OFFSET + 0x70:AK2I_HEADER_OFFSET + 0x15E])
header += struct.pack('<H', CRC16(modbus_flag=True).calculate(header))
buf = buf_to_int_list(
buf[:AK2I_BLOWFISH_OFFSET] + blowfish +
buf[AK2I_BLOWFISH_OFFSET + 0x1048:AK2I_HEADER_OFFSET] + header +
buf[AK2I_HEADER_OFFSET + 0x160:AK2I_1ST_BLOWFISH_OFFSET] + buf[:0x48] +
buf[AK2I_1ST_BLOWFISH_OFFSET + 0x48:AK2I_2ND_BLOWFISH_OFFSET] +
buf[0x48:0x48 + 0xBF0] +
buf[AK2I_2ND_BLOWFISH_OFFSET + 0xBF0:AK2I_SEC_OFFSET] + secure +
buf[AK2I_SEC_END_OFFSET:AK2I_DATA_OFFSET] + firm_sections +
buf[AK2I_DATA_OFFSET + len(firm) - 0x200:])
return int_list_to_buf(buf)
def validate_checksum(telegram):
"""
:param str telegram:
:raises ParseError:
:raises InvalidChecksumError:
"""
# Extract the part for which the checksum applies.
checksum_contents = re.search(r'\/.+\!', telegram, re.DOTALL)
# Extract the hexadecimal checksum value itself.
# The line ending '\r\n' for the checksum line can be ignored.
checksum_hex = re.search(r'((?<=\!)[0-9A-Z]{4})+', telegram)
if not checksum_contents:
raise ParseContentError(
'Failed to perform CRC validation because the telegram is '
'incomplete: The content value is missing.')
elif checksum_contents and not checksum_hex:
raise NoChecksumError(
'Failed to perform CRC validation because the telegram is '
'incomplete: The CRC is missing.')
calculated_crc = CRC16().calculate(checksum_contents.group(0))
expected_crc = int(checksum_hex.group(0), base=16)
if calculated_crc != expected_crc:
raise InvalidChecksumError(
"Invalid telegram. The CRC checksum '{}' does not match the "
"expected '{}'".format(calculated_crc, expected_crc))
def unpackData(self, inPacket):
crcCalculator = CRC16()
packetValid = False
try:
correctedPacket = self.rs.decode(inPacket)[0]
packet = cobs.decode(correctedPacket)
crc = crcCalculator.calculate(bytes(packet[:-2]))
# Check CRC validity
if ((crc & 0xFF00) >> 8) == packet[-2] and (crc
& 0xFF) == packet[-1]:
packetValid = True
# Get packet length
packetLen = packet[6] << 8 | packet[7]
# Origin callsign
originCallsign = packet[0:6].decode('utf-8').strip()
# Check for missing packets
if packetValid:
expectedSequenceId = (self.sequenceId + 1) & 0xFFFF
packetSequenceId = packet[8] << 8 | packet[9]
if expectedSequenceId != packetSequenceId:
self.packetLost += 1
self.sequenceId = packetSequenceId
payload = packet[10:-2]
return (originCallsign, packetLen, packetSequenceId, payload)
except Exception as e:
#print('Decode error '+str(e)+'\n'+str(inPacket))
return None
def createPacket(self, data=b''):
packet = bytearray()
# Header (1 byte - added after padding)
# Callsign (6 bytes)
packet += self.callsign
# Length (2 bytes)
dataLen = len(data)
packet += bytes([(dataLen & 0xFF00) >> 8, dataLen & 0xFF])
# Sequence ID (2 bytes)
packet += bytes([(self.sequenceId & 0xFF00) >> 8,
self.sequenceId & 0xFF])
self.sequenceId = (self.sequenceId + 1) & 0xFFFF
# payload (unknown length)
packet += data
# CRC and footer (CRC MSB, CRC LSB) (2 bytes)
crcCalculator = CRC16()
crc = crcCalculator.calculate(bytes(packet))
packet += bytes([(crc & 0xFF00) >> 8, crc & 0xFF])
cobs_packet = cobs.encode(packet)
encoded_packet = self.rs.encode(cobs_packet)
return bytes([0]) + encoded_packet + bytes([0])
def validate_telegram_checksum(line_values):
"""
:type line_values: list
:raises ParseError:
:raises InvalidChecksumError:
"""
full_telegram = ''.join(line_values)
# Extract the bytes that count towards the checksum.
checksum_contents = re.search(r'\/.+\!', full_telegram, re.DOTALL)
# Extract the hexadecimal checksum value itself.
checksum_hex = re.search(r'((?<=\!)[0-9A-Z]{4}(?=\r\n))+',
full_telegram)
if not checksum_contents or not checksum_hex:
raise ParseError(
'Failed to perform CRC validation because the telegram is '
'incomplete. The checksum and/or content values are missing.')
calculated_crc = CRC16().calculate(checksum_contents.group(0))
expected_crc = checksum_hex.group(0)
expected_crc = int(expected_crc, base=16)
if calculated_crc != expected_crc:
raise InvalidChecksumError(
"Invalid telegram. The CRC checksum '{}' does not match the "
"expected '{}'".format(calculated_crc, expected_crc))
def saveP(self):
atual, lenatual = self.com.getData(16)
self.tipo = atual[1]
self.np = atual[2:6]
#print("Numero atual do pack"+str(int.from_bytes(self.np,byteorder='little')))
TamPack = atual[10:14]
TamPack = int.from_bytes(TamPack, byteorder='little')
self.crc = atual[14:]
self.crc = int.from_bytes(self.crc, byteorder='little')
print("crc - client... {0}".format(self.crc))
self.resto = TamPack % 128
self.corpo, lencorpo = self.com.getData(132)
payload = self.corpo[:128]
self.Localcrc = CRC16().calculate(payload)
#self.Localcrc = int.from_bytes(Localcrc,byteorder='little')
print("Local-crc-inicial... {0}".format(self.Localcrc))
self.find = self.corpo.find(self.EoP)
def __crc16_check(check_list):
"""
CRC校验
:param check_list: 待校验的列表
:return:CRC校验值 2*8位 （list）
"""
check_byte = b''
check_len = len(check_list)
# 将列表中的值提取出来组成一串新的位串
for i in range(check_len):
temporary_var = check_list[i]
# 转换成相同的字符串即'0x11'
temporary_var = hex(temporary_var)
# 截取掉'0x'
temporary_var = "{:0>2s}".format(temporary_var[2:])
temporary_var = binascii.a2b_hex(temporary_var)
check_byte += temporary_var
# 调用CRC16校验库函数进行校验
check_num = hex(CRC16(modbus_flag=True).calculate(check_byte))
check_num_list = []
check_num = "{:0>4s}".format(check_num[2:])
check_num_list.append(int(check_num[0:2], 16))
check_num_list.append(int(check_num[2:4], 16))
return check_num_list
def __init__(self):
self.payload = []
self.header = Header()
self.eop = EOP()
self.stuffing = Stuffing()
self.crc = CRC16()
def validate_checksum(telegram):
"""
:param str telegram:
:raises ParseError:
:raises InvalidChecksumError:
"""
# Extract the part for which the checksum applies.
checksum_contents = re.search(r'\/.+\!', telegram, re.DOTALL)
# Extract the hexadecimal checksum value itself.
# The line ending '\r\n' for the checksum line can be ignored.
checksum_hex = re.search(r'((?<=\!)[0-9A-Z]{4})+', telegram)
if not checksum_contents or not checksum_hex:
raise ParseError(
'Failed to perform CRC validation because the telegram is '
'incomplete. The checksum and/or content values are missing.')
calculated_crc = CRC16().calculate(checksum_contents.group(0))
expected_crc = int(checksum_hex.group(0), base=16)
calculated_crc_hex = '{:0>4}'.format(hex(calculated_crc)[2:].upper())
expected_crc_hex = '{:0>4}'.format(hex(expected_crc)[2:].upper())
if calculated_crc != expected_crc:
raise InvalidChecksumError(
"Invalid telegram CRC. The calculated checksum '{}' ({}) does not match the "
"telegram checksum '{}' ({})".format(calculated_crc,
calculated_crc_hex,
expected_crc,
expected_crc_hex))
def checkValidData(self, client, userdata, message):
try:
array_message = ""
array_message = str(message.payload.decode())
if len(array_message) != 41:
raise Exception
self.__crcChecksum = int(array_message[-5:])
self.__crcChecksum_new = CRC16().calculate(str(array_message[:-5]))
print(self.__crcChecksum_new)
if (self.__crcChecksum_new != self.__crcChecksum):
raise Exception
self.__idMachine_mgs = int(array_message[1:11])
if (self.__idMachine_mgs != self.idMachine):
raise Exception
self.__amoutOfProducts_mgs = int(array_message[31:36])
if (self.amoutOfProducts == self.__amoutOfProducts_mgs):
raise Exception
self.__idhr_mgs = int(array_message[11:21])
self.__wls_mgs = int(array_message[21:31])
#print(" CheckValidData: OK")
#print("ID: %d\nIDHR: %d\nWls: %d" %
#(self.__idMachine_mgs,self.__idhr_mgs, self.__wls_mgs))
self.amoutOfProducts = self.__amoutOfProducts_mgs
self.countTimeDown = 0
self.onConnect = True
qty.e
self.insertIntoMySQL()
except Exception:
#print("error")
pass
#print(" CheckValidData: FAILED ID:%d GROUP:%d LINE:%s"
# %(self.idMachine, self.group, self.line))
except:
pass
def node_crc(arg1, arg2, arg3):
data = serial.to_bytes([arg1, arg2, arg3])
crc_result = CRC16().calculate(data)
status = crc_result
lowbyte = status & 0xff
highbyte = (status & 0xff00) >> 8
data = serial.to_bytes([arg1, arg2, arg3, lowbyte, highbyte, 0x0A])
ser.write(data)
def check_crc(response):
crcbytes = map(ord, response[-2:])
resp = response[0:-2]
crc = hex_to_hexarr(CRC16(True).calculate(resp))
if crc == crcbytes:
return True
return False
def prepare_command(net_number, code):
request = ['0']
x = string_to_list(net_number) # '266608'
next = request + x + [code] # '28'
lst = map(lambda x: int(x, 16), next)
arr = array.array('B', lst).tostring()
crc = CRC16(True).calculate(arr)
return lst + hex_to_hexarr(crc)
def CRCrecebe(data: bytes):
'''
CRC-16-ModBus Algorithm
'''
resto = CRC16().calculate(data)
# print("Resto no CRC (calculado): ", resto)
return resto
def verify_crc(self):
# Get received CRC from last last of telegram
crc_received = self.telegram[len(self.telegram)-1][1:] # Remove EOT_CHAR from received CRC
# Compute CRC from received data
crc = "0x{:04x}".format(CRC16().calculate(self.crc_data+'!'))
crc = crc[2:].upper()
# Return verified CRC
return crc == crc_received
def handle(self):
crc16calc = CRC16(modbus_flag=True)
recv_buf = bytearray(DEFAULT_PACKET_LEN)
n = 0
while True:
view = memoryview(recv_buf)[n:]
while n < DEFAULT_PACKET_LEN:
tmp = self.request.recv_into(view)
if tmp <= 0:
print('Warning: Client has shutdown the connection!')
return
n += tmp
view = view[tmp:]
pkt = first_match_from_buf(recv_buf)
n = len(pkt)
if 0 == n:
continue
if 0 < n < DEFAULT_PACKET_LEN:
recv_buf[:n] = pkt # 数据包不完整(有头无尾), 需将包头回写进收缓冲区
continue
n = 0 if DEFAULT_PACKET_LEN == n else n - DEFAULT_PACKET_LEN
# # TODO: 假如遇到超长的数据包,需要将超长部分回写进收缓冲区
# if n > len(recv_buf): # This should NEVER happen!
# n = 0
# continue
# elif 0 < n <= DEFAULT_PACKET_LEN:
# recv_buf[:n] = pkt[DEFAULT_PACKET_LEN:DEFAULT_PACKET_LEN + n]
# 拆包
src_dev_addr, cmd, cnt, raw_data, crc_checksum = \
struct.unpack('>HbH12sH', pkt[2:DEFAULT_PACKET_LEN - 2]) # 不需要解析起始/终止符
# 计算并对比 CRC16 校验和是否一致
crc = crc16calc.calculate(pkt[:DEFAULT_PACKET_LEN - 4])
if crc != crc_checksum:
print('Checksum error:',
'Received {:04X},'.format(crc_checksum),
'but should be {:04X}.'.format(crc))
continue
if self.debug:
# 调试信息
client_ip_addr, client_port = self.request.getpeername()
print('Client ip={}, port={}, device_id={:04X}'.format(
client_ip_addr, client_port, src_dev_addr))
hex_str = hexlify(pkt).decode('ascii').upper()
formatted_str = ' '.join([
hex_str[i:i + 2] for i in range(0, len(hex_str), 2)
]) # 添加空格便于阅读
print(formatted_str)
if self.debug_send_back:
# Just send back the same data
self.request.sendall(pkt)
def send_file(self, file_path):
if self.socket.isValid() and self.socket.state() == QtNetwork.QAbstractSocket.ConnectedState:
file_content = None
with open(file_path, mode='rb') as file:
file_content = file.read()
crc16 = hex(CRC16().calculate(file_content))[2:].upper()
self.send_packet('I', False, len(file_content), '0', '0', GET_DATE(), GET_TIME(), 'dt.jpg', crc16)
self.socket.write(file_content)
else:
self.log('Failed to send file. Socket state is {}'.format(self.socket.state()))
def checkCrc(self):
"""
Checks if message is correct
"""
crc = CRC16().calculate(bytes(self.payload))
if crc != 0:
self.log("[ERROR] Wrong CRC.", "server")
self.sendType6()
return
def send_packet(self, packet_type, calc_crc, *args):
if self.socket.isValid() and self.socket.state() == QtNetwork.QAbstractSocket.ConnectedState:
packet_header = '#' + packet_type + '#'
packet_body = ';'.join('NA' if not arg else str(arg) for arg in args)
if calc_crc:
packet_body = packet_body + ';'
crc16 = CRC16().calculate(packet_body.encode())
packet_body = packet_body + hex(crc16)[2:].upper()
packet = packet_header + packet_body + '\r\n'
self.log(packet)
self.socket.write(packet.encode())
else:
self.log('Failed to send packet. Socket state is {}'.format(self.socket.state()))
def handle_packet(self, data):
self._object_ref.bytes_received = self._object_ref.bytes_received + len(
data) + 1
try:
decoded_packet = cobs.decode(data)
except:
self._object_ref.decode_error_count = self._object_ref.decode_error_count + 1
else:
# ce pa dobim korekten podatek, pogledam po seznamu handlerjev in klicem ustrezen callback
length_of_packet = len(decoded_packet)
# potegnem ven kodo
code = decoded_packet[0:2]
# in podatke
packet_data = decoded_packet[2:length_of_packet - 2]
code_and_data = decoded_packet[0:length_of_packet - 2]
# in na koncu se CRC
crc_received = int.from_bytes(decoded_packet[length_of_packet -
2:length_of_packet],
byteorder='little')
# sedaj naredim se CRC nad podatki in ukazom
crc_of_data = CRC16(True).calculate(bytes(code_and_data))
# ce sta CRC-ja enaka, potem nadaljujem, sicer pa kar odneham
if crc_of_data == crc_received:
# uspesno prejet paket
self._object_ref.packets_received = self._object_ref.packets_received + 1
# handlerji po novo
try:
index = self._object_ref.rx_code_list.index(code)
callback = self._object_ref.rx_handler_list[index]
# poklicem handler
if packet_data == None:
callback.rx_handler()
else:
callback.rx_handler(packet_data)
except:
self._object_ref.non_registered_packets_received = self._object_ref.non_registered_packets_received + 1
pass
else:
# povecam stevec CRC napak
self._object_ref.crc_error_count = self._object_ref.crc_error_count + 1
# ce je CRC handler registriran potem
if self._object_ref.crc_handler_function != False:
# dam stevec na vrsto
self._object_ref.crc_data.put(
self._object_ref.crc_error_count)
# in preko signala klicem sistem
self._object_ref.crc_print_signal.emit()
def sendFile(self):
"""
Sends the file to the server using a TYPE 3 message.
"""
while self.currentPacket <= self.numberOfPackets:
# Slicing the file to create the payload
self.payload = self.fileBA[(self.currentPacket - 1) *
126:self.currentPacket * 126]
# Calculate and add crc to the payload
crc = CRC16().calculate(bytes(self.payload))
self.payload = self.payload + crc.to_bytes(2, "little")
# Building the header
self.buildHead()
# Assemble the packet.
self.packet = self.head + self.payload + self.eop
startTime = time.time()
self.receivedResponse = False
while not self.receivedResponse:
# Send the data.
self.com.sendData(self.packet)
# Wait for the data to be sent.
while (self.com.tx.getIsBussy()):
pass
self.log(
f"Sent TYPE3. Packet {self.currentPacket}/{self.numberOfPackets}.",
"client")
# Wait for response
self.log(f"Waiting for TYPE4.", "client")
self.response, self.responseSize = self.com.getData(
16 + 0 + len(self.eop), 5)
if self.responseSize != 0:
self.parseResponse()
self.receivedResponse = True
# Get current timer
now = time.time()
# Checking if we had a timeout
if now - startTime >= 20:
self.sendType5(self.currentPacket, self.numberOfPackets)
self.com.disable()
exit()
def check_crc_n7(rcv):
rez = bytearray(rcv)
crc16 = CRC16(modbus_flag=True).calculate(rcv[0:5])
if len(rez) == 7:
crc = rez[6] * 256 + rez[5]
if crc == crc16:
res = 256 * rez[3] + rez[4]
if res > 1600:
return TEMPERATURE_ERROR_MSG
else:
return res
else:
return CRC_ERROR_MSG
else:
return PKG_SIZE_ERROR_MSG
def write_SV(sv):
req_save_SV[4] = int(sv) // 256
req_save_SV[5] = int(sv) % 256
crc16 = CRC16(modbus_flag=True).calculate(str(req_save_SV[0:6]))
req_save_SV[6] = crc16 % 256
req_save_SV[7] = crc16 // 256
print "try to write_SV ", sv
rcv = open_port_and_read(req_save_SV, 8)
if rcv == False:
return PORT_ERROR_MSG
else:
rez = bytearray(rcv)
if rez != req_save_SV:
#print "Error send SV = ", sv
return False
return True
def write_max_output_value(sv):
req_save_MV[4] = int(sv) // 256
req_save_MV[5] = int(sv) % 256
crc16 = CRC16(modbus_flag=True).calculate(str(req_save_MV[0:6]))
req_save_MV[6] = crc16 % 256
req_save_MV[7] = crc16 // 256
print "try to write_output_power MV ", sv
rcv = open_port_and_read(req_save_MV, 8)
if rcv == False:
return PORT_ERROR_MSG
rez = bytearray(rcv)
if rez == req_save_MV:
return True
else:
#print "Error send MV = ", sv
return False
def crc(input_date):
"""
:param input_date:
:return:
"""
crc_tool = CRC16(modbus_flag=True)
try:
data_b = bytes.fromhex(input_date)
except (ValueError, TypeError):
print('参数错误')
except Exception:
print(' ')
else:
crc_code = crc_tool.calculate(data_b)
crc_high = hex(crc_code >> 8)[2:]
crc_low = hex(crc_code & 0x00ff)[2:]
result = input_date + ' ' + crc_low + ' ' + crc_high
return result.upper()
def checkPackage(self, messageType3, payloadSize):
if self.checkEopPayload(messageType3, payloadSize):
crcCaculated = CRC16().calculate(bytes(messageType3[:payloadSize]))
if crcCaculated == self.crcReceived:
self.packagesReceived.append(messageType3[:payloadSize])
self.setMessageType(4)
self.messageType4()
print("")
print("CRC CORRETO.")
print("===========================================")
print("Mensagem tipo 4 enviada.")
print("===========================================")
print("")
self.counter += 1
else:
self.setMessageType(6)
self.messageType6()
print("Mensagem tipo 6 enviada.")
def type3(data, total_of_packages, data_stuffed, max_package_size,
current_package):
type_msg = 3
server_id = 1
#while current_package <= total_of_packages:
payload = data_stuffed[max_package_size *
(current_package - 1):max_package_size *
(current_package)]
payload = bytes(payload)
crc = CRC16().calculate(payload)
head_payload = head(payload, total_of_packages, current_package,
type_msg, server_id, crc)
package = add_eop(head_payload)
com.sendData(package)
def send_packet(self, code, data):
if data is None:
packet_out = (struct.pack('<h', code))
else:
packet_out = (struct.pack('<h', code)) + data
# ce je port odprt
if self.ser.isOpen() == True:
# pripravim za posiljanje
crc_of_data = CRC16(True).calculate(bytes(packet_out))
crc_of_data_bytes = struct.pack("<H", crc_of_data)
packet_array = bytearray(packet_out)
packet_array.append(crc_of_data_bytes[0])
packet_array.append(crc_of_data_bytes[1])
# zakodiram
cobs_encoded = cobs.encode(bytes(packet_array))
# dodam se 0x00 za konec paketa
cobs_encoded.append(0)
# posljem, tx_threadu
self.tx_queue.put(cobs_encoded)
pass
