def poll(self):
if self.serial_port.in_waiting > 0:
self.pkt_buffer.extend(
self.serial_port.read(self.serial_port.in_waiting))
while True:
if 0 in self.pkt_buffer:
index = self.pkt_buffer.index(0)
data = cobs.decode(self.pkt_buffer[0:index])
del self.pkt_buffer[0:index + 1]
if data is None or len(data) < 6:
self.rx_errs += 1
continue
pkt = packet.parse(data)
if pkt is not None:
if self.raw_log_callback:
self.raw_log_callback(0, data)
self.rx_pkts += 1
return pkt
else:
self.rx_errs += 1
else:
return None
def handle_packet(self, data):
self._object_ref.bytes_received = self._object_ref.bytes_received + len(
data) + 1
try:
decoded_packet = cobs.decode(data)
except:
self._object_ref.decode_error_count = self._object_ref.decode_error_count + 1
else:
# ce pa dobim korekten podatek, pogledam po seznamu handlerjev in klicem ustrezen callback
length_of_packet = len(decoded_packet)
# potegnem ven kodo
code = decoded_packet[0:2]
# in podatke
packet_data = decoded_packet[2:length_of_packet - 2]
code_and_data = decoded_packet[0:length_of_packet - 2]
# in na koncu se CRC
crc_received = int.from_bytes(decoded_packet[length_of_packet -
2:length_of_packet],
byteorder='little')
# sedaj naredim se CRC nad podatki in ukazom
crc_of_data = CRC16(True).calculate(bytes(code_and_data))
# ce sta CRC-ja enaka, potem nadaljujem, sicer pa kar odneham
if crc_of_data == crc_received:
# uspesno prejet paket
self._object_ref.packets_received = self._object_ref.packets_received + 1
# handlerji po novo
try:
index = self._object_ref.rx_code_list.index(code)
callback = self._object_ref.rx_handler_list[index]
# poklicem handler
if packet_data == None:
callback.rx_handler()
else:
callback.rx_handler(packet_data)
except:
self._object_ref.non_registered_packets_received = self._object_ref.non_registered_packets_received + 1
pass
else:
# povecam stevec CRC napak
self._object_ref.crc_error_count = self._object_ref.crc_error_count + 1
# ce je CRC handler registriran potem
if self._object_ref.crc_handler_function != False:
# dam stevec na vrsto
self._object_ref.crc_data.put(
self._object_ref.crc_error_count)
# in preko signala klicem sistem
self._object_ref.crc_print_signal.emit()
def receive(self):
success = False
packet = bytes()
data = bytes()
try:
packet = self.oven.read_until(bytes([0x00]))
# print('>', str(packet))
except Exception as e:
print(f'Error: Exception encountered on serial.read_until {e}.')
if packet:
data = cobs.decode(packet[:-1])
# print('>', str(list(data)))
success = True
return success, data
def decode(self, txt):
if txt[-1] == '\x00':
txt = txt[:-1]
p = Packet()
decoded = cobs.decode(txt)
# print ''.join( [ "%02X " % ord( x ) for x in decoded ] ).strip()
crc = self.checksum(decoded[0:-2])
crc_check = uint16(decoded[-2:])
if crc != crc_check:
raise DecodeError("CRC mismatch")
p.rtr = uint8(decoded[0]) & 0x40 != 0
p.id = uint16(decoded[0:2]) & 0x7ff
p.data = [uint8(x) for x in decoded[2:-2]]
return p
def decode(self, txt):
if txt[-1] == '\x00':
txt = txt[:-1]
p = Packet()
decoded = cobs.decode(txt)
# print ''.join( [ "%02X " % ord( x ) for x in decoded ] ).strip()
crc = self.checksum(decoded[0:-2])
crc_check = uint16(decoded[-2:])
if crc != crc_check:
raise DecodeError("CRC mismatch")
p.rtr = uint8(decoded[0]) & 0x40 != 0
p.id = uint16(decoded[0:2]) & 0x7ff
p.data = [uint8(x) for x in decoded[2:-2]]
return p
def read(self, addr):
tx = bytearray(4)
tx[0] = (addr & 0x3F0000) >> 16
tx[1] = (addr & 0xFF00) >> 8
tx[2] = addr & 0xFF
tx[3] = 3
self.dev.write(cobs.encode(tx))
del tx
self.dev.write(b'\x00')
# expect 7 bytes back + 1 overhead + 1 framing
rx = self.dev.read(9)
pk = cobs.decode(rx[:8])
val = pk[3]
val |= (pk[4] << 8)
val |= (pk[5] << 16)
val |= (pk[6] << 24)
del rx
del pk
return val
def write(self, addr, val):
tx = bytearray(7)
tx[0] = (addr & 0x3F0000) >> 16
tx[0] |= 0x80
tx[1] = (addr & 0xFF00) >> 8
tx[2] = addr & 0xFF
tx[3] = val & 0xFF
tx[4] = (val & 0xFF00) >> 8
tx[5] = (val & 0xFF0000) >> 16
tx[6] = (val & 0xFF000000) >> 24
self.dev.write(cobs.encode(tx))
del tx
self.dev.write(b'\x00')
# expect 4 bytes back + 1 overhead + 1 framing
rx = self.dev.read(6)
pk = cobs.decode(rx[:5])
val = pk[3]
del rx
del pk
return val
def process(self, data):
"""
process input data
"""
data = buf_unpack(data)
self._buf += data
frames = []
while self._idx < len(self._buf):
if self._buf[self._idx] == 0:
# recovered a frame
self._idx += 1
fr = self._buf[:self._idx]
fr = cobs.decode(fr)
fr = buf_pack(fr)
frames.append(fr)
# remove frame from input
self._buf = self._buf[self._idx:]
self._idx = 0
else:
self._idx += 1
return frames
def _decode(self, in_bytes):
decoded = cobs.decode(in_bytes)
if self._checksum_ok(decoded):
return map(ord, decoded[:-2])
else:
return None