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 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'