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)
