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