def __init__(self, comport): self.comport = comport self.packet_queue = Queue(maxsize=0) self.protocol = TI_IMU.IMUFramedPacket(self.packet_queue) self.reader_thread = ReaderThread(self.comport, self.protocol)
def start(self): serial_instance = serial.serial_for_url(self.port, baudrate=115200, timeout=1) self.reader = ReaderThread(serial_instance, RobotInventorProtocol) self.reader.start() _, self.protocol = self.reader.connect()
def __init__(self, port, baudrate=115200, recv_callback=None): self.port = port self.ser = Serial(port, baudrate) self.recv_callback = recv_callback self.protocol = RF95_protocol(recv_callback) self.reader_thread = ReaderThread(self.ser, self.protocol) self.reader_thread.start()
class Serial2MQTT: def __init__(self, device, host, port, rootTopic): self._rootTopic = rootTopic self._mqttClient = mqtt.Client(client_id='mysensors', clean_session=False) self._mqttClient.on_connect = self._mqtt_on_connect self._mqttClient.on_message = self._mqtt_on_message self._mqttClient.connect_async(host, port) ser = serial.Serial(args.device, 38400, timeout=1) self._serialClient = ReaderThread(ser, lambda: MySerialReader(self._rootTopic, self._mqttClient)) self._serialProtocol = None def _mqtt_on_connect(self, client, userdata, flags, rc): self._mqttClient.subscribe(self._rootTopic + "in/#") print('Connected with result code [{}]'.format(rc)) def _mqtt_on_message(self, client, obj, msg): payload = msg.payload.decode("utf-8") print('received topic: {}. payload: {}'.format(msg.topic, payload)) fields = msg.topic.split('/') data = ";".join(fields[1:] + [payload]) print('writing msg: {}'.format(data)) self._serialProtocol.write_line(data) def run(self): self._serialClient.start() _, self._serialProtocol = self._serialClient.connect() self._mqttClient.loop_start() def stop(self): self._mqttClient.loop_stop() self._serialClient.stop()
def _enable_autoupdate(self): """Create a separate thread to auto-load updates from the device""" if self.autoupdate: return self._thread = ReaderThread(self._ser, lambda: MessagePacketizer(self)) self._ser.write(MSG_AUTOSEND) self._thread.start()
def __init__(self, device, host, port, rootTopic): self._rootTopic = rootTopic self._mqttClient = mqtt.Client(client_id='mysensors', clean_session=False) self._mqttClient.on_connect = self._mqtt_on_connect self._mqttClient.on_message = self._mqtt_on_message self._mqttClient.connect_async(host, port) ser = serial.Serial(args.device, 38400, timeout=1) self._serialClient = ReaderThread(ser, lambda: MySerialReader(self._rootTopic, self._mqttClient)) self._serialProtocol = None
def create(self): thread = None try: thread = ReaderThread(self._serial, self._protocol_factory) connection = thread.__enter__() except Exception as e: if thread is not None: thread.close() raise e return thread, connection
def run(self): with ReaderThread(self.ser, UST) as protocol: while True: if self.start_now: protocol.start_ranging() self.start_now = False self.is_running = True if self.stop_now: protocol.stop_ranging() self.stop_now = False self.is_running = False if self.is_running: self.mutex.acquire() sys.stdout.write("Reader : mutex Acquire\n") data = protocol.get_measures() self.data[:] = data[1] self.dataP[:] = data[2] self.mutex.release() sys.stdout.write("Reader : mutex Released\n") sys.stdout.write("Data Received \n") kill(os.getpid(), signal.SIGINT ) #emet un signal pour executer la fonction func time.sleep(0.001)
class TI_IMU: class IMUFramedPacket(FramedPacket): START = b"(" STOP = b")" def __init__(self, packet_queue): FramedPacket.__init__(self) self.packet_queue = packet_queue def __call__(self): return self def handle_packet(self, packet): vals = [] try: vals = [float(v.strip()) for v in (packet).split()] except ValueError: # sometimes the packet is corrupted and can't be parsed # This usually only happens once during startup, so just ignore this packet pass else: if len(vals) == 6: state = dict( zip(['x', 'y', 'z', 'roll', 'pitch', 'yaw'], vals)) try: self.packet_queue.get_nowait() except queue.Empty: pass self.packet_queue.put(state) def handle_out_of_packet_data(self, data): #print("OP: " + bytes.decode(data)) pass def __init__(self, comport): self.comport = comport self.packet_queue = Queue(maxsize=0) self.protocol = TI_IMU.IMUFramedPacket(self.packet_queue) self.reader_thread = ReaderThread(self.comport, self.protocol) def start(self): self.reader_thread.start() def get_state(self): return self.packet_queue.get()
def run_test(self): ser = serial.serial_for_url(self.dev_path, baudrate=self.baudrate, timeout=self.timeout) with ReaderThread(ser, self.make_bound_parser) as protocol: while True: time.sleep(1) print('run_test loop...')
class RobotInventorClient: def __init__(self, port: str): self.port = port def start(self): serial_instance = serial.serial_for_url(self.port, baudrate=115200, timeout=1) self.reader = ReaderThread(serial_instance, RobotInventorProtocol) self.reader.start() _, self.protocol = self.reader.connect() def close(self): self.reader.close() def __enter__(self) -> RobotInventorProtocol: self.start() return self.protocol def __exit__(self, exc_type, exc_value, traceback): self.close()
def __init__(self, parent=None, port=None, baud=115200): QWidget.__init__(self, parent) self.alive = False self.console = Console(self) self.console.key_data_signal.connect(self.write_data) self.status_bar = QStatusBar(self) layout = QGridLayout(self) layout.addWidget(self.console) layout.addWidget(self.status_bar) ser = serial.serial_for_url(port, baudrate=baud, timeout=1) t = ReaderThread(ser, SerialProtocol) t.start() _, self.protocol = t.connect() self.protocol.bind_signals(self)
async def on_start(self): # self.log.info(f'RobustSerialService: {self.device} in thread {threading.get_ident()}') self.log.info(f'Starting on {self.device}') try: ser = serial.serial_for_url(self.device, baudrate=self.baudrate, timeout=self.timeout) self.reader_thread = self.add_context( ReaderThread(ser, self.make_bound_parser)) except BaseException as e: self.log.warning(f'Problems opening port! Stopping! ({str(e)})') await self.stop()
class RF95(): def __init__(self, port, baudrate=115200, recv_callback=None): self.port = port self.ser = Serial(port, baudrate) self.recv_callback = recv_callback self.protocol = RF95_protocol(recv_callback) self.reader_thread = ReaderThread(self.ser, self.protocol) self.reader_thread.start() def send(self, message): message = b'S ' + hexlify(message) self.protocol.write_line(message.decode('utf-8')) def recv(self): ret_lines = [] ret_lines += self.protocol.lines self.protocol.lines = [] return ret_lines def setFrequency(self, frequency): message = b'F ' + repr(frequency).encode('utf-8') self.protocol.write_line(message.decode('utf-8')) def setPower(self, power): message = b'P ' + repr(power).encode('utf-8') self.protocol.write_line(message.decode('utf-8')) def setSpreadingFactor(self, sf): message = b'W ' + repr(sf).encode('utf-8') self.protocol.write_line(message.decode('utf-8')) def setCodingRate(self, cr): message = b'C ' + repr(cr).encode('utf-8') self.protocol.write_line(message.decode('utf-8')) def setBandwidth(self, bandwidth): message = b'B ' + repr(bandwidth).encode('utf-8') self.protocol.write_line(message.decode('utf-8'))
def __init__(self): self.baudrate = 9600 print('Buscando un arduino...') puertos = list(serial.tools.list_ports.comports()) for puerto in puertos: self.ser = serial.Serial(puerto.device, self.baudrate, timeout=1.0) if self.ser.isOpen() == True: print('Conectado a {}'.format(self.ser.name)) else: print('Error, Arduino no conectado') print('Creando hilo de comunicacion...') self.hilo_uart = ReaderThread(self.ser, PrintLines) #if self.hilo_uart.is_alive(): if self.hilo_uart._connection_made: print('Hilo creado') else: print('Error creando el hilo') self.flag_posicion_cero = False self.flag_paso_realizado = False self.flag_estado_recibido = False self.elevacion = 0 self.azimut = 0 self.fin_de_trama_derecho = False self.fin_de_trama_izquierdo = False self.fin_de_trama_inferior = False self.fin_de_trama_superior = False self.iniciar()
def _connect_comport(self, comport: str, attributes: Dict, protocol: Dict) -> Dict[str, str]: """ Connect to specified serial comport. """ if comport in self.serial_threads: # Connect again with new attributes # Closing current connection first self._close_comport(comport) self.logger.debug(f'Connecting to {comport}...') ser = serial.serial_for_url(comport, **attributes) reader = ReaderThread( ser, lambda: AutomataProtocol(logger=self.logger, **protocol)) reader.start() transport, protocol = reader.connect() self.serial_threads[comport] = { 'attributes': attributes, 'reader': reader, 'transport': transport, 'protocol': protocol, } return { 'result': f'{comport} connected successfully', }
def __init__( self, port: str = '/dev/ttyACM0', baud: int = 115200, callbacks: Optional[BotvacDriverCallbacks] = None, ): self._base_width = 240 # mm self._max_speed = 300 # mm/s self._callbacks = callbacks self._stopped = False # if the robot should not be moving self._port = serial.Serial(port, baud, timeout=1) self._reader = ReaderThread(self._port, self._get_reader) self._reader.start() self._reader._connection_made.wait() if not self._reader.alive: raise RuntimeError('connection_lost already called') self._protocol = self._reader.protocol self._setTestMode(True) time.sleep( 0.5) # TODO should be able to build this into our communications self._setLDS(True)
def main(self): with ReaderThread(self.ser, self.PrintLines) as protocol: control = Control(2, 2000, 0) sleep(1) for roop in range(0, 100): global timer now = timer.getTimeFloat() axis1 = control.make_sin(now) axis2 = control.make_sin(now) axis3 = control.make_sin(now) outvalue = control.get_out_sin_str(now, now, now) # outvalue = control.get_out_square_str(now, now, now) protocol.write_line(outvalue) self.writer.writeRow(timer.getTimeString(), axis1, axis2, axis3) usleep(100)
def main(): signal.signal(signal.SIGINT, signal_handler) print("Press Ctrl+C to quit") if not os.path.exists(args.out_dir): os.makedirs(args.out_dir) ser = Serial(port=args.port, baudrate=args.baudrate, timeout=1) with ReaderThread(ser, SerialIO) as protocol: while not done: try: arr = q.get(False) if args.show_signal: showSignal(arr) except Empty: pass time.sleep(0.1)
def loop(self, port, baudrate=115200): ser = serial.serial_for_url(port, baudrate=115200) log_data = list() timeout = 30 # auto close serial with ReaderThread(ser, LineReader) as protocol: while True: try: log_line = log_queue.get(timeout=timeout).strip() if self.deal_line_func(log_line) == False: break log_data.append(log_line) except queue.Empty: continue return log_data
def __init__(self, websocket_port, serial_port): self.n_packet = 0 try: self.ser = serial.Serial(serial_port) except serial.SerialException as e: logging.error("Can't find teensy: {}".format(e)) if USE_DUMMY: logging.warning('Using serial dummy') self.dummy = SerialDummy() self.ser = self.dummy.ser else: exit() self.serial_reader = ReaderThread(self.ser, PacketReceiver).__enter__() self.serial_reader.commander = self # Websocket server self.websocket_server = WebsocketServer(websocket_port) self.websocket_server.set_fn_message_received(self.ws_msg_rcv) self.websocket_server.set_fn_new_client(self.ws_client_connect) self.websocket_server.set_fn_client_left(self.ws_client_left) self.websocket_thread = threading.Thread( target=self.websocket_server.run_forever) self.websocket_thread.daemon = True self.websocket_thread.start()
def main(argv): logging.basicConfig(stream=sys.stdout, level=logging.INFO, format='%(asctime)-15s - %(message)s') parser = argparse.ArgumentParser( description="Primitive socat-like relay from serial to tcp") parser.add_argument('--serial', nargs='?', type=str, required=True) parser.add_argument('--host', nargs='?', type=str, required=True) parser.add_argument('--port', nargs='?', type=int, required=True) parser.add_argument('--baud', nargs='?', type=int, default=19200) args = parser.parse_args(argv) serial_name = args.serial serial_baud = args.baud target_host = args.host target_port = args.port _log.info(f"launching for serial port {serial_name}, baud {serial_baud}.") _log.info(f"relaying to {target_host}:{target_port}") tty = Serial( port=serial_name, baudrate=serial_baud, bytesize=8, parity='N', stopbits=1, timeout=None, xonxoff=0, rtscts=0, ) ProtoClass = build_protocol_class(target_host, target_port) reader = ReaderThread(tty, ProtoClass) reader.start() print("reader thread started") reader.join()
client.subscribe(OUTGOING) def message(serial_protocol, mosq, obj, msg): payload = str(msg.payload.decode("utf-8")) print('Feed {0} received new value: {1}'.format(msg.topic, payload)) if payload == 'HTRON': print("Writing ON to serial") serial_protocol.write_line("HTRON") else: print("Writing OFF to serial") serial_protocol.write_line("HTROFF") if __name__ == '__main__': try: # try and connect to ttyACM0 ser = serial.serial_for_url('/dev/ttyACM0', baudrate=9600, timeout=1) except serial.SerialException: # that failed, try ttyACM1 instead ser = serial.serial_for_url('/dev/ttyACM1', baudrate=9600, timeout=1) client.on_connect = connected # Connect to the MQTT server. client.connect('localhost') with ReaderThread(ser, SerialDataReader) as protocol: client.on_message = partial(message, protocol) client.loop_forever()
class SenTorrMod(Instrument): def _initialize(self): self._rlock = threading.RLock() self._driver_A = LEDDriver() self._driver_B = LEDDriver() self._driver_A.decoders[Address.Digit0] = LEDDriver.decode_digit self._driver_A.decoders[Address.Digit1] = LEDDriver.decode_digit self._driver_A.decoders[Address.Digit2] = sign_map.__getitem__ self._driver_A.decoders[Address.Digit3] = LEDDriver.decode_digit self._ser = Serial(self._paramset['port'], timeout=1.0) self._thread = None def close(self): if self._thread: self._thread.stop() self._ser.close() @property def autoupdate(self): return bool(self._thread) @autoupdate.setter def autoupdate(self, enable): if enable: self._enable_autoupdate() else: self._enable_autoupdate() def _enable_autoupdate(self): """Create a separate thread to auto-load updates from the device""" if self.autoupdate: return self._thread = ReaderThread(self._ser, lambda: MessagePacketizer(self)) self._ser.write(MSG_AUTOSEND) self._thread.start() def _disable_autoupdate(self): if not self.autoupdate: return self._thread.stop() self._thread = None self._ser.write(MSG_NOAUTOSEND) @staticmethod def _burst_messages(buf): """Yields pairs of message tuples (addr, data) from a buffer""" for i in range(0, len(buf), 4): addr_B, data_B, addr_A, data_A = struct.unpack_from( '>BBBB', buf, i) yield ((0x0F & addr_A, data_A), (0x0F & addr_B, data_B)) def _grab_packet(self): """Grab the bytes from the most recent burst packet""" self._ser.reset_input_buffer() self._ser.write(MSG_GET_ONE) # Poll the arduino msg = self._ser.read(264) if msg.endswith(TERMINATOR): return msg[:-len(TERMINATOR)] raise Error("Received invalid message") def update(self): """Poll the device for its current state""" self._update(self._grab_packet()) def _update(self, packet): with self._rlock: for (msg_a, msg_b) in self._burst_messages(packet): self._driver_A.read_message(*msg_a) self._driver_B.read_message(*msg_b) @property def pressure(self): """The ion gauge's pressure reading""" with self._rlock: # Lock to make sure digits and units match digits = self._driver_A.digits()[:4] units = self._units() try: disp = ''.join(digits) except TypeError: raise Error("Unknown digit values {}".format(digits)) if disp == ' ': raise Error( "Must update at least once before reading the pressure") elif disp == '0F F': raise Error("Ion gauge is off") elif disp.endswith('E'): raise Error(err_map[disp]) try: mag = float(digits[0] + digits[1] + 'e' + digits[2] + digits[3]) return mag * units except ValueError: raise Error("Unknown digit values {}".format(digits)) def _units(self): with self._rlock: data = self._driver_B.digit(5) mbar_on = bool(data & MASK_TOP) torr_on = bool(data & MASK_BOT) if mbar_on and torr_on: raise Exception("Both mBar and Torr lights are on! Nonsense!") if mbar_on: return u.mbar elif torr_on: return u.torr else: return u.Pa @property def degas_on(self): with self._rlock: d6 = self._driver_B.digit(6) return bool(d6 & MASK_TOP)
#~ print 'handle_packet' #~ def data_received(self, data): #~ print('data received', repr(data)) def handle_line(self, data): print 'handle_line' sys.stdout.write('line received: {}\n'.format(repr(data))) def connection_lost(self, exc): if exc: traceback.print_exc(exc) sys.stdout.write('port closed\n') ser = serial.serial_for_url(UART_PORT_NAME, baudrate=UART_BAUD_RATE, timeout=5) protocol = ReaderThread(ser, PrintLines) protocol.write_line('M105') protocol.write_line('G28 X0 Y0') time.sleep(5) #~ protocol.write_line('hello') #~ time.sleep(2) #~ class GCodeReader(LineReader): #~ def __init__(self, ser): #~ super(GCodeReader, self).__init__(ser) #~ def handle_line(self, line): #~ print 'handle_line: ['+line+']'
class BotvacDriver: """Interface to the mobile base and its sensors.""" def __init__( self, port: str = '/dev/ttyACM0', baud: int = 115200, callbacks: Optional[BotvacDriverCallbacks] = None, ): self._base_width = 240 # mm self._max_speed = 300 # mm/s self._callbacks = callbacks self._stopped = False # if the robot should not be moving self._port = serial.Serial(port, baud, timeout=1) self._reader = ReaderThread(self._port, self._get_reader) self._reader.start() self._reader._connection_made.wait() if not self._reader.alive: raise RuntimeError('connection_lost already called') self._protocol = self._reader.protocol self._setTestMode(True) time.sleep( 0.5) # TODO should be able to build this into our communications self._setLDS(True) def __del__(self): self._setLDS(False) self._setTestMode(False) def _get_reader(self): return ResponseReader(self._callbacks) @property def base_width(self) -> int: """Distance between wheel centers, in mm.""" return self._base_width @property def max_speed(self) -> int: """Max speed of a robot wheel, in mm/s.""" return self._max_speed def _setTestMode(self, on: bool) -> None: self._protocol.write_line('testmode {}'.format(_boolstr(on))) def _setLDS(self, on: bool) -> None: self._protocol.write_line('setldsrotation {}'.format(_boolstr(on))) def setMotors(self, left_dist: int, right_dist: int, speed: int) -> None: """Set motors, distance left & right + speed.""" """ The following is a work-around for a bug in the Neato API. The bug is that the robot won't stop instantly if a 0-velocity command is sent - the robot could continue moving for up to a second. To work around this bug, the first time a 0-velocity is sent in, a velocity of 1,1,1 is sent. Then, the zero is sent. This effectively causes the robot to stop instantly. """ if (int(left_dist) == 0 and int(right_dist) == 0 and int(speed) == 0): if (not self._stopped): self._stopped = True left_dist = 1 right_dist = 1 speed = 1 else: self._stopped = False self._protocol.write_line( 'setmotor lwheeldist {} rwheeldist {} speed {}'.format( left_dist, right_dist, speed)) def requestEncoders(self): """Send a request for the latest motor encoder status.""" self._protocol.write_line(CMD_MOTORS) def requestBattery(self) -> None: """Send a request for latest battery status.""" self._protocol.write_line(CMD_BATTERY) def requestScan(self) -> None: """Send a request for latest LIDAR scan.""" self._protocol.write_line(CMD_LASER) def requestAccel(self) -> None: """Send a request for the latest accelerometer reading.""" self._protocol.write_line(CMD_ACCELEROMETER)
self.send_cmd('mac pause') self.send_cmd('radio set pwr 10') self.send_cmd('radio rx 0') self.send_cmd("sys set pindig GPIO10 0") def handle_line(self, data): if data == "ok" or data == 'busy': return if data == "radio_err": self.send_cmd('radio rx 0') return self.send_cmd("sys set pindig GPIO10 1", delay=0) print(data) time.sleep(.1) self.send_cmd("sys set pindig GPIO10 0", delay=1) self.send_cmd('radio rx 0') def connection_lost(self, exc): if exc: print(exc) print("port closed") def send_cmd(self, cmd, delay=.5): self.transport.write(('%s\r\n' % cmd).encode('UTF-8')) time.sleep(delay) ser = serial.Serial(args.port, baudrate=57600) with ReaderThread(ser, PrintLines) as protocol: while(1): pass
if "subcommand" in cmd: has_handler = cmd["subcommand"] in sysex_command_handler if has_handler: sysex_command_handler[cmd["subcommand"]](cmd["subcommand"], cmd["data"]) else: print("SYSEX {0:x} {1} {2}".format(cmd["subcommand"], has_handler, data)) else: has_handler = cmd["command"] in command_handler if has_handler: command_handler[cmd["command"]](cmd["command"], cmd["data"]) else: print("{0:x} {1} {2}".format(cmd["command"], has_handler, data)) ser = serial.Serial("/dev/ttyAMA0", 115200) reader = ReaderThread(ser, get_handler) reader.start() def signal_handler(sig, frame): print('You pressed Ctrl+C') ser.close() os._exit(0) signal.signal(signal.SIGINT, signal_handler) def reset_queue(): while not(command_queue.empty()): command_queue.get_nowait() def send_sysex(bytes): reader.write(chr(0xF0))
signal.signal(signal.SIGTERM, sig_handler) print(f'================ serial={SERIAL_PORT}, mqtt={MQTT_HOST} ================') ser.port = SERIAL_PORT ser.baudrate = SERIAL_BAUDRATE ser.open() client.on_connect = on_connect client.on_message = on_message client.on_disconnect = on_disconnect client.connect_async(host=MQTT_HOST) client.loop_start() with ReaderThread(ser, SerialHandler) as protocol: protocol: LineReader while True: target, msg = msg_q.get() print('Sending', target, msg) if target == 'serial': protocol.write_line(msg) if target == 'mqtt': client.publish('brewcast/device/state/valve-hack', json.dumps(msg), retain=True) except KeyboardInterrupt: pass
class Arduino: def __init__(self): self.baudrate = 9600 print('Buscando un arduino...') puertos = list(serial.tools.list_ports.comports()) for puerto in puertos: self.ser = serial.Serial(puerto.device, self.baudrate, timeout=1.0) if self.ser.isOpen() == True: print('Conectado a {}'.format(self.ser.name)) else: print('Error, Arduino no conectado') print('Creando hilo de comunicacion...') self.hilo_uart = ReaderThread(self.ser, PrintLines) #if self.hilo_uart.is_alive(): if self.hilo_uart._connection_made: print('Hilo creado') else: print('Error creando el hilo') self.flag_posicion_cero = False self.flag_paso_realizado = False self.flag_estado_recibido = False self.elevacion = 0 self.azimut = 0 self.fin_de_trama_derecho = False self.fin_de_trama_izquierdo = False self.fin_de_trama_inferior = False self.fin_de_trama_superior = False self.iniciar() def iniciar(self): self.reset() self.hilo_uart.start() def reset(self): print('\n\nResetear arduino') print('--------------------\n') print('Esperando...') #Reseteamos el arduino self.ser.setDTR(False) #Esperamos 1 segundo time.sleep(0.1) self.ser.flushInput() self.ser.setDTR(True) print('Listo\n\n') def enviar_trama(self, trama): self.ser.write(trama.encode()) def cerrar(self): if self.hilo_uart.is_alive(): self.hilo_uart.close() if self.ser.isOpen(): self.ser.close() def esta_abierto(self): return self.ser.isOpen() and self.hilo_uart.is_alive() def llevar_a_cero(self): print('\n\nLlevar a posicion cero') print('--------------------------\n') self.enviar_trama('<0>') print('Esperando...') while self.flag_posicion_cero != True: pass self.flag_posicion_cero = False print('Listo\n\n') def leer_posicion_actual(self): print('\n\nLeer posicion actual') print('--------------------------\n') self.enviar_trama('<S>') while self.flag_estado_recibido != True: pass self.flag_estado_recibido = False print('Elevacion: {}'.format(self.elevacion)) print('Azimut: {}\n\n'.format(self.azimut)) def set_flag_posicion_cero(self): self.flag_posicion_cero = True
if len(maybes) == 0: tkMessageBox.showerror('Not connected', 'Cannot find USB device') sys.stderr.write( 'missing serial port (maybe /dev/tty.usbserial-something)\n') sys.exit(1) if len(maybes) > 1: sys.stderr.write( 'not sure which serial port to use. ' 'likely candidates:\n{}\n'.format('\n'.join( map( lambda m: '{}\t{}\t{}'.format(m.device, m.description, m.manufacturer), maybes)))) sys.exit(1) port = maybes[0].device s = Serial(port, 9600) with ReaderThread(s, Packetizer) as device: if init: time.sleep(2) device.send(k103.init('C')) time.sleep(0.2) device.send(k103.init('P')) time.sleep(0.2) app = ui.App(device=device) app.master.geometry('640x700+320+0') app.master.minsize(512, 480) app.master.lift() # dunno why this helps with first render app.mainloop()
colorama.init() if 'PYTHONUNBUFFERED' not in os.environ: os.environ['PYTHONUNBUFFERED'] = '1' command = [sys.executable] command.extend(sys.argv) sp.call(command) sys.exit(0) ser = serial.serial_for_url('/dev/ttyUSB0', baudrate=115200, timeout=1) with ReaderThread(ser, SerialProtocol) as protocol: CTRL_S = chr(ord(readchar.key.CTRL_A) + ord('s') - ord('a')) while True: key = readchar.readkey() if key == readchar.key.CTRL_D: break if key == CTRL_S: sys.stdout.write('Save to files\n') sys.stdout.flush() protocol.write_packet('\r') protocol.write_packet(key)