def process_byte(self, byte_in: bytes): byte = byte_in[0] if (byte == FRAME_BOUNDARY and not self.in_escape): # Check for End Frame + Validity if(self.frame_offset >= 2): if ((self.frame_offset - 4) == self.receive_buffer[1]): # Length matches. Now verify checksum self.frame_chksum = bytearray(struct.pack("<H", crc16(self.receive_buffer[0:self.frame_offset-2]))) packet = self.receive_buffer[0:self.frame_offset-2] self.frame_chksum = crc16(packet) sent_chksum = struct.unpack("<H", self.receive_buffer[self.frame_offset-2:self.frame_offset])[0] if(self.frame_chksum == sent_chksum and self.packet_cb is not None): self.packet_cb(packet) # Reset and look for next frame self.frame_offset = 0 self.frame_chksum = 0 return # Handle Escape Sequence if(self.in_escape is True): byte = byte ^ HDLC_BYTE_INVERT self.in_escape = False elif(byte == CONTROL_ESCAPE): self.in_escape = True return # Copy to buffer self.receive_buffer[self.frame_offset] = byte self.frame_offset += 1 if (self.frame_offset >= PACKET_SIZE_LIMIT): # Overflow Packet Limit, self.frame_offset = 0 # Reset self.frame_chksum = 0 # Reset
def opcode8(self, address, group, seconds, minutes, hours, day, month, year,expected_length=-1): data = [address, group, self._host_address, self._host_group, 8, 6, seconds, minutes, hours, day, month, year] request = "" for i in data: request += struct.pack('B',i) for i in crc.crc16(request): request += struct.pack('B',i) self._send(request) data = self._recv() responsecrc = data[-2:] data = data[:-2] response = "" for i in data: response += struct.pack('B',i) if not(crc.crc16(response) == responsecrc): raise RuntimeError('CRC Error') if not(data[0] == self._host_address) or not(data[1] == self._host_group): raise RuntimeError('Incorrect Host Address in Response') if not(data[2] == address) or not(data[3] == group): raise RuntimeError('Incorrect Device Address in Response') if not(data[4] == 8) and (data[4] != 255): raise RuntimeError('Incorrect OPCode in Response') if (data[4] == 255): raise OpcodeError(data[7], data[8],[]) if (data[5] == 0): return True else: return False
def opcode17(self, address, group, expected_length=-1): data = [address, group, self._host_address, self._host_group, 17, 5,76,79,73,03,232] request = "" for i in data: request += struct.pack('B',i) for i in crc.crc16(request): request += struct.pack('B',i) self._send(request) data = self._recv() responsecrc = data[-2:] data = data[:-2] response = "" for i in data: response += struct.pack('B',i) if not(crc.crc16(response) == responsecrc): raise RuntimeError('CRC Error') if not(data[0] == self._host_address) or not(data[1] == self._host_group): raise RuntimeError('Incorrect Host Address in Response') if not(data[2] == address) or not(data[3] == group): raise RuntimeError('Incorrect Device Address in Response') if not(data[4] == 17) and (data[4] != 255): raise RuntimeError('Incorrect OPCode in Response') if (data[4] == 255): raise OpcodeError(data[7], data[8],[]) return data
def decode_af(self, in_data, is_stream=False): if is_stream: headerdata = in_data.read(10) else: headerdata = in_data[:10] sync, plen, seq, ar, pt = struct.unpack(af_head_struct, headerdata) if sync != "AF": return False crc_flag = (ar & 0x80) != 0x00 revision = ar & 0x7F if is_stream: payload = in_data.read(plen) crc_data = in_data.read(2) crc = struct.unpack("!H", crc_data)[0] else: payload = in_data[10:10 + plen] crc_data = in_data[10 + plen:10 + plen + 2] crc = struct.unpack("!H", crc_data)[0] crc_calc = crc16(headerdata) crc_calc = crc16(payload, crc_calc) crc_calc ^= 0xFFFF crc_ok = crc_calc == crc if crc_ok: self.send_udp(headerdata + payload + crc_data) return crc_ok
def opcode126(self, address, group, point, expected_length=-1): data = [address, group, self._host_address, self._host_group, 126, 1, point] clock = self.opcode180(address=address, group=group, TLP=[[12,0,5],[12,0,4],[12,0,3],[12,0,2]], data_format=['b','b','b','b']) iHour = clock[3] sDate = "20%2d-%02d-%02d"%(clock[0],clock[1],clock[2]) request = "" for i in data: request += struct.pack('B',i) for i in crc.crc16(request): request += struct.pack('B',i) self._send(request) data = self._recv() responsecrc = data[-2:] data = data[:-2] response = "" for i in data: response += struct.pack('B',i) if not(crc.crc16(response) == responsecrc): raise RuntimeError('CRC Error') if not(data[0] == self._host_address) or not(data[1] == self._host_group): raise RuntimeError('Incorrect Host Address in Response') if not(data[2] == address) or not(data[3] == group): raise RuntimeError('Incorrect Device Address in Response') if not(data[4] == 126) and (data[4] != 255): raise RuntimeError('Incorrect OPCode in Response') if (data[4] == 255): raise OpcodeError(data[7], data[6],[]) if not(data[6] == point): raise RuntimeError('Incorrect Pointer in Response') iMin = data[7] hist = data[8:] iBit = 0 aHist = [] for i in range(60): value = '' value += struct.pack('B',hist[iBit]) value += struct.pack('B',hist[iBit + 1]) value += struct.pack('B',hist[iBit + 2]) value += struct.pack('B',hist[iBit + 3]) aValue = struct.unpack('f',value) #aHist.append(aValue[0]) iBit += 4 date_time = datetime.datetime(clock[0]+2000,clock[1],clock[2],iHour,i, 00) if i >= iMin: date_time = date_time - datetime.timedelta(hours=1) sTime = date_time.strftime('%Y-%m-%d %H:%M:%S') aHist.append({'date_time':sTime, 'value': aValue[0]}) return aHist
def decode_af(in_data, is_stream=False): p.pr("AF Packet") p.inc() if is_stream: headerdata = in_data.read(10) else: headerdata = in_data[:10] if len(headerdata) != 10: p.hexpr("AF Header", headerdata) sync, plen, seq, ar, pt = struct.unpack(af_head_struct, headerdata) if sync != "AF": p.pr("No AF Sync") p.hexpr("in", in_data) p.dec() return False crc_flag = (ar & 0x80) != 0x00 revision = ar & 0x7F if is_stream: payload = in_data.read(plen) crc = struct.unpack("!H", in_data.read(2))[0] else: payload = in_data[10:10+plen] crc = struct.unpack("!H", in_data[10+plen:10+plen+2])[0] crc_calc = crc16(headerdata) crc_calc = crc16(payload, crc_calc) crc_calc ^= 0xFFFF crc_ok = crc_calc == crc if crc_flag and crc_ok: p.pr("CRC ok 0x{0:04x}".format(crc)) elif crc_flag: p.pr("CRC not ok!") p.pr(" CRC: is 0x{0:04x}, calculated 0x{1:04x}".format(crc, crc_calc)) else: p.pr("No CRC") p.pr("plen {}".format(plen)) p.pr("seq {}".format(seq)) p.pr("revision {}".format(revision)) p.pr("protocol type {}".format(pt)) success = False if pt == "T": success = decode_tag(payload) p.dec() return success
def decode_af(in_data, is_stream=False): p.pr("AF Packet") p.inc() if is_stream: headerdata = in_data.read(10) else: headerdata = in_data[:10] if len(headerdata) != 10: p.hexpr("AF Header", headerdata) sync, plen, seq, ar, pt = struct.unpack(af_head_struct, headerdata) if sync != "AF": p.pr("No AF Sync") p.hexpr("in", in_data) p.dec() return False crc_flag = (ar & 0x80) != 0x00 revision = ar & 0x7F if is_stream: payload = in_data.read(plen) crc = struct.unpack("!H", in_data.read(2))[0] else: payload = in_data[10:10 + plen] crc = struct.unpack("!H", in_data[10 + plen:10 + plen + 2])[0] crc_calc = crc16(headerdata) crc_calc = crc16(payload, crc_calc) crc_calc ^= 0xFFFF crc_ok = crc_calc == crc if crc_flag and crc_ok: p.pr("CRC ok 0x{0:04x}".format(crc)) elif crc_flag: p.pr("CRC not ok!") p.pr(" CRC: is 0x{0:04x}, calculated 0x{1:04x}".format(crc, crc_calc)) else: p.pr("No CRC") p.pr("plen {}".format(plen)) p.pr("seq {}".format(seq)) p.pr("revision {}".format(revision)) p.pr("protocol type {}".format(pt)) success = False if pt == "T": success = decode_tag(payload) p.dec() return success
def output(self, _data): # packed _data to hci frame and send it frame = HCI_DATA.to_bytes(1, 'big') + \ self.send_seq.to_bytes(1, 'big') + _data frame += crc.crc16(frame).to_bytes(2, 'big') self.send_data(frame, retry=3) self.send_seq = 0 if self.send_seq >= 0xFF else self.send_seq + 1
def tcm_result(self): if self._tcm_result != None: return self._tcm_result self._perror = -1 data_received = self.udp_result() while True: self._tcm_result = (0, None) if data_received == None or len(data_received) < 6: print 'bad tcm size' self._perror = 10 break type, size = struct.unpack('<HH', data_received[0:4]) packet = data_received[4:-2] if len(packet) != size: print 'bad tcm size' self._perror = 10 break checksum = struct.unpack('<H', data_received[-2:])[0] test_cksum = crc.crc16(data_received[:-2]) if checksum != test_cksum: print 'bad tcm crc' self._perror = 11 break self._perror = 0 self._tcm_result = (type, packet) break return self._tcm_result
def _send_with_session(self, to, session, msg_type, data): print("_send:", to._unit_addr, msg_type, session, to._counter_send, data) if session == None: raise Exception('No session') plain = bytearray() plain.append(to._unit_addr) plain.append(self._unit_addr) plain.append(msg_type) plain.extend(session) plain.extend(struct.pack('>H', to._counter_send)) if data: plain.append(len(data)) plain.extend(data) else: plain.append(0) plain.extend(CRC.crc16(plain)) pads = (16 - (len(plain) % 16)) % 16 plain.extend(pads * '=') print("sending:", plain) iv = crypto.getrandbits(32)[:2] aes = AES(self._crypto_key, AES.MODE_CBC, iv * 8) self._sock.send(self._site_id + iv + aes.encrypt(plain)) to._counter_send = (to._counter_send + 1) % 0x10000 if to._counter_send == 0: print("Reset after counter overflow") to._reset_trial = 0 to._reset_next = time.ticks_ms()
def com_session_test(adr: int): """Make session with ine device TODO! EXCEPTION if answer of device is less than 24 bytes :param adr: int address of device :return: if CRC is ok: response from device - array of 24 bytes else: string 'ERROR CRC' """ time.sleep(0.05) # without this delay don't work print('start fun:') time.clock() ser = serial.Serial() ser.baudrate = BAUD_RATE ser.port = COM_PORT ser.open() while not ser.writable(): a = 1 ser.write(form_req(adr)) while not ser.in_waiting: pass s = ser.read(ser.in_waiting) crc_cal = crc.crc16(s[0:22]) crc_real = s[len(s) - 2:len(s)] print('end fun, time:') print(time.clock()) if crc_real == crc_cal: ser.close() return s else: ser.close() return 'ERROR CRC'
def getBarCode_214(numberbarcode, modesocket=0): ''' Настройка штрихкодов чтение''' if (numberbarcode < 1 or numberbarcode > 32): raise Exception('Value out range') head2 = [0x00, 214, 02, 01, 01] head1 = array.array('B') header = array.array('B') addListInByteArray(header, head2) header.append(numberbarcode) # номер штрихкода head1.append(stx) addWordInByteArray(head1, 9, 'LH') addWordInByteArray(head1, 1, 'LH') addWordInByteArray(head1, 1, 'LH') head1.extend(header) addWordInByteArray(head1, crc.crc16(head1.tostring()[1:], crc.CRC_CCITT_XMODEM), 'HL') if modesocket == 0: ret_val = getsocket(address, port, head1) else: ret_val = getmultisocket(head1) rt = [] rt.append(int(ord(ret_val[:1]))) rt.append(str(ret_val[2:15])) return rt
def getMoreText_209(numbertext, modesocket=0): ''' Дополнительные тексты ''' head2 = [0x0, 209, 02, 01, 01] head1 = array.array('B') header = array.array('B') addListInByteArray(header, head2) head2 = [] addWordInByteArray(head2, numbertext, 'LH') header.extend(head2) head1.append(stx) addWordInByteArray(head1, 8 + 1 * len(head2), 'LH') addWordInByteArray(head1, 1, 'LH') addWordInByteArray(head1, len(head2), 'LH') head1.extend(header) addWordInByteArray(head1, crc.crc16(head1.tostring()[1:], crc.CRC_CCITT_XMODEM), 'HL') if modesocket == 0: ret_val = getsocket(address, port, head1) else: ret_val = getmultisocket(head1) rt = [] rt.append(int(ord(ret_val[:1]))) rt.append(unicode(str(ret_val[2:202]), 'cp866')) return rt pass
def getCommodityGroups_210(numgroup, modesocket=0): ''' Товарные группы ''' head2 = [0x0, 210, 02, 01, 01] head1 = array.array('B') header = array.array('B') addListInByteArray(header, head2) head2 = [] addWordInByteArray(head2, numgroup, 'LH') header.extend(head2) head1.append(stx) addWordInByteArray(head1, 8 + 1 * len(head2), 'LH') addWordInByteArray(head1, 1, 'LH') addWordInByteArray(head1, len(head2), 'LH') head1.extend(header) addWordInByteArray(head1, crc.crc16(head1.tostring()[1:], crc.CRC_CCITT_XMODEM), 'HL') if modesocket == 0: ret_val = getsocket(address, port, head1) else: ret_val = getmultisocket(head1) rt = [] rt.append(int(ord(ret_val[:1]))) rt.append(unicode(str(ret_val[2:20]), 'cp866')) rt.append(int(ord(ret_val[22:23]))) return rt
def getSellers_204(sellernumber, modesocket=0): ''' Продавцы ''' head2 = [0x0, 204, 02, 00, 01] head1 = array.array('B') header = array.array('B') addListInByteArray(header, head2) head2 = [] addWordInByteArray(head2, sellernumber, 'LH') header.extend(head2) head1.append(stx) addWordInByteArray(head1, 8 + 1 * len(head2), 'LH') addWordInByteArray(head1, 1, 'LH') addWordInByteArray(head1, len(head2), 'LH') head1.extend(header) addWordInByteArray(head1, crc.crc16(head1.tostring()[1:], crc.CRC_CCITT_XMODEM), 'HL') if modesocket == 0: ret_val = getsocket(address, port, head1) else: ret_val = getmultisocket(head1) rt = [] rt.append(int(ord(ret_val[:1]))) rt.append(unicode(str(ret_val[2:15]), 'cp866')) return rt pass
def setTara_215(numbertare, weight): ''' Тара установка ''' if (numbertare < 1 or numbertare > 16): raise Exception('Value out range') head2 = [0x0, 215, 0, 01, 01] head1 = array.array('B') header = array.array('B') addListInByteArray(header, head2) head2 = [] addWordInByteArray(head2, numbertare, 'LH') addWordInByteArray(head2, (weight & 0x0000FFFF), 'LH') addWordInByteArray(head2, ((weight & 0xFFFF0000) >> 16), 'LH') #hh=(wight & 0xFFFF0000)>>16 #ll=(wight & 0x0000FFFF) header.extend(head2) head1.append(stx) # addWordInByteArray(head1, 8 + 1 * len(head2), 'LH') # --------------- addWordInByteArray(head1, 1, 'LH') # расчет размеров и длинн тела addWordInByteArray(head1, len(head2), 'LH') # ---------------- head1.extend(header) addWordInByteArray(head1, crc.crc16(head1.tostring()[1:], crc.CRC_CCITT_XMODEM), 'HL') setsocket(address, port, head1) pass
def setFixKey_216(numberkey, numberretail, numberplu, modesocket=0): if (numberkey < 1 or numberkey > 109): raise Exception('Value out range') head2 = [0x0, 216, 0, 01, 01] head1 = array.array('B') header = array.array('B') addListInByteArray(header, head2) head2 = [] addWordInByteArray(head2, numberkey, 'LH') addWordInByteArray(head2, numberretail, 'LH') # 4 байта номера plu addWordInByteArray(head2, (numberplu & 0x0000FFFF), 'LH') addWordInByteArray(head2, ((numberplu & 0xFFFF0000) >> 16), 'LH') head2.extend([0x00, 0x00, 0x00, 0x00, 0x00, 0x00]) header.extend(head2) head1.append(stx) addWordInByteArray(head1, 8 + 1 * len(head2), 'LH') addWordInByteArray(head1, 1, 'LH') addWordInByteArray(head1, len(head2), 'LH') head1.extend(header) addWordInByteArray(head1, crc.crc16(head1.tostring()[1:], crc.CRC_CCITT_XMODEM), 'HL') if modesocket == 0: setsocket(address, port, head1) else: setmultisocket(head1) pass
def getFixKey_216(numberkey, modesocket=0): ''' Фиксированные клавиши ''' if (numberkey < 1 or numberkey > 109): raise Exception('Value out range') head2 = [0x0, 216, 2, 01, 01] head1 = array.array('B') header = array.array('B') addListInByteArray(header, head2) addWordInByteArray(header, numberkey, 'LH') head1.append(stx) addWordInByteArray(head1, 10, 'LH') addWordInByteArray(head1, 1, 'LH') addWordInByteArray(head1, 2, 'LH') head1.extend(header) addWordInByteArray(head1, crc.crc16(head1.tostring()[1:], crc.CRC_CCITT_XMODEM), 'HL') if modesocket == 0: ret_val = getsocket(address, port, head1) else: ret_val = getmultisocket(head1) rt = [] rt.append((ord(ret_val[1]) * 256) + ord(ret_val[0])) rt.append((ord(ret_val[3]) * 256) + ord(ret_val[2])) rt.append((ord(ret_val[6]) * 65526) + (ord(ret_val[5]) * 256) + ord(ret_val[4])) #print rt return rt
def com_full_session(adr_arr: int): """like com_session, but work with array of addresses :param adr_arr: array of addresses :return: array of array """ ser = serial.Serial() ser.baudrate = BAUD_RATE ser.port = COM_PORT ser.open() k = 0 s = [0] * len(adr_arr) for i in adr_arr: while not ser.writable(): pass ser.write(form_req(i)) while not ser.in_waiting: pass temp = ser.read(ser.in_waiting) time.sleep(0.05) crc_cal = crc.crc16(temp[0:22]) crc_real = temp[len(temp) - 2:len(temp)] if crc_real == crc_cal: s[k] = temp else: s[k] = 'ERROR CRC' k += 1 ser.close() return s
def frame_packet(self, packet: bytearray): if (len(packet) >= PACKET_SIZE_LIMIT): raise NotImplementedError(f"Can not send packet size {len(packet)} > {PACKET_SIZE_LIMIT}") # Must use control escape sequence for the reserved bytes escaped_packet = bytearray() for byte in packet: if(byte == FRAME_BOUNDARY or byte == CONTROL_ESCAPE): escaped_packet.append(CONTROL_ESCAPE) escaped_packet.append(byte ^ HDLC_BYTE_INVERT) else: escaped_packet.append(byte) # Compute CRC16 crc = bytearray(struct.pack("<H", crc16(packet))) # Format Packet for Transport hdlc_frame = bytearray() hdlc_frame.append(FRAME_BOUNDARY) hdlc_frame += escaped_packet hdlc_frame += crc hdlc_frame.append(FRAME_BOUNDARY) return hdlc_frame
def setBarCode_214(numberbarcode, maskbarcode, modesocket=0): ''' Настройка штрихкодов запись ''' if (numberbarcode < 1 or numberbarcode > 32): raise Exception('Value out range') #maskbarcode - 13 head2 = [0x0, 214, 0x0, 01, 01] head1 = array.array('B') header = array.array('B') addListInByteArray(header, head2) head2 = [numberbarcode, 0x30] head2.extend(getList(maskbarcode)) head2.extend([0x20, 0x20, 0x20, 0x20, 0x20]) header.extend(head2) head1.append(stx) addWordInByteArray(head1, 8 + 1 * len(head2), 'LH') addWordInByteArray(head1, 1, 'LH') addWordInByteArray(head1, len(head2), 'LH') head1.extend(header) addWordInByteArray(head1, crc.crc16(head1.tostring()[1:], crc.CRC_CCITT_XMODEM), 'HL') if modesocket == 0: setsocket(address, port, head1) else: setmultisocket(head1) pass
def fixup(self, seq_num=0): buf = self.get_buffer() if buf[0] == START_OF_PACKET: buf[1], buf[2] = le16(len(buf)+2) buf[1] = (buf[1] << 3) buf[3] = crc.crc8(buf[0:3]) buf[7], buf[8] = le16(seq_num) self.add_int16(crc.crc16(buf))
def opcode17(self, address, group, expected_length=-1): data = [address, group, self._host_address, self._host_group, 17, 5,76,79,73,03,232] request = "" for i in data: request += struct.pack('B',i) for i in crc.crc16(request): request += struct.pack('B',i) self._send(request) data = self._recv() responsecrc = data[-2:] data = data[:-2] response = "" for i in data: response += struct.pack('B',i) if not(crc.crc16(response) == responsecrc): raise RuntimeError('CRC Error')
def cmd06(self, addr, reg, value): dat = [] dat.append(addr) dat.append(0x06) dat.extend(int16_to_char(reg)) dat.extend(int16_to_char(value)) check = crc16() check.createarray(dat) return bytes([a for a in dat])
def test_crc16_with_append(self): seq = [0x01, 0x03, 0xc0, 0x20, 0x00, 0x18] b2, b1 = crc.crc16(seq, append=True) self.assertEqual(b2, 0x78) self.assertEqual(b1, 0xa) expect = [0x01, 0x03, 0xc0, 0x20, 0x00, 0x18, 0x78, 0xa] self.assertEqual(seq, expect)
def cmd03(self, addr, reg_start, reg_count): dat = [] dat.append(addr) dat.append(0x03) dat.extend(int16_to_char(reg_start)) dat.extend(int16_to_char(reg_count)) check = crc16() check.createarray(dat) return bytes([a for a in dat])
def form_req(adr: int): """Form request frame kind: 0xXX(address),0x00,0x00,0xXX(CRC low),0xXX(CRC high) :param adr: int :return: array length 5 bytes """ adr_byte = adr.to_bytes(1, byteorder='big') req_val = adr_byte + b'\x00' + b'\x00' req_val = req_val + crc.crc16(req_val) return req_val
def setPLU_207(plu, barcode, name_plu, price, tax, tarenum, fixscale=0, group=0, flg=0, timegod=499, timesale=499, misctext=0, modestr=1, modesocket=0): ''' параметр modestr тип весов 1- однострочные 2 - двух строчные ''' head2 = [0x0, 207, 00, 01, 01] head1 = array.array('B') header = array.array('B') addListInByteArray(header, head2) head2 = [] addWordInByteArray(head2, (plu & 0x0000FFFF), 'LH') addWordInByteArray(head2, ((plu & 0xFFFF0000) >> 16), 'LH') head2.extend(getList(convbar(barcode))) if modestr == 1: head2.extend(getList(convstr(name_plu[:28], 28))) else: head2.extend(getList(convstr(name_plu[:60], 60))) head2.extend([0xCC]) # p = int(price * 100) addWordInByteArray(head2, (p & 0x0000FFFF), 'LH') addWordInByteArray(head2, ((p & 0xFFFF0000) >> 16), 'LH') head2.extend([tax]) head2.extend([tarenum]) head2.extend([0x00, 0x00]) addWordInByteArray(head2, fixscale, 'LH') head2.extend([0x00, 0x00]) addWordInByteArray(head2, group, 'LH') addWordInByteArray(head2, flg, 'LH') addWordInByteArray(head2, timegod, 'LH') addWordInByteArray(head2, timesale, 'LH') addWordInByteArray(head2, misctext, 'LH') header.extend(head2) head1.append(stx) addWordInByteArray(head1, 8 + 1 * len(head2), 'LH') addWordInByteArray(head1, 1, 'LH') addWordInByteArray(head1, len(head2), 'LH') head1.extend(header) addWordInByteArray(head1, crc.crc16(head1.tostring()[1:], crc.CRC_CCITT_XMODEM), 'HL') #print head1 if modesocket == 0: setsocket(address, port, head1) else: setmultisocket(head1) pass
def check_crc(self): if 0: log("B " + " ".join("{:02x}".format(b) for b in self.data)) for i in range(1, len(self.data)): log(" i={:02} crc=0x{:04x} calc1=0x{:04x} calc2=0x{:04x}". format(i, self.crc, 0xffff ^ crc.crc16(self.data[1:i]), crc.crc_ccitt(self.data[1:i]))) self.crc_calc = crc.crc_ccitt(self.data[1:4 + self.mfl]) return self.crc_calc == self.crc
def keyslot(self, key): """ Calculate keyslot for a given key """ start = key.find("{") if start > -1: end = key.find("}", start + 1) if end > -1 and end != start + 1: key = key[start + 1:end] return crc16(key) % self.RedisClusterHashSlots
def check_crc(self): if 0: log("B " + " ".join("{:02x}".format(b) for b in self.data)) for i in range(1, len(self.data)): log(" i={:02} crc=0x{:04x} calc1=0x{:04x} calc2=0x{:04x}".format(i, self.crc, 0xffff ^ crc.crc16(self.data[1:i]), crc.crc_ccitt(self.data[1:i]))) self.crc_calc = crc.crc_ccitt(self.data[1:4+self.mfl]) return self.crc_calc == self.crc
def _build_packet(self, address, instruction, parameters): packet = [0xFF, 0xFF, 0xFD, 0x00] packet.append(address) packet.append(len(parameters)+3 % 256) # Packet_length_lower packet.append(len(parameters)+3 >> 8) # Packet_length_higher packet.append(instruction) packet += parameters crc = crc16(packet) packet.append(crc % 256) # crc low packet.append(crc >> 8) # crc high return bytes(packet)
def nvram_write_command(num, data): packet = '\x27' packet += struct.pack('<H', num) packet += data packet += '\x00\x00' packet += struct.pack('<H', crc16(packet)) packet = packet.replace('\x7d', '\x7d\x5d') packet = packet.replace('\x7e', '\x7d\x5e') packet += '\x7e' return packet
def __init__(self, canbus, filename, srcnode=247): """canbus is a canbus.Connection() object and filename is a string that is the path to the Intel Hex file that we are downloading""" self.__canbus = canbus self.ih = IntelHex(filename) self.__srcnode = srcnode cs = crc.crc16() for each in range(self.ih.minaddr(), self.ih.maxaddr()+1): cs.addByte(self.ih[each]) self.__size = self.ih.maxaddr()+1 self.__checksum = cs.getResult() self.lock = threading.Lock() self.__progress = 0.0 self.__blocks = self.__size / 128 + 1 self.__currentblock = 0 self.__blocksize = 128 self.kill = False
def build_packet(data): packet = data packet += struct.pack('<H', crc16(data)) packet = packet.replace('\x7d', '\x7d\x5d').replace('\x7e', '\x7d\x5e') packet = '\x7e' + packet + '\x7e' return packet
def test_crc16(self): seq = [0x01, 0x03, 0xc0, 0x20, 0x00, 0x18] b2, b1 = crc.crc16(seq) self.assertEqual(b2, 0x78) self.assertEqual(b1, 0xa)
def generate_eti(self): # generate ETI(NI) # SYNC buf = io.BytesIO() buf.write("\xff") # ERR # FSYNC if self.fc['FCT'] % 2 == 1: buf.write("\xf8\xc5\x49") else: buf.write("\x07\x3a\xb6") # LIDATA # FC buf.write(tobyte(self.fc['FCT'] & 0xff)) NST = len(self.stc) buf.write(tobyte((self.fc['FICF'] << 7) | NST)) if self.fc['FICF'] == 0: FICL = 0 elif self.fc['MID'] == 3: FICL = 32 else: FICL = 24 # EN 300 799 5.3.6 FL = NST + 1 + FICL + sum(subch['STL'] * 2 for subch in self.stc) p.pr("********** NST {}, FICL {}, stl {}, sum, {}".format( NST, FICL, [subch['STL'] for subch in self.stc], sum(subch['STL'] * 2 for subch in self.stc))) buf.write(tobyte( (self.fc['FP'] << 5) | (self.fc['MID'] << 3) | ((FL & 0x700) >> 8))) buf.write(tobyte(FL & 0xff)) # STC for subch in self.stc: buf.write(tobyte( (subch['SCID'] << 2) | ((subch['SAD'] & 0x300) >> 8) )) buf.write(tobyte( subch['SAD'] & 0xff )) buf.write(tobyte( (subch['TPL'] << 2) | ((subch['STL'] & 0x300) >> 8))) buf.write(tobyte( subch['STL'] & 0xff )) # EOH # MNSC buf.write(tobyte( self.mnsc & 0xff )) buf.write(tobyte( (self.mnsc & 0xff00) >> 8 )) # CRC buf.seek(4) headerdata = buf.read() crc_calc = crc16(headerdata) crc_calc ^= 0xFFFF buf.write(tobyte( (crc_calc & 0xff00) >> 8)) buf.write(tobyte( crc_calc & 0xff )) mst_start = buf.tell() # MST # FIC data buf.write(bytes(bytearray(self.fic))) # Data stream for subch in self.stc: buf.write(bytes(bytearray(subch['data']))) # EOF # CRC buf.seek(mst_start) mst_data = buf.read() crc_calc = crc16(mst_data) crc_calc ^= 0xFFFF buf.write(tobyte( (crc_calc & 0xff00) >> 8)) buf.write(tobyte( crc_calc & 0xff )) buf.write("\xff\xff") # RFU # TIST buf.write("\xff\xff\xff\xff") # TODO TIST in EDI is awful length = buf.tell() padding = 6144 - length buf.write(bytes(bytearray("\x55" * padding))) buf.seek(0) return buf.read()
def decode_pft(stream): p.inc() p.pr("start decoding PF") headerdata = stream.read(12) header = struct.unpack(pft_head_struct, headerdata) psync, pseq, findex1, findex2, findex3, fcount1, fcount2, fcount3, fec_ad_plen = header findex = (findex1 << 16) | (findex2 << 8) | findex3 fcount = (fcount1 << 16) | (fcount2 << 8) | fcount3 fec = (fec_ad_plen & 0x8000) != 0x00 addr = (fec_ad_plen & 0x4000) != 0x00 plen = fec_ad_plen & 0x3FFF # try to sync according to TS 102 821 Clause 7.4.1 if psync != "PF": p.pr("No PF Sync") p.dec() return False rs_k = 0 rs_z = 0 if fec: rs_head = stream.read(2) rs_k, rs_z = struct.unpack(pft_rs_head_struct, rs_head) headerdata += rs_head addr_source = 0 addr_dest = 0 if addr: addr_head = stream.read(4) addr_source, addr_dest = struct.unpack(pft_addr_head_struct, addr_head) headerdata += addr_head # read CRC crc = struct.unpack("!H", stream.read(2))[0] crc_calc = crc16(headerdata) crc_calc ^= 0xFFFF crc_ok = crc_calc == crc if crc_ok: p.pr("CRC ok") else: p.pr("CRC not ok!") p.pr(" read 0x{:04x}, calculated 0x{:04x}".format(crc, crc_calc)) p.pr("pseq {}".format(pseq)) p.pr("findex {}".format(findex)) p.pr("fcount {}".format(fcount)) if fec: p.pr("with fec:") p.pr(" RSk={}".format(rs_k)) p.pr(" RSz={}".format(rs_z)) if addr: p.pr("with transport header:") p.pr(" source={}".format(addr_source)) p.pr(" dest={}".format(addr_dest)) p.pr("payload length={}".format(plen)) payload = stream.read(plen) success = False if crc_ok and fec: # Fragmentation and # Reed solomon decode if pseq not in defragmenters: defragmenters[pseq] = Defragmenter(fcount, get_rs_decoder(rs_k, rs_z)) success = defragmenters[pseq].push_fragment(findex, payload) elif crc_ok and fcount > 1: # Fragmentation if pseq not in defragmenters: defragmenters[pseq] = Defragmenter(fcount, decode_af_fragments) success = defragmenters[pseq].push_fragment(findex, payload) elif crc_ok and fcount == 1: success = decode_af(payload) p.dec() return success