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 ): # 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 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)))
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 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)))