def wake_tc_get_header(ser, ntpoffset, debug=0):
"""
Send Ctrl-C Ctrl-C to TC module to wake it up, capture header content
Get computer's UTC time for comparison to time reported in module header
If debug flag, write module response to stderr
"""
ser.reset_input_buffer()
ser.reset_output_buffer()
wakeup = b"\x03\x03"
for b in serial.iterbytes(wakeup):
n = ser.write(b)
if debug:
LOGGER.debug("{} byte ({}) written to port".format(n, b))
time.sleep(0.1)
timecheck = datetime.utcnow() + timedelta(seconds=ntpoffset)
capture = ""
rx = 1
while rx:
rx = ser.read(ser.in_waiting or 1).decode(errors="replace")
if rx:
if debug:
LOGGER.debug(rx)
capture += rx
if capture.strip():
return timecheck, crlfpat.sub(linend, capture)
return None, None
def send_run(self):
"""
Sends run command and updates status until pump has stopped.
"""
self.ser.write(b'RUN\r')
over = False
while not over and self.ser.is_open:
# Send carriage return to receive status.
self.ser.write(b'\r')
in_packet = True
while in_packet and self.ser.is_open:
# Read all that is there.
data = self.ser.read(self.ser.in_waiting or 1)
# For each byte.
for byte in serial.iterbytes(data):
if byte == b':':
self.updateSignal.emit(SerialThread.STOPPED)
over = True
in_packet = False
elif byte == b'>':
self.updateSignal.emit(SerialThread.FORWARD)
in_packet = False
elif byte == b'*':
self.updateSignal.emit(SerialThread.STALLED)
over = True
in_packet = False
# Check if signals require processing.
QtWidgets.QApplication.processEvents()
def _generate_cmd(cmd_code, arg1=0, arg2=0):
"""Builds a command out of all the pieces of a command.
Args:
cmd_code (array): The 2 byte command code.
arg1 (int): First argument to the command if used.
arg2 (int): Second argument to the command if used.
Returns:
str: A complete command ready to be sent over serial.
"""
data = [0] * _CMD_DATA_LENGTH
data[0] = arg1
data[2] = arg2
cmd = _CMD_HEADER + cmd_code + data
HdmiMatrixController._append_checksum(cmd)
serial.iterbytes(cmd)
return cmd
def sendSLIP(port : serial.Serial, data : bytes):
for byte in serial.iterbytes(data):
if byte == END:
port.write(ESC)
port.write(ESC_END)
elif byte == ESC:
port.write(ESC)
port.write(ESC_ESC)
else:
port.write(byte)
port.write(END)
def rx(self, text):
result = ""
for b in serial.iterbytes(text):
if (self._counter % 16) == 0:
result += "\n{:04X} | ".format(self._counter)
asciicode = ord(b)
if asciicode <= 255:
result += "{:02X} ".format(asciicode)
else:
result += "?? "
self._counter += 1
return result
def main():
terminal = SimpleTerminal(Console())
decoder = EscapeDecoder(terminal)
p = subprocess.Popen([sys.executable] + sys.argv[1:],
stdout=subprocess.PIPE)
# p.stdin.close()
while True:
data = p.stdout.read(4096)
if not data:
break
for byte in serial.iterbytes(data):
decoder.handle(byte)
def data_received(self, data):
"""Find data enclosed in START/STOP, call handle_packet"""
for byte in serial.iterbytes(data):
if byte == self.START:
self.in_packet = True
elif byte == self.STOP:
self.in_packet = False
self.handle_packet(bytes(self.packet)) # make read-only copy
del self.packet[:]
elif self.in_packet:
self.packet.extend(byte)
else:
self.handle_out_of_packet_data(byte)
def data_received(self, data):
"""Find data enclosed in START/STOP, call handle_packet"""
for byte in serial.iterbytes(data):
if byte == self.START:
self.in_packet = True
elif byte == self.STOP:
self.in_packet = False
self.handle_packet(bytes(self.packet)) # make read-only copy
del self.packet[:]
elif self.in_packet:
self.packet.extend(byte)
else:
self.handle_out_of_packet_data(byte)
def data_received( self, data ):
# logging.debug( data )
for byte in serial.iterbytes( data ):
if ( byte == self.START ) and ( self.in_packet is False ):
self.in_packet = True
self.packet.extend( byte )
elif self.in_packet:
self.packet.extend( byte )
if ( ( self.packet[1] + 2 ) == len( self.packet ) ):
self.in_packet = False
if self.address == self.packet[2]: # Check if the address is correct.
if ( libscrc.lrc( bytes(self.packet) ) == 0 ): # Check if the package's crc is correct.
self.handle_packet( bytes( self.packet ) ) # Process data.
del self.packet[:] # Clear buffer.
def data_received(self, data):
"""Find data enclosed in tokens, call handle_packet"""
if self._debug:
print("DATA CHUNK RECEIVED = '{}'".format(data))
# for each byte in the recv buffer
for byte in serial.iterbytes(data):
if not self.prefix_found:
if byte == self.SERIAL_PREFIX_IN:
self.prefix_found = True
else:
if byte != self.SERIAL_SUFFIX:
self.packet.extend(byte)
else:
self.handle_packet(bytes(self.packet))
self.init_parser()
def get_answer(self, requested):
"""
Function reads the bytes until the requested answer is given.
:param requested: Kind of answer to expect.
1 = Diameter
2 = Rate
3 = Target
"""
# Init variables.
packet = bytearray()
in_packet = False
# Thread loop. While connected.
while self.ser.is_open and (requested or in_packet):
# Read all that is there.
data = self.ser.read(self.ser.in_waiting or 1)
# For each byte.
for byte in serial.iterbytes(data):
if byte == b'\n':
in_packet = True
del packet[:]
elif byte == b':':
self.updateSignal.emit(SerialThread.STOPPED)
in_packet = False
requested = 0
elif byte == b'>':
self.updateSignal.emit(SerialThread.FORWARD)
in_packet = False
requested = 0
elif byte == b'*':
self.updateSignal.emit(SerialThread.STALLED)
in_packet = False
requested = 0
elif byte == b'\r':
if requested == 1:
self.recDiaSignal.emit(float(bytes(packet)))
elif requested == 2:
self.recRatSignal.emit(float(packet[:8]), [
b'ml/mn', b'ul/mn', b'ml/hr', b'ul/hr'
].index(bytes(packet[9:])))
elif requested == 3:
self.recTarSignal.emit(float(bytes(packet)))
elif in_packet:
packet.extend(byte)
def send_message(self, message):
"""Send message out over the current com_port. """
with serial.Serial(self.com_port) as ser:
# Configure Serial Connection
# TODO: Allow for more options here.
# TODO: Allow connection over socket
ser.write_timeout = 1
for char in serial.iterbytes(message):
# Necessary wait to make sure the time machine receives each
# byte as the rs232 is a low priority source on the time
# machine. As noted in tm_manual page 4-1.
try:
ser.write(char)
except serial.SerialTimeoutException as e:
raise TimeMachineError(
"Serial Connection Timeout: Please check your connection to the Time Machine.")
t.sleep(.001)
def reader(self):
"""loop and copy serial->console"""
try:
while self.alive and self._reader_alive:
# read all that is there or wait for one byte
data = self.serial.read(self.serial.in_waiting or 1)
for byte in serial.iterbytes(data):
try:
self.escape_decoder.handle(byte)
except Exception as e:
traceback.print_exc()
# text = self.rx_decoder.decode(data)
# for transformation in self.rx_transformations:
# text = transformation.rx(text)
# self.console.write(text)
except serial.SerialException:
self.alive = False
self.console.cancel()
raise # XXX handle instead of re-raise?
def data_received(self, data):
"""Find data after HEADER, call handle_packet"""
for byte in serial.iterbytes(data):
if self.in_data and (len(self.packet) < self.data_size):
self.packet.extend(byte)
if len(self.packet) == self.data_size:
self.in_data = False
# make read-only copy
self.handle_packet(bytes(self.packet))
del self.packet[:]
# Since there is no 'byte' object, indexing a bytes or bytearray
# object yields an int. Instead, we need to compare a bytes object
# of size 1 with a bytes object of size 1
elif byte == self.HEADER[self.header_pos:self.header_pos + 1]:
self.header_pos += 1
if self.header_pos == len(self.HEADER):
self.header_pos = 0
self.in_data = True
else:
self.header_pos = 0
def main():
root = tk.Tk()
root.title('pySerial-Terminal tk_widget test')
console = tk_widget.Console(root)
# console.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
console.pack()
terminal = SimpleTerminal(console)
decoder = EscapeDecoder(terminal)
p = subprocess.Popen([sys.executable] + sys.argv[1:], stdout=subprocess.PIPE)
# p.stdin.close()
while True:
data = p.stdout.read(4096)
if not data:
break
for byte in serial.iterbytes(data):
decoder.handle(byte)
root.update_idletasks()
root.update()
root.mainloop()
def sixteen(data):
"""\
yield tuples of hex and ASCII display in multiples of 16. Includes a
space after 8 bytes and (None, None) after 16 bytes and at the end.
"""
n = 0
for b in serial.iterbytes(data):
yield ('{:02X} '.format(ord(b)), b.decode('ascii') if b' ' <= b < b'\x7f' else '.')
n += 1
if n == 8:
yield (' ', '')
elif n >= 16:
yield (None, None)
n = 0
if n > 0:
while n < 16:
n += 1
if n == 8:
yield (' ', '')
yield (' ', ' ')
yield (None, None)
def sixteen(data):
"""\
yield tuples of hex and ASCII display in multiples of 16. Includes a
space after 8 bytes and (None, None) after 16 bytes and at the end.
"""
n = 0
for b in serial.iterbytes(data):
yield ('{:02X} '.format(ord(b)), b.decode('ascii') if b' ' <= b < b'\x7f' else '.')
n += 1
if n == 8:
yield (' ', '')
elif n >= 16:
yield (None, None)
n = 0
if n > 0:
while n < 16:
n += 1
if n == 8:
yield (' ', '')
yield (' ', ' ')
yield (None, None)
def send_cmd(ser, command, debug=0):
"""
Send command to module, wait for response
Return response
"""
ser.reset_input_buffer()
ser.reset_output_buffer()
for b in serial.iterbytes(command):
n = ser.write(b)
if debug:
LOGGER.debug("{} byte ({}) written to port".format(n, b))
time.sleep(0.1)
out = ""
rx = 1
while rx:
rx = ser.read(ser.in_waiting or 1)
if rx:
out += rx.decode(errors="replace")
if debug:
LOGGER.debug(rx)
return out
def test_iterbytes(self):
self.assertEqual(list(serial.iterbytes(b'\x01\x02\x03')), [b'\x01', b'\x02', b'\x03'])
def decode(self, data, final=False):
return unicode(''.join('{:02X} '.format(ord(b)) for b in serial.iterbytes(data)))
def decode(self, data, errors='strict'):
"""b'@ab' -> '40 41 42'"""
return unicode(''.join('{:02X} '.format(ord(b))
for b in serial.iterbytes(data)))
def decode(self, data, final=False):
return unicode(''.join('{:02X} '.format(ord(b))
for b in serial.iterbytes(data)))
def test_iterbytes(self):
self.assertEqual(list(serial.iterbytes(b'\x01\x02\x03')),
[b'\x01', b'\x02', b'\x03'])
async def _telnet_read_loop(self):
"""Read loop for the socket."""
mode = M_NORMAL
suboption = None
try:
while self.is_open:
try:
data = await self._socket.read(1024)
except socket.timeout:
# just need to get out of recv form time to time to check if
# still alive
continue
except socket.error as e:
# connection fails -> terminate loop
self.logger.debug(
"socket error in reader thread: {}".format(e))
await self._read_buffer.put(None)
break
self.logger.debug('RECV %r', data)
if not data:
await self._read_buffer.put(None)
break # lost connection
for byte in iterbytes(data):
if mode == M_NORMAL:
# interpret as command or as data
if byte == IAC:
mode = M_IAC_SEEN
else:
# store data in read buffer or sub option buffer
# depending on state
if suboption is not None:
suboption += byte
else:
await self._read_buffer.put(byte)
elif mode == M_IAC_SEEN:
if byte == IAC:
# interpret as command doubled -> insert character
# itself
if suboption is not None:
suboption += IAC
else:
await self._read_buffer.put(IAC)
mode = M_NORMAL
elif byte == SB:
# sub option start
suboption = bytearray()
mode = M_NORMAL
elif byte == SE:
# sub option end -> process it now
self._telnet_process_subnegotiation(
bytes(suboption))
suboption = None
mode = M_NORMAL
elif byte in (DO, DONT, WILL, WONT):
# negotiation
telnet_command = byte
mode = M_NEGOTIATE
else:
# other telnet commands
self._telnet_process_command(byte)
mode = M_NORMAL
elif mode == M_NEGOTIATE: # DO, DONT, WILL, WONT was received, option now following
await self._telnet_negotiate_option(telnet_command, byte)
mode = M_NORMAL
finally:
self._thread = None
self.logger.debug("read thread terminated")
def write(self, message: bytes):
for l in serial.iterbytes(message):
self.interface.write(l)
self.interface.flush()
def decode(self, data, errors='strict'):
"""b'@ab' -> '40 41 42'"""
return unicode(''.join('{:02X} '.format(ord(b)) for b in serial.iterbytes(data)))
def data_received(self, data):
for byte in serial.iterbytes(data):
unsigned_byte = _unsigned_single_byte(byte)
self._checksum += unsigned_byte
self._bytes_read += 1
if self._read_state == self.READ_HEADER:
if unsigned_byte == Packets.HEADER_BYTE:
self._read_state = self.READ_NBYTES
self._checksum = unsigned_byte
self.logger.trace("received header")
else:
self.logger.warning("received byte {} while expecting header byte".format(unsigned_byte))
elif self._read_state == self.READ_NBYTES:
self._read_state = self.READ_PACKET_ID
self._expected_bytes_read = unsigned_byte
self._bytes_read = 0
self.logger.trace("received nbytes = {}".format(unsigned_byte))
# TODO: validate
elif self._read_state == self.READ_PACKET_ID:
self._current_packet_id = unsigned_byte
self._current_packet_expected_byte_lengths, self._current_packet_decoder, self._current_packet_validator = Packets.get(unsigned_byte)
if self._current_packet_decoder is None:
self.logger.warning("cannot find packet type {}".format(unsigned_byte))
self._read_state = self.READ_HEADER
else:
self._current_packet_data = []
self._read_state = self.READ_PACKET_DATA
self.logger.trace("found packet {}, expecting {} bytes".format(self._current_packet_id, self._current_packet_expected_byte_lengths))
elif self._read_state == self.READ_PACKET_DATA:
self._current_packet_data.append(byte)
self.logger.trace("received data {}".format(unsigned_byte))
if len(self._current_packet_data) >= self._current_packet_expected_byte_lengths:
data = self._current_packet_decoder(b''.join(self._current_packet_data))
self._sensor_data_next[self._current_packet_id] = data
self.logger.trace("decoded data {} for packet {}".format(data, self._current_packet_id))
# TODO: validate
if self._bytes_read >= self._expected_bytes_read:
self._read_state = self.READ_CHECKSUM
else:
self._read_state = self.READ_PACKET_ID
elif self._read_state == self.READ_CHECKSUM:
checks_out = self._checksum & 0xFF
self.logger.trace("read checksum {}, {} & 0xFF = {}".format(unsigned_byte, self._checksum, checks_out))
if checks_out == 0:
if self.log_data:
self.logger.debug("got data: {}".format(self.sensor_data))
self.sensor_data = self._sensor_data_next
self.sensor_data[Packets.TIMESTAMP] = time.time()
self._sensor_data_next = Packets()
for f in self.sensor_callbacks:
try:
f(self.sensor_data)
except Exception as e:
traceback.print_exc()
self.logger.error("failed to process sensor data via {}: {}, ignoring...".format(f.__name__, e))
else:
self.corrupted_packets += 1
self.logger.warn("failed checksum: {} & 0xFF = {}".format(self._checksum, checks_out))
self.total_packets += 1
self._read_state = self.READ_HEADER
def decode(self, data, errors="strict"):
"""b'@ab' -> '40 41 42'"""
return unicode("".join("{:02X} ".format(ord(b)) for b in serial.iterbytes(data)))
