def calc_crc(data):
assert len(data) >= 16
crc = crc16xmodem(data[:4])
crc = crc16xmodem(b"\0\0", crc)
crc = crc16xmodem(data[6:], crc)
return crc
def serialize(o, validate=True):
'''returns ready-to-send telegram as binary string.'''
result = [
0xdc,
o.src ^ 0x80,
o.dst,
0, # length to be set
_PACKETTYPES_R[o.packettype],
]
id = o.field.telegram_id
id = [(id & 0xff000000) >> 24, (id & 0xff0000) >> 16,
(id & 0xff00) >> 8, id & 0xff]
if o.packettype in ['get', 'set']:
id[1], id[0] = id[0], id[1]
result += id
if o.packettype in ['set', 'ret']:
result += o.field.encode(o.data, o.packettype, validate=validate)
# set length
result[3] = len(result) + 2
# add crc
crc = crc16xmodem(result)
result.append((crc & 0xff00) >> 8)
result.append(crc & 0xff)
return ''.join(map(chr, result))
def send_SOH(self, first_flag):
data_send = []
self.data_comand = [0xff, 0xfe]
self.len = 128 + 8
self.data_comand.insert(0, int(self.id))
self.data_comand.insert(1, self.len)
for data in range(128):
data_send.append(0x00)
if first_flag == 1:
data_send[0] = (self.filed_len >> 24) & 0x00ff
data_send[0] = (self.filed_len >> 16) & 0x00ff
data_send[2] = (self.filed_len >> 8) & 0x00ff
data_send[3] = self.filed_len & 0x00ff
self.crc_check = crc16pure.crc16xmodem(data_send)
data_send.append(self.crc_check >> 8)
data_send.append(self.crc_check & 0x00ff)
data_send.insert(0, 0x01) #SOH
data_send.insert(1, 0x00)
data_send.insert(2, 0xff)
data_send = self.data_comand + data_send
self.check_sum = check_sum(data_send)
data_send.append(self.check_sum)
data_send = self.head + data_send
send_data(data_send)
while self.back_data == '':
self.back_data = get_data()
data = bytes.fromhex(self.back_data)
data_ack = str(bytes(data[5:6]))[4:-1]
#print('ack',data_ack)
if data_ack == '06': #C
if first_flag == 0:
self.back_data = 'a'
#print('get ACK')
else:
data_c = str(bytes(data[6:7]))[2:-1]
#print('data_c=:',data_c)
if data_c == 'C':
self.back_data = 'a'
else:
#print("wrong")
self.back_data = ''
elif data_ack == '18':
break
elif data_ack == '15':
send_data(data_send)
self.back_data = ''
else:
self.back_data = ''
self.back_data = ''
def _validate(cls, data):
if data[0] != 0xdc:
raise DecodeError("bad start marker")
if len(data) < 4 or len(data) < data[3]:
raise DecodeError("incomplete telegram")
tlen = data[3]
if tlen < 11:
raise DecodeError(
"bad length: telegram cannot be shorter than 11 bytes")
crc = crc16xmodem(data[:tlen])
if crc != 0:
pretty = ''.join('%0.2X ' % i for i in data[:tlen])
raise DecodeError("bad crc checksum for: " + pretty)
def updateNCP(firmwareEBL):
with open(firmwareEBL, 'rb') as file:
i = ezsp.EZSPInterface()
i.ezspInit()
queryResponse = i.XModemQuery(False)
if not queryResponse:
i.ezspVersion(4)
i.ezspLaunchStandaloneBootloader(
STANDALONE_BOOTLOADER_RECOVERY_MODE)
i.waitFor260boot()
queryResponse = i.XModemQuery(False)
if not queryResponse:
raise RuntimeError('Cannot start NCP bootloader')
if queryResponse[0] != XMODEM_QRESP:
raise RuntimeError('Invalid response from NCP bootloader')
if queryResponse[QRESP_OFFSET_PLATFORM] != 4:
raise RuntimeError('Invalid bootloader "platform" value')
if queryResponse[QRESP_OFFSET_MICRO] != 3:
raise RuntimeError('Invalid bootloader "micro" value')
bootloaderVersion = queryResponse[
QRESP_OFFSET_BL_VERSION] << 8 | queryResponse[(
QRESP_OFFSET_BL_VERSION + 1)]
print 'NCP bootloader version: 0x%04x' % bootloaderVersion
blockCount = 1
pktCounter = 0
complete = False
while not complete:
packet = file.read(XMODEM_BLOCK_SIZE)
if len(packet) < XMODEM_BLOCK_SIZE:
complete = True
if len(packet) > 0:
while len(packet) < XMODEM_BLOCK_SIZE:
packet += chr(255)
xmodemPacket = struct.pack('>BBBB128sH',
BOOTLOAD_PROTOCOL_VERSION,
XMODEM_SOH, blockCount,
255 - blockCount, packet,
crc16.crc16xmodem(packet))
xmodemTransaction(i, xmodemPacket)
pktCounter += 1
blockCount += 1
if blockCount > 255:
blockCount = 0
if PRINT_PROGRESS_DOTS:
print '.',
xmodemPacket = struct.pack('>BB', BOOTLOAD_PROTOCOL_VERSION,
XMODEM_EOT)
xmodemTransaction(i, xmodemPacket)
def __init__(self, data=''):
HciPacket.sequence_number = (HciPacket.sequence_number + 1) % 8
self.temp_data = ''
self.temp_data += parts_to_four_bytes(HciPacket.sequence_number,
DATA_INTEGRITY_CHECK_PRESENT,
RELIABLE_PACKET, HCI_PACKET_TYPE,
len(data))
self.temp_data += data
crc = crc16pure.crc16xmodem(self.temp_data, crc=65535)
self.temp_data += chr(crc & 255)
self.temp_data += chr((crc & 65280) >> 8)
self.temp_data = encode_packet(self.temp_data)
self.data = chr(192)
self.data += self.temp_data
self.data += chr(192)
def send_STX(self):
data_tab = []
list_f = 0
self.data_comand = [0xff, 0xfe]
self.data_comand.insert(0, int(self.id))
self.data_comand.insert(1, 0xff)
#print(self.data_comand)
for list_f in range(self.Kbits):
list_first = list_f * 1024
list_end = list_first + 1024
if list_f == self.Kbits - 1:
data_tab = self.f[list_first:]
data_tab = data_tab + self.end_tab
else:
data_tab = self.f[list_first:list_end]
self.crc_check = crc16pure.crc16xmodem(data_tab)
data_tab.append(self.crc_check >> 8)
data_tab.append(self.crc_check & 0x00ff)
data_tab.insert(0, 0x02) #SOH
data_tab.insert(1, list_f + 1)
data_tab.insert(2, 0xff ^ (list_f + 1))
data_tab = self.data_comand + data_tab
self.check_sum = check_sum(data_tab)
data_tab.append(self.check_sum)
data_tab = self.head + data_tab
print('发送第', list_f, '帧数据')
send_data_len = len(data_tab)
print('发送数据长度：', send_data_len)
#data_tab=data_pack(data_tab,self.data_comand,list_f+1)
send_data(data_tab)
self.back_data = ''
while self.back_data == '':
self.back_data = get_data()
data = bytes.fromhex(self.back_data)
data_ack = str(bytes(data[5:6]))[4:-1]
sleep(1)
if data_ack == '06':
self.back_data = 'a'
elif data_ack == '18':
break
elif data_ack == '15':
print('第', list_f, '帧数据错误 重新发送')
send_data(data_tab)
self.back_data = ''
else:
self.back_data = ''
print('数据发送完成')
self.back_data = ''
def recvCmdSOH(self, timeout):
rbuff = self.uartDrv.read(128 + 3 + 2)
if (len(rbuff) < 128 + 3 + 2):
return None, None, False
cmd, num, nnum, data128, crc16 = struct.unpack("!ccc128sH", rbuff)
#print()
#print("CRC 0x%x crc16:0x%x" % (crc16xmodem(data128),crc16))
if ((cmd[0] != self.Command['SOH']) or (num[0] != nnum[0] ^ 0xff)
or (crc16xmodem(data128) != crc16)):
return None, None, False
print("Receive SOH package is right !")
return num[0], data128, True
def __init__(self, data=""):
HciPacket.sequence_number = (HciPacket.sequence_number + 1) % 8
self.temp_data = ""
self.temp_data += parts_to_four_bytes(
HciPacket.sequence_number, DATA_INTEGRITY_CHECK_PRESENT, RELIABLE_PACKET, HCI_PACKET_TYPE, len(data)
)
self.temp_data += data
# Add escape caracters
crc = crc16pure.crc16xmodem(self.temp_data, crc=0xFFFF)
self.temp_data += chr(crc & 0xFF)
self.temp_data += chr((crc & 0xFF00) >> 8)
self.temp_data = encode_packet(self.temp_data)
self.data = chr(0xC0)
self.data += self.temp_data
self.data += chr(0xC0)
def __init__(self, action, led_data=None):
sync_byte = 0xC0
version = 0x0
self.data = bytearray(b'AT')
self.data.append(sync_byte)
self.data.append(version)
#print(self.data)
cmd_data = bytearray(action)
if led_data != None:
cmd_data.extend(led_data)
self.data.extend(struct.pack('H', len(cmd_data)))
self.data.extend(cmd_data)
crc = crc16pure.crc16xmodem(cmd_data)
self.data.extend(struct.pack('H', crc)) #crc
def data_pack(data_in, command, lsit):
data_comand = command
data_s = data_in
check_crc = crc16pure.crc16xmodem(data_in)
data_s.append(check_crc >> 8)
data_s.append(check_crc & 0x00ff)
if lsit == 0:
data_s.insert(0, 0x01)
data_s.insert(1, 0x00)
data_s.insert(2, 0xff)
else:
data_s.insert(0, 0x02)
data_s.insert(1, lsit)
data_s.insert(2, (lsit) ^ (0xff))
data_s = data_comand + data_s
check_sm = check_sum(data_s)
data_s.append(check_sm)
data_s = qh_sprotocol.head + data_s
return data_s
def __init__(self, data=''):
HciPacket.sequence_number = (HciPacket.sequence_number + 1) % 8
self.temp_data = ''
self.temp_data += parts_to_four_bytes(HciPacket.sequence_number,
DATA_INTEGRITY_CHECK_PRESENT,
RELIABLE_PACKET, HCI_PACKET_TYPE,
len(data))
self.temp_data += data
# Add escape caracters
crc = crc16pure.crc16xmodem(self.temp_data, crc=0xFFFF)
self.temp_data += chr(crc & 0xFF)
self.temp_data += chr((crc & 0xFF00) >> 8)
self.temp_data = encode_packet(self.temp_data)
self.data = chr(0xc0)
self.data += self.temp_data
self.data += chr(0xc0)
def GenerateCRC(self, image):
self.CRC = crc16pure.crc16xmodem(image, crc=0xFFFF)
def upload_firmware(self):
def percentage(part, whole):
return int(100 * float(part) / float(whole))
def get_ack_nr(uart):
def is_timeout(start_time, timeout_sec):
return not (datetime.now() - start_time <= timedelta(
0, timeout_sec))
uart_buffer = []
start = datetime.now()
while uart_buffer.count(0xC0) < 2:
#Disregard first of the two C0
temp = uart.read(1)
if temp:
uart_buffer.append(ord(temp))
if is_timeout(start, 5):
# reset HciPacket numbering back to 0
HciPacket.sequence_number = 0
# call timeout callback from parent layer
self.timeout_callback()
# quit loop
break
#read until you get a new C0
#RESUME_WORK
data = decode_esc_chars(uart_buffer)
# Remove 0xC0 at start and beginning
data = data[1:-1]
# print "non-slip data ", [data]
return (data[0] >> 3) & 0x07
def send_packet(uart, pkt):
attempts = 0
last_ack = None
packet_sent = False
while packet_sent == False:
uart.write(pkt.data)
attempts += 1
ack = get_ack_nr(uart)
if last_ack == None:
last_ack = ack
break
if ack == (last_ack + 1) % 8:
last_ack = ack
packet_sent = True
if attempts > 3:
raise Exception(
"Three failed tx attempts encountered on packet {0}"
.format(seq))
def start_packet_generate(hex_file):
def word_align(a, b):
return (((a) + (b - 1)) & ~(b - 1))
hex_type = hex_file.hex_type_get()
start_data = int32_to_bytes(DFU_START_PACKET)
start_data += int32_to_bytes(hex_type)
# size of SoftDevice
start_data += int32_to_bytes(
word_align(hex_file.sd_address_end, 4) -
hex_file.sd_address_start)
# size of BootLoader
start_data += int32_to_bytes(
word_align(hex_file.bl_address_end, 4) -
hex_file.bl_address_start)
# size of Application
start_data += int32_to_bytes(
word_align(hex_file.app_address_end, 4) -
hex_file.app_address_start)
packet = HciPacket(start_data)
# print "\n\nstart packet data:",
# for i in packet.data:
# print hex(ord(i)),
# print ""
return packet
def init_packet_generate(image_crc):
hardware_version = 0xFFFF
hardware_revision = 0xFFFF
application_version = 0xFFFFFFFF
softdevice_len = 0x0001
softdevice_array = 0xFFFE
init_packet = int32_to_bytes(DFU_INIT_PACKET)
init_packet += int16_to_bytes(hardware_version)
init_packet += int16_to_bytes(hardware_revision)
init_packet += int32_to_bytes(application_version)
init_packet += int16_to_bytes(softdevice_len)
init_packet += int16_to_bytes(softdevice_array)
init_packet += int16_to_bytes(image_crc)
init_packet += int16_to_bytes(0x0000)
packet = HciPacket(init_packet)
return packet
def stop_packet_generate():
stop_data = int32_to_bytes(DFU_END_PACKET)
packet = HciPacket(stop_data)
# print "\n\nstop packet data:",
# for i in packet.data:
# print hex(ord(i)),
return packet
def data_packets_generate(bin_image):
def word_align(a, b):
return (((a) + (b - 1)) & ~(b - 1))
foo_packets = []
for i in range(0, len(bin_image), 512):
data_packet = HciPacket(
int32_to_bytes(DFU_DATA_PACKET) + bin_image[i:i + 512])
# print "\n\ndata packet data:",
# for i in data_packet.data:
# print hex(ord(i)),
foo_packets.append(data_packet)
return foo_packets
#self.test_sd()
ih = Nrf51Hex(self.file_path)
# if verbose flag is set.
if self.verbose:
self.verbose_info(ih)
packets = []
bin_image = ""
if ih.is_softdevice():
bin_image += ih.tobinstr(
start=ih.sd_address_start, end=ih.sd_address_end - 1
) # remove last address as intelhex module includes the end address.
if ih.is_bootloader():
bin_image += ih.tobinstr(start=ih.bl_address_start,
end=ih.bl_address_end - 1)
if ih.is_application():
bin_image += ih.tobinstr(start=ih.app_address_start,
end=ih.app_address_end - 1)
bin_image_crc = crc16pure.crc16xmodem(bin_image, crc=0xFFFF)
# Add start packet
start_packet = start_packet_generate(ih)
packets.append(start_packet)
init_packet = init_packet_generate(bin_image_crc)
packets.append(init_packet)
# Add hex data packets
data_packets = data_packets_generate(bin_image)
packets.extend(data_packets)
# Add stop packet
stop_packet = stop_packet_generate()
packets.append(stop_packet)
if self.verbose:
print "Total number of HCI packets: %i" % len(packets)
uart = None
try:
uart = Serial(self.com_port,
self.baud_rate,
rtscts=self.flow_control,
timeout=1)
except Exception, e:
print "UART could not be opened on %s" % self.com_port
print e
def rnd(n):
return random.randrange(n)
if __name__ == '__main__':
s = SPIDriver(sys.argv[1])
t1 = time.time() + float(sys.argv[2])
i = 0
random.seed(7)
while time.time() < t1:
expected = s.ccitt_crc
s.unsel()
l = 1 + rnd(100)
db = [rnd(256) for j in range(l)]
s.write(db)
expected = crc16xmodem(db, expected)
s.unsel()
db = [rnd(256) for j in range(64)]
r = list(array.array('B', s.writeread(db)))
expected = crc16xmodem(db, expected)
expected = crc16xmodem(r, expected)
s.getstatus()
print("expected=%04x actual=%04x" % (expected, s.ccitt_crc))
assert expected == s.ccitt_crc, "pass %d with %d bytes %s, expected=%04x actual=%04x" % (
i, len(db), list(db), expected, s.ccitt_crc)
i += 1
for i in range(20):
s.seta(0)
s.setb(0)
hna = h.minaddr() # veeeeeery slow function
hma = h.maxaddr() # same
a = hna
sdt = datetime.datetime.now()
tb = 0
crc = 0
while a < hma:
s = ''
adr = hex(a)[2:].zfill(6)
nb = min(pgw_size, hma - a + 1)
tb = tb + nb
for i in range(nb):
s = s + hex(h[a])[2:].zfill(2)
a = a + 1
crc = crc16pure.crc16xmodem(s.decode('hex'), crc)
try:
te = datetime.datetime.now() - sdt # time elapsed
pd = 1.0 * (a-hna) / (hma-hna) # prg done
tl = datetime.timedelta(seconds = int(((1.0-pd)/pd) * te.total_seconds())) # time left
print adr,nb,tb,'/',hma-hna+1,'(',int(100.0*pd),'%)',tl,' left'
atcmd('AT+BUFWR=' + s, 'OK')
atcmd('AT+EE24WR=' + adr, 'OK')
atcmd('AT+EE24RD=' + adr + ',' + str(i + 1), 'OK')
atcmd('AT+BUFCMP', 'OK')
except Exception, e:
print e
break
print
if hna == 0:
print 'Device CRC:',atcmd('AT+EE24CRC=' + str(hma+1), '', 20)
def updateNCP(firmwareEBL):
with open(firmwareEBL, 'rb') as file:
i = ezsp.EZSPInterface()
i.ezspInit()
queryResponse = i.XModemQuery(False)
if not queryResponse:
i.ezspVersion(4)
i.ezspLaunchStandaloneBootloader(STANDALONE_BOOTLOADER_RECOVERY_MODE)
i.waitFor260boot()
queryResponse = i.XModemQuery(False)
if not queryResponse:
raise RuntimeError('Cannot start NCP bootloader')
if queryResponse[0] != XMODEM_QRESP:
raise RuntimeError('Invalid response from NCP bootloader')
if queryResponse[QRESP_OFFSET_PLATFORM] != 4:
raise RuntimeError('Invalid bootloader "platform" value')
if queryResponse[QRESP_OFFSET_MICRO] != 3:
raise RuntimeError('Invalid bootloader "micro" value')
bootloaderVersion = queryResponse[QRESP_OFFSET_BL_VERSION] << 8 | queryResponse[(QRESP_OFFSET_BL_VERSION + 1)]
print 'NCP bootloader version: 0x%04x' % bootloaderVersion
blockCount = 1
pktCounter = 0
complete = False
while not complete:
packet = file.read(XMODEM_BLOCK_SIZE)
if len(packet) < XMODEM_BLOCK_SIZE:
complete = True
if len(packet) > 0:
while len(packet) < XMODEM_BLOCK_SIZE:
packet += chr(255)
xmodemPacket = struct.pack('>BBBB128sH', BOOTLOAD_PROTOCOL_VERSION, XMODEM_SOH, blockCount, 255 - blockCount, packet, crc16.crc16xmodem(packet))
xmodemTransaction(i, xmodemPacket)
pktCounter += 1
blockCount += 1
if blockCount > 255:
blockCount = 0
if PRINT_PROGRESS_DOTS:
print '.',
xmodemPacket = struct.pack('>BB', BOOTLOAD_PROTOCOL_VERSION, XMODEM_EOT)
xmodemTransaction(i, xmodemPacket)
def upload_firmware(self):
def percentage(part, whole):
return int(100 * float(part)/float(whole))
def get_ack_nr(uart):
def is_timeout(start_time, timeout_sec):
return not (datetime.now() - start_time <= timedelta(0, timeout_sec))
uart_buffer = []
start = datetime.now()
while uart_buffer.count(0xC0) < 2:
#Disregard first of the two C0
temp = uart.read(1)
if temp:
uart_buffer.append(ord(temp))
if is_timeout(start, 5):
# reset HciPacket numbering back to 0
HciPacket.sequence_number = 0
# call timeout callback from parent layer
self.timeout_callback()
# quit loop
break
#read until you get a new C0
#RESUME_WORK
data = decode_esc_chars(uart_buffer)
# Remove 0xC0 at start and beginning
data = data[1:-1]
# print "non-slip data ", [data]
return (data[0] >> 3) & 0x07
def send_packet(uart, pkt):
attempts = 0
last_ack = None
packet_sent = False
while packet_sent == False:
uart.write(pkt.data)
attempts += 1
ack = get_ack_nr(uart)
if last_ack == None:
last_ack = ack
break
if ack == (last_ack+1) % 8:
last_ack = ack
packet_sent = True
if attempts > 3:
raise Exception("Three failed tx attempts encountered on packet {0}".format(seq))
def start_packet_generate(hex_file):
def word_align(a, b):
return (((a) + (b - 1)) &~(b - 1))
hex_type = hex_file.hex_type_get()
start_data = int32_to_bytes(DFU_START_PACKET)
start_data += int32_to_bytes(hex_type)
# size of SoftDevice
start_data += int32_to_bytes(word_align(hex_file.sd_address_end, 4) - hex_file.sd_address_start)
# size of BootLoader
start_data += int32_to_bytes(word_align(hex_file.bl_address_end, 4) - hex_file.bl_address_start)
# size of Application
start_data += int32_to_bytes(word_align(hex_file.app_address_end, 4) - hex_file.app_address_start)
packet = HciPacket(start_data)
# print "\n\nstart packet data:",
# for i in packet.data:
# print hex(ord(i)),
# print ""
return packet
def init_packet_generate(image_crc):
hardware_version = 0xFFFF
hardware_revision = 0xFFFF
application_version = 0xFFFFFFFF
softdevice_len = 0x0001
softdevice_array = 0xFFFE
init_packet = int32_to_bytes(DFU_INIT_PACKET)
init_packet += int16_to_bytes(hardware_version)
init_packet += int16_to_bytes(hardware_revision)
init_packet += int32_to_bytes(application_version)
init_packet += int16_to_bytes(softdevice_len)
init_packet += int16_to_bytes(softdevice_array)
init_packet += int16_to_bytes(image_crc)
init_packet += int16_to_bytes(0x0000)
packet = HciPacket(init_packet)
return packet
def stop_packet_generate():
stop_data = int32_to_bytes(DFU_END_PACKET)
packet = HciPacket(stop_data)
# print "\n\nstop packet data:",
# for i in packet.data:
# print hex(ord(i)),
return packet
def data_packets_generate(bin_image):
def word_align(a, b):
return (((a) + (b - 1)) &~(b - 1))
foo_packets = []
for i in range(0, len(bin_image), 512):
data_packet = HciPacket(int32_to_bytes(DFU_DATA_PACKET) + bin_image[i:i+512])
# print "\n\ndata packet data:",
# for i in data_packet.data:
# print hex(ord(i)),
foo_packets.append(data_packet)
return foo_packets
#self.test_sd()
ih = Nrf51Hex(self.file_path)
# if verbose flag is set.
if self.verbose:
self.verbose_info(ih)
packets = []
bin_image = ""
if ih.is_softdevice():
bin_image += ih.tobinstr(start = ih.sd_address_start, end = ih.sd_address_end - 1) # remove last address as intelhex module includes the end address.
if ih.is_bootloader():
bin_image += ih.tobinstr(start = ih.bl_address_start, end = ih.bl_address_end - 1)
if ih.is_application():
bin_image += ih.tobinstr(start = ih.app_address_start, end = ih.app_address_end - 1)
bin_image_crc = crc16pure.crc16xmodem(bin_image, crc=0xFFFF)
# Add start packet
start_packet = start_packet_generate(ih)
packets.append(start_packet)
init_packet = init_packet_generate(bin_image_crc)
packets.append(init_packet)
# Add hex data packets
data_packets = data_packets_generate(bin_image)
packets.extend(data_packets)
# Add stop packet
stop_packet = stop_packet_generate()
packets.append(stop_packet)
if self.verbose:
print "Total number of HCI packets: %i" % len(packets)
uart = None
try:
uart = Serial(self.com_port, self.baud_rate, rtscts=self.flow_control, timeout=1)
except Exception, e:
print "UART could not be opened on %s" % self.com_port
print e
def GenerateCRC(self, image):
self.CRC = crc16pure.crc16xmodem(image, crc=0xFFFF)
def hash_paragraph(self, paragraph: str) -> str:
binary = ''.join(self.str_to_binary(p) for p in paragraph)
binary = str.encode(binary)
p_hash = crc16xmodem(binary)
return self.int_to_binary(p_hash)
def get_data():
data = ''
while ser.inWaiting() > 0:
#data.append(hex(ser.read(1)))
data = data + str(binascii.b2a_hex(ser.read(1)))[2:-1] + ' '
#data.append(ser.read(1))
print('接收数据:', data)
sleep(0.5)
return data
#data+=binascii.b2a_hex(ser.read(1))
if __name__ == '__main__':
data = [0x01, 0x02, 0x04, 0x08]
crcdata = crc16pure.crc16xmodem(data)
print(crcdata)
#qh_sprotocol.test()
#data=''
# while 1:
# data=get_data()
# if data!='':
# print(data)
# data=bytes.fromhex(data)
# data_send=str(bytes(data[5:6]))[2:-1]
# print(data_send)
# if data_send=='00':
# data='a'
