def _init_serial(self, spec):
"""Initialise the serial object."""
addr, val = parse_protocol_string(spec)
try:
if not addr and not val:
pass
elif addr == u'STDIO' or (not addr and val.upper() == u'STDIO'):
return SerialStdIO(val.upper() == u'CRLF')
else:
if not serial:
logging.warning(
u'Could not attach %s to COM device. Module `serial` not available: %s',
spec, logging_msg
)
return None
if addr in (u'SOCKET', u'RFC2217'):
# throws ValueError if too many :s, caught below
host, socket = val.split(u':')
url = u'%s://%s:%s' % (addr.lower(), host, socket)
stream = serial.serial_for_url(url, timeout=0, do_not_open=True)
# monkey-patch serial object as SocketSerial does not have this property
stream.out_waiting = 0
return stream
elif addr == u'PORT':
# port can be e.g. /dev/ttyS1 on Linux or COM1 on Windows.
return serial.serial_for_url(val, timeout=0, do_not_open=True)
else:
raise ValueError(u'Invalid protocol `%s`' % (addr,))
except (ValueError, EnvironmentError) as e:
logging.warning(u'Could not attach %s to COM device: %s', spec, e)
return None
def test_custom_url(self):
"""custom protocol handlers"""
# it's unknown
self.assertRaises(ValueError, serial.serial_for_url, "test://")
# add search path
serial.protocol_handler_packages.append('handlers')
# now it should work
serial.serial_for_url("test://")
# remove our handler again
serial.protocol_handler_packages.remove('handlers')
# so it should not work anymore
self.assertRaises(ValueError, serial.serial_for_url, "test://")
def test_failed_connection(self):
# connection to closed port
s = serial.serial_for_url('rfc2217://127.99.99.99:2217', do_not_open=True)
self.failUnlessRaises(serial.SerialException, s.open)
self.assertFalse(s.is_open)
s.close() # no errors expected
# invalid address
s = serial.serial_for_url('rfc2217://127goingtofail', do_not_open=True)
self.failUnlessRaises(serial.SerialException, s.open)
self.assertFalse(s.is_open)
s.close() # no errors expected
# close w/o open is also OK
s = serial.serial_for_url('rfc2217://irrelevant', do_not_open=True)
self.assertFalse(s.is_open)
s.close() # no errors expected
def _spec_open_one(spec):
if isinstance(spec, basestring):
descr = serial.serial_for_url(spec)
descr.nonblocking()
return descr
elif isinstance(spec, dict):
# We have to remove the port thing for passing to the
# function, but we want to keep the original spec intact
_spec = dict(spec)
url = _spec.pop('port')
descr = serial.serial_for_url(url, **_spec)
descr.nonblocking()
return descr
else:
raise RuntimeError("Don't know how to open: %s" % spec)
def __init__(self, port=PORT, baud=BAUD, start_baud=START_BAUD):
log.info('opening port %s with %s baud', port, start_baud)
if port == 'loop://':
self._port = serial.serial_for_url(port, start_baud, timeout=Uploader.TIMEOUT)
else:
self._port = serial.Serial(port, start_baud, timeout=Uploader.TIMEOUT)
self.start_baud = start_baud
self.baud = baud
# Keeps things working, if following conections are made:
## RTS = CH_PD (i.e reset)
## DTR = GPIO0
self._port.setRTS(False)
self._port.setDTR(False)
def sync():
# Get in sync with LUA (this assumes that NodeMCU gets reset by the previous two lines)
log.debug('getting in sync with LUA');
self.clear_buffers()
try:
self.exchange(';') # Get a defined state
self.writeln('print("%sync%");')
self.expect('%sync%\r\n> ')
except CommunicationTimeout:
raise DeviceNotFoundException('Device not found or wrong port')
sync()
if baud != start_baud:
self.set_baudrate(baud)
# Get in sync again
sync()
self.line_number = 0
def get_data(engine, TBase, port, baudrate=115200, timeout=1):
'''
'''
ser = serial.serial_for_url(port, baudrate=baudrate, timeout=timeout) # Open com port
t1old = 0 # Initialization
t2old = 0 # Initialization
while 1: # While TRUE read a com port
data = ser.read(14) # Read 14 bytes
#print data
if (data != '') and (data != []): # Check for data
#print 'data: ',repr(data)
try:
# Unpack readed data
c=unpack('>h',str(bytearray(data)[4:-8]))
t0=unpack('>l',str(bytearray(data)[6:-4]))
t1new=unpack('>h',str(bytearray(data)[10:-2]))
t2new=unpack('>h',str(bytearray(data)[12:]))
except:
continue
delta = int(t2new[0])-int(t1new[0])
now = dt.datetime.now() # Current date and time
print now.strftime('%Y-%m-%d %H:%M:%S'), 'dT1='+time2str(t1new[0]+t0[0]-t1old)+',', \
'dT1='+time2str(t1new[0]+t0[0]-t1old)+',', 'Label='+str(c[0])+',', 'T0='+str(t0[0])+',', \
'T1+='+str(t1new[0])+',', 'T2+='+str(t2new[0])+',', 'dlt='+str(delta)
#send data to base
fillDB(engine, TBase, now.strftime('%Y-%m-%d %H:%M:%S'), str(c[0]), time2str(t1new[0]+t0[0]-t1old)) # или t2new в зависимости от выбора. выбор дописать
t1old = t1new[0]+t0[0] # Time1 on last lap
t2old = t2new[0]+t0[0] # Time2 on last lap
ser.close() # Close com port
def __init__(self, portname):
self.serialport = serial.serial_for_url(portname, do_not_open=True)
self.serialport.close() # In case port is already open
self.serialport.open()
self.serialport.write("++addr 10\n".encode())
self.successread = 0
self.failread = 0
def try_connect(url, tries=10, step=0.5, *args, **kwargs):
""" Try connecting 'tries' time to url tuple
Sleep 'step' between each tries.
If last trial fails, the SerialException is raised
The goal is to be resilient to the fact that serial_aggregator might be
(re)starting. """
# Run 'tries -1' times with 'try except'
for _ in range(0, tries - 1):
try:
return serial.serial_for_url(url, *args, **kwargs)
except serial.SerialException:
time.sleep(step)
# Last connection should run an exception
return serial.serial_for_url(url, *args, **kwargs)
def open(self, wait = True):
# ATTN: timeout is essential else realine will block.
try:
self.port = serial.serial_for_url( config.args_.port
, self.baudRate , timeout = 0.5
)
except OSError as e:
# Most like to be a busy resourse. Wait till it opens.
print("[FATAL] Could not connect")
print(e)
if wait:
_logger.warn("[INFO] Device seems to be busy. I'll try to reconnect"
" after some time..."
)
time.sleep(1)
self.open( True )
else:
quit()
except Exception as e:
_logger.error("[FATAL] Failed to connect to port. Error %s" % e)
quit()
if wait:
print("[INFO] Waiting for port %s to open" % self.path, end='')
while not self.port.isOpen():
if int(time.time() - tstart) % 2 == 0:
print('.', end='')
sys.stdout.flush()
print(" ... OPEN")
def __init__(self, url=None, dev=None, num_boards=3):
if dev is None:
dev = serial.serial_for_url(url)
self.dev = dev
self.num_boards = num_boards
self.num_channels = self.num_dacs * self.num_boards
self.channels = [Channel() for i in range(self.num_channels)]
def __init__(self, channel, baudrate=115200, timeout=0.1, rtscts=False,
*args, **kwargs):
"""
:param str channel:
The serial device to open. For example "/dev/ttyS1" or
"/dev/ttyUSB0" on Linux or "COM1" on Windows systems.
:param int baudrate:
Baud rate of the serial device in bit/s (default 115200).
.. warning::
Some serial port implementations don't care about the baudrate.
:param float timeout:
Timeout for the serial device in seconds (default 0.1).
:param bool rtscts:
turn hardware handshake (RTS/CTS) on and off
"""
if not channel:
raise ValueError("Must specify a serial port.")
self.channel_info = "Serial interface: " + channel
self.ser = serial.serial_for_url(
channel, baudrate=baudrate, timeout=timeout, rtscts=rtscts)
super(SerialBus, self).__init__(channel=channel, *args, **kwargs)
def open(self, device, baudrate): #self.serial = serial.Serial( self.serial = serial.serial_for_url( device, baudrate, bytesize=serial.EIGHTBITS, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, timeout=SERIAL_TIMEOUT, xonxoff=False, rtscts=False) # Toggle DTR to reset Arduino try: self.serial.setDTR(0) except IOError: pass time.sleep(1) CNC.vars["state"] = CONNECTED CNC.vars["color"] = STATECOLOR[CNC.vars["state"]] #self.state.config(text=CNC.vars["state"], # background=CNC.vars["color"]) # toss any data already received, see # http://pyserial.sourceforge.net/pyserial_api.html#serial.Serial.flushInput self.serial.flushInput() try: self.serial.setDTR(1) except IOError: pass time.sleep(1) self.serial.write(b"\n\n") self._gcount = 0 self._alarm = True self.thread = threading.Thread(target=self.serialIO) self.thread.start() return True
def available_ports():
usb_serial_ports = filter(
(lambda x: x.startswith('ttyUSB')),
os.listdir('/dev'))
ports = []
for p in usb_serial_ports:
ports.append(serial_for_url('/dev/'+p, do_not_open=True))
"""
also check for old school serial ports, my hope is that this will enable
both USB serial adapters and standard serial ports
Scans COM1 through COM255 for available serial ports
returns a list of available ports
"""
for i in range(256):
try:
p = Serial(i)
p.close()
ports.append(p)
except SerialException:
pass
return ports
def __init__(self, port, baudRate, parity, rtscts=False, xonxoff=False,
echo=False, convert_outgoing=1, repr_mode=0):
QObject.__init__(self)
try:
self.serial = serial.serial_for_url(port, baudRate, parity=parity,
rtscts=rtscts, xonxoff=xonxoff,
timeout=1)
except AttributeError:
# happens when the installed pyserial is older than 2.5. use the
# Serial class directly then.
self.serial = serial.Serial(port, baudRate, parity=parity,
rtscts=rtscts, xonxoff=xonxoff,
timeout=1)
self.echo = echo
self.repr_mode = repr_mode
self.convert_outgoing = convert_outgoing
self.newline = (0, 1, 2)[self.convert_outgoing]
self.dtr_state = True
self.rts_state = True
self.break_state = False
####################
self.alive = True
self.transmitter_thread = None
self.receiver_thread = None
self.log = list()
self.xlogger = None
self.switchersLst = []
self.wigwagsLst = []
self.balisesLst = []
self.sendCommandLog = []
def open(self):
# TODO find correct port on our own, could be done with
# serial.tools.list_ports, but that seems to have some
# problems at the moment.
try:
self._serial = serial.serial_for_url(self.get_url(), 115200)
except serial.SerialException as e:
raise DriverException(e)
print "Serial information:"
print "name: ", self._serial.name
print "port: ", self._serial.port
print "baudrate: ", self._serial.baudrate
print "bytesize: ", self._serial.bytesize
print "parity: ", self._serial.parity
print "stopbits: ", self._serial.stopbits
print "timeout: ", self._serial.timeout
print "writeTimeout: ", self._serial.writeTimeout
print "xonxoff: ", self._serial.xonxoff
print "rtscts: ", self._serial.rtscts
print "dsrdtr: ", self._serial.dsrdtr
print "interCharTimeout:", self._serial.interCharTimeout
self._serial.timeout = 0
def initSerialPort(portPath = '/dev/ttyACM'+ str(sys.argv[4]), baudRate = 9600):
global logWin_
global serial_port_
global serial_
serial_port_ = serial.serial_for_url(portPath, baudRate, timeout = 1)
print('[INFO] Connected to %s' % serial_port_)
serial_ = '%s' % portPath.split('/')[-1]
def change_port(self):
"""Have a conversation with the user to change the serial port"""
with self.console:
try:
port = ask_for_port()
except KeyboardInterrupt:
port = None
if port and port != self.serial.port:
# reader thread needs to be shut down
self._stop_reader()
# save settings
settings = self.serial.getSettingsDict()
try:
new_serial = serial.serial_for_url(port, do_not_open=True)
# restore settings and open
new_serial.applySettingsDict(settings)
new_serial.rts = self.serial.rts
new_serial.dtr = self.serial.dtr
new_serial.open()
new_serial.break_condition = self.serial.break_condition
except Exception as e:
sys.stderr.write('--- ERROR opening new port: {} ---\n'.format(e))
new_serial.close()
else:
self.serial.close()
self.serial = new_serial
sys.stderr.write('--- Port changed to: {} ---\n'.format(self.serial.port))
# and restart the reader thread
self._start_reader()
def __init__(self, port=PORT, baud=BAUD):
log.info('opening port %s', port)
if port == 'loop://':
self._port = serial.serial_for_url(port, baud, timeout=Uploader.TIMEOUT)
else:
self._port = serial.Serial(port, baud, timeout=Uploader.TIMEOUT)
# Keeps things working, if following conections are made:
## RTS = CH_PD (i.e reset)
## DTR = GPIO0
self._port.setRTS(False)
self._port.setDTR(False)
def sync():
# Get in sync with LUA (this assumes that NodeMCU gets reset by the previous two lines)
log.debug('getting in sync with LUA');
self.exchange(';') # Get a defined state
self.writeln('print("%sync%");')
self.expect('%sync%\r\n> ')
sync()
if baud != Uploader.BAUD:
log.info('Changing communication to %s baud', baud)
self.writeln(UART_SETUP.format(baud=baud))
# Wait for the string to be sent before switching baud
time.sleep(0.1)
self.set_baudrate(baud)
# Get in sync again
sync()
self.line_number = 0
def handle_listen(args):
port = serial.serial_for_url(args.port, args.baudrate)
conn = SerialRatpConnection(port)
conn.listen()
while True:
conn.wait(None)
conn.close()
def _autoprobe(self):
success = False
baudrate = 9600
parity = 'N'
rtscts = False
xonxoff = False
timeout = 10
for i in range(20):
port = "/dev/ttyUSB{0}".format(i)
try:
self.serial = serial.serial_for_url(port, baudrate, parity=parity, rtscts=rtscts, xonxoff=xonxoff, timeout=timeout)
except AttributeError:
# happens when the installed pyserial is older than 2.5. use the
# Serial class directly then.
try:
self.serial = serial.Serial(port, baudrate, parity=parity, rtscts=rtscts, xonxoff=xonxoff, timeout=timeout)
except:
continue
except:
continue
d = self._sendcommand(b"ATE0", 10)
if d == b"ATE0\r\nOK\r\n" or d == b"\r\nOK\r\n":
success = True
break
return success
def main():
with serial.serial_for_url(SERIAL_PORT, baudrate=BAUD_RATE, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, bytesize=serial.EIGHTBITS) as xbee:
controller_state = ControllerState()
watchdog_timer = 0
# Run joystick listener loop
while True:
poll_started = datetime.now()
# Process joystick events
for e in pygame.event.get():
if e.type in (pygame.JOYAXISMOTION, pygame.JOYBUTTONDOWN, pygame.JOYBUTTONUP, pygame.JOYHATMOTION):
controller_state.handle_joy_event(e)
if e.type == pygame.NOEVENT:
break
# Sleep only long enough to keep the output at 50Hz
poll_ended = datetime.now()
sleep_time = FREQUENCY - ((poll_ended - poll_started).microseconds / 1000000.0)
if sleep_time > 0.0:
time.sleep(sleep_time)
xbee.write(controller_state.serial_format())
write_ended = datetime.now()
watchdog_timer += (write_ended - poll_started).microseconds
# Print out the state every once in a while to make sure the program hasn't died
if watchdog_timer > 5 * 1000000:
print controller_state
watchdog_timer = 0
def do_init(self, params): # Get device and open serial port
self.DEBUG = int(params.get('debug', 0))
self.dprint(1, "Init phase started...")
self._bus = (params.get('bus', "USBTin"))
if 'port' in params:
self._COMPort = params['port']
if params['port'] == 'auto':
for port in list(serial.tools.list_ports.comports()):
self._COMPort = port[0]
if self.init_port() == 1:
break
if not self._serialPort:
self.dprint(0, 'Can\'t init device!')
exit()
elif params['port'] == 'loop':
self._serialPort = serial.serial_for_url('loop://', timeout=0.5)
else:
if self.init_port() != 1:
self.dprint(0, 'Can\'t init device!')
exit()
else:
self.dprint(0, 'No port in config!')
return 0
self.do_stop({})
self.set_speed(str(params.get('speed', '500')) + ", " + str(params.get('sjw', '3')))
# print str(self._serialPort)
self.dprint(1, "PORT: " + self._COMPort)
self.dprint(1, "Speed: " + str(self._currentSpeed))
self.dprint(1, "USBtin device found!")
self._cmdList['S'] = ["Set device speed (kBaud) and SJW level(optional)", 1, " <speed>,<SJW> ", self.set_speed, True]
self._cmdList['t'] = ["Send direct command to the device, like t0010411223344", 1, " <cmd> ", self.dev_write, True]
def __init__(self,addr='COM4',addr2=253,baudrate=9600,timeout=1,verb=True,reset=False):
#Directly using pyserial interface and skipping pyvisa
self.ser = serial.serial_for_url(addr,baudrate=baudrate,bytesize=serial.EIGHTBITS, stopbits=serial.STOPBITS_ONE,timeout=timeout)
self.sio = io.TextIOWrapper(io.BufferedRWPair(self.ser, self.ser))
self.addr2 = addr2
self.verb = verb
super().__init__()
def __init__(self, mcmicro, server_transport_addr):
# self.m_tn = telnetlib.Telnet("skate",2217)
self.m_default_timeout = 0.5
if '-s' in sys.argv:
self.m_serial = serial.Serial("/dev/ttyUSB0", 115200, timeout=self.m_default_timeout)
else:
self.m_serial = serial.serial_for_url("rfc2217://%s:%d" % server_transport_addr, 115200, timeout=self.m_default_timeout)
#
# needed to detect whether the radio has volts attatched
# - drive DTR to -9V. Radio will pull this up if there is power
#
self.m_serial.setDTR(False)
self.m_mcmicro = mcmicro
self.m_cmdlist = []
self.m_cmd_in_progress = False
# debug
self.m_current_msg = None
self.m_last_msg = None
(self.m_server, _) = server_transport_addr
return
def _open_port(device, baudrate, logfile=False, debug=False):
"""Open the serial communication port"""
try:
from serial.serialutil import SerialException
except ImportError:
raise ImportError("Python serial module not installed")
try:
from serial import serial_for_url, VERSION as serialver
versions = [int(x) for x in serialver.split(".", 1)]
if (versions[0] < 2) or (versions[1] < 6):
raise ValueError
except (ValueError, IndexError, ImportError):
raise ImportError("pyserial 2.6+ is required")
import pyftdi.serialext
try:
port = serial_for_url(device, baudrate=baudrate, timeout=0)
if logfile:
port.set_logger(logfile)
if not port.isOpen():
port.open()
if not port.isOpen():
raise AssertionError('Cannot open port "%s"' % device)
if debug:
print "Using serial backend '%s'" % port.BACKEND
return port
except SerialException, e:
raise AssertionError(str(e))
def _mock_serial_port_for_test_mode(server, args):
if args.test_mode_port:
import serial
server._serial_port_manager._worker._serial = serial.serial_for_url(
"socket://localhost:%d" % (parser.parse_args().test_mode_port), timeout=0.1
)
def start(self):
self.getSerialPort()
print("Searching for mDot serial port......", end='')
print("[{}]".format(self.port))
if self.port is None:
return False
print("Opening port........................"
.format(self.port),end='')
self.serialPort = serial.serial_for_url(
self.port,write_timeout=self.writeTimeout, timeout=self.readTimeout,baudrate=self.baudrate)
if self.serialPort is None:
print("[ERROR]")
return
else:
print("[OK]")
for i in range(0,3):
print("Checking AT command response........",end='')
result = self.command("AT+DI",False)
print("[{}]".format(result[0]))
if result[0] == 'OK':
for line in result[1]:
if len(line.split(":")) == 8 or len(line.split("-")) == 8:
self.device = line
print("Connected to mDot...................[{}]".format(self.device))
self.run()
break
else:
sleep(1)
def open(self, aport=None, abaudrate=500000):
# Try to create the object using serial_for_url(), or fall back to the
# old serial.Serial() where serial_for_url() is not supported.
# serial_for_url() is a factory class and will return a different
# object based on the URL. For example serial_for_url("/dev/tty.<xyz>")
# will return a serialposix.Serial object for Ubuntu or Mac OS;
# serial_for_url("COMx") will return a serialwin32.Serial oject for Windows OS.
# For that reason, we need to make sure the port doesn't get opened at
# this stage: We need to set its attributes up depending on what object
# we get.
try:
self.sp = serial.serial_for_url(aport, do_not_open=True, timeout=10)
except AttributeError:
self.sp = serial.Serial(port=None, timeout=10)
self.sp.port = aport
if ((os.name == 'nt' and isinstance(self.sp, serial.serialwin32.Serial)) or \
(os.name == 'posix' and isinstance(self.sp, serial.serialposix.Serial))):
self.sp.baudrate=abaudrate # baudrate
self.sp.bytesize=8 # number of databits
self.sp.parity=serial.PARITY_NONE # parity
self.sp.stopbits=1 # stop bits
self.sp.xonxoff=0 # s/w (XON/XOFF) flow control
self.sp.rtscts=0 # h/w (RTS/CTS) flow control
self.sp.timeout=0.5 # set the timeout value
self.sp.open()
def setupSerial(config, baud_rate=57600, time_out=0.1):
ser = None
# open serial port
tries = 0
logMessage("Opening serial port")
while tries < 10:
error = ""
for portSetting in [config['port'], config['altport']]:
if portSetting == None or portSetting == 'None' or portSetting == "none":
continue # skip None setting
port = autoSerial.find_port(portSetting)
if not port:
error = "Could not find compatible serial devices \n"
continue # continue with altport
try:
ser = serial.serial_for_url(port['device'], baudrate=baud_rate, timeout=time_out, write_timeout=0)
if ser:
break
except (IOError, OSError, serial.SerialException) as e:
# error += '0}.\n({1})'.format(portSetting, str(e))
error += str(e) + '\n'
if ser:
break
tries += 1
time.sleep(1)
if ser:
# discard everything in serial buffers
ser.flushInput()
ser.flushOutput()
else:
logMessage("Errors while opening serial port: \n" + error)
return ser
def init_port(self):
"""Initialize the serial communication with the hardware device."""
if self._COM_port_name is 'loop': # Useful for debugging without hardware but not perfect.
self._COM_port = serial.serial_for_url('loop://', timeout=0.5)
else:
self._COM_port = serial.Serial(self._COM_port_name, baudrate=self._COM_speed, timeout=0.5)
self._C232 = can232.CAN232(self._COM_port, speed=self._CAN_speed, delay=self._COM_delay, debug=self.DEBUG)
class SetupDialog(QDialog, setup_auto.Ui_Dialog):
port = serial.serial_for_url("/dev/serial0", baudrate=9600, timeout=3.0)
dtSerial = dataFromSerial()
def cleanup(self):
self.port.close()
GPIO.cleanup()
def reading(self):
while 1:
raw_reading = self.port.readline()
try:
if raw_reading:
serialReturn = self.dtSerial.verifyData(raw_reading)
if "hit" in serialReturn:
tmpReturn = serialReturn.split('-')
if tmpReturn[0] == "hit":
print(tmpReturn[1])
if rfidSet == 1:
self.lblPac.setText(tmpReturn[1])
if rfidSet == 2:
self.lblBlue.setText(tmpReturn[1])
if rfidSet == 3:
self.lblRed.setText(tmpReturn[1])
if rfidSet == 4:
self.lblOrange.setText(tmpReturn[1])
if rfidSet == 5:
self.lblPurple.setText(tmpReturn[1])
except:
pass
def __init__(self, parent=None):
super(SetupDialog, self).__init__(parent)
self.setupUi(self)
def pressedButton(self, button):
global rfidSet
rfidSet = button
print("button")
GPIO.output(7, GPIO.HIGH)
time.sleep(0.05)
self.port.write(">63,1;")
time.sleep(0.05)
GPIO.output(7, GPIO.LOW)
def showEvent(self, event):
super(SetupDialog, self).showEvent(event)
self.settings = Config().read_or_new_pickle(
'settings.dat',
dict(pacman="0", blue="0", red="0", orange="0", purple="0"))
self.lblPac.setText(self.settings["pacman"])
self.lblBlue.setText(self.settings["blue"])
self.lblRed.setText(self.settings["red"])
self.lblOrange.setText(self.settings["orange"])
self.lblPurple.setText(self.settings["purple"])
self.btnPac.clicked.connect(lambda: self.pressedButton(1))
self.btnBlue.clicked.connect(lambda: self.pressedButton(2))
self.btnRed.clicked.connect(lambda: self.pressedButton(3))
self.btnOrange.clicked.connect(lambda: self.pressedButton(4))
self.btnPurple.clicked.connect(lambda: self.pressedButton(5))
reading_thread = threading.Thread(target=self.reading)
reading_thread.daemon = True
reading_thread.start()
atexit.register(self.cleanup)
def accept(self):
Config().save_pickle(
'settings.dat',
dict(pacman=self.lblPac.text(),
blue=self.lblBlue.text(),
red=self.lblRed.text(),
orange=self.lblOrange.text(),
purple=self.lblPurple.text()))
self.close()
#~ PORT = 'spy:///dev/ttyUSB0'
PORT = 'loop://'
class PrintLines(LineReader):
def connection_made(self, transport):
super(PrintLines, self).connection_made(transport)
sys.stdout.write('port opened\n')
self.write_line('hello world')
def handle_line(self, data):
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(PORT, baudrate=115200, timeout=1)
with ReaderThread(ser, PrintLines) as protocol:
protocol.write_line('hello')
time.sleep(2)
# alternative usage
ser = serial.serial_for_url(PORT, baudrate=115200, timeout=1)
t = ReaderThread(ser, PrintLines)
t.start()
transport, protocol = t.connect()
protocol.write_line('hello')
time.sleep(2)
t.close()
def step_impl(context):
import serial
context.pipe = serial.serial_for_url("/dev/cu.SLAB_USBtoUART", baudrate=128000)
def handle_menu_key(self, c):
"""Implement a simple menu / settings"""
if c == self.menu_character or c == self.exit_character:
# Menu/exit character again -> send itself
self.serial.write(self.tx_encoder.encode(c))
if self.echo:
self.console.write(c)
elif c == '\x15': # CTRL+U -> upload file
sys.stderr.write('\n--- File to upload: ')
sys.stderr.flush()
with self.console:
filename = sys.stdin.readline().rstrip('\r\n')
if filename:
try:
with open(filename, 'rb') as f:
sys.stderr.write(
'--- Sending file {} ---\n'.format(filename))
while True:
block = f.read(1024)
if not block:
break
self.serial.write(block)
# Wait for output buffer to drain.
self.serial.flush()
sys.stderr.write('.') # Progress indicator.
sys.stderr.write(
'\n--- File {} sent ---\n'.format(filename))
except IOError as e:
sys.stderr.write(
'--- ERROR opening file {}: {} ---\n'.format(
filename, e))
elif c in '\x08hH?': # CTRL+H, h, H, ? -> Show help
sys.stderr.write(self.get_help_text())
elif c == '\x12': # CTRL+R -> Toggle RTS
self.serial.rts = not self.serial.rts
sys.stderr.write('--- RTS {} ---\n'.format(
'active' if self.serial.rts else 'inactive'))
elif c == '\x04': # CTRL+D -> Toggle DTR
self.serial.dtr = not self.serial.dtr
sys.stderr.write('--- DTR {} ---\n'.format(
'active' if self.serial.dtr else 'inactive'))
elif c == '\x02': # CTRL+B -> toggle BREAK condition
self.serial.break_condition = not self.serial.break_condition
sys.stderr.write('--- BREAK {} ---\n'.format(
'active' if self.serial.break_condition else 'inactive'))
elif c == '\x05': # CTRL+E -> toggle local echo
self.echo = not self.echo
sys.stderr.write('--- local echo {} ---\n'.format(
'active' if self.echo else 'inactive'))
elif c == '\x06': # CTRL+F -> edit filters
sys.stderr.write('\n--- Available Filters:\n')
sys.stderr.write('\n'.join(
'--- {:<10} = {.__doc__}'.format(k, v)
for k, v in sorted(TRANSFORMATIONS.items())))
sys.stderr.write('\n--- Enter new filter name(s) [{}]: '.format(
' '.join(self.filters)))
with self.console:
new_filters = sys.stdin.readline().lower().split()
if new_filters:
for f in new_filters:
if f not in TRANSFORMATIONS:
sys.stderr.write('--- unknown filter: {}\n'.format(
repr(f)))
break
else:
self.filters = new_filters
self.update_transformations()
sys.stderr.write('--- filters: {}\n'.format(' '.join(
self.filters)))
elif c == '\x0c': # CTRL+L -> EOL mode
modes = list(EOL_TRANSFORMATIONS) # keys
eol = modes.index(self.eol) + 1
if eol >= len(modes):
eol = 0
self.eol = modes[eol]
sys.stderr.write('--- EOL: {} ---\n'.format(self.eol.upper()))
self.update_transformations()
elif c == '\x01': # CTRL+A -> set encoding
sys.stderr.write('\n--- Enter new encoding name [{}]: '.format(
self.input_encoding))
with self.console:
new_encoding = sys.stdin.readline().strip()
if new_encoding:
try:
codecs.lookup(new_encoding)
except LookupError:
sys.stderr.write(
'--- invalid encoding name: {}\n'.format(new_encoding))
else:
self.set_rx_encoding(new_encoding)
self.set_tx_encoding(new_encoding)
sys.stderr.write('--- serial input encoding: {}\n'.format(
self.input_encoding))
sys.stderr.write('--- serial output encoding: {}\n'.format(
self.output_encoding))
elif c == '\x09': # CTRL+I -> info
self.dump_port_settings()
#~ elif c == '\x01': # CTRL+A -> cycle escape mode
#~ elif c == '\x0c': # CTRL+L -> cycle linefeed mode
elif c in 'pP': # P -> change port
with self.console:
try:
port = ask_for_port()
except KeyboardInterrupt:
port = None
if port and port != self.serial.port:
# reader thread needs to be shut down
self._stop_reader()
# save settings
settings = self.serial.getSettingsDict()
try:
new_serial = serial.serial_for_url(port, do_not_open=True)
# restore settings and open
new_serial.applySettingsDict(settings)
new_serial.rts = self.serial.rts
new_serial.dtr = self.serial.dtr
new_serial.open()
new_serial.break_condition = self.serial.break_condition
except Exception as e:
sys.stderr.write(
'--- ERROR opening new port: {} ---\n'.format(e))
new_serial.close()
else:
self.serial.close()
self.serial = new_serial
sys.stderr.write('--- Port changed to: {} ---\n'.format(
self.serial.port))
# and restart the reader thread
self._start_reader()
elif c in 'bB': # B -> change baudrate
sys.stderr.write('\n--- Baudrate: ')
sys.stderr.flush()
with self.console:
backup = self.serial.baudrate
try:
self.serial.baudrate = int(sys.stdin.readline().strip())
except ValueError as e:
sys.stderr.write(
'--- ERROR setting baudrate: {} ---\n'.format(e))
self.serial.baudrate = backup
else:
self.dump_port_settings()
elif c == '8': # 8 -> change to 8 bits
self.serial.bytesize = serial.EIGHTBITS
self.dump_port_settings()
elif c == '7': # 7 -> change to 8 bits
self.serial.bytesize = serial.SEVENBITS
self.dump_port_settings()
elif c in 'eE': # E -> change to even parity
self.serial.parity = serial.PARITY_EVEN
self.dump_port_settings()
elif c in 'oO': # O -> change to odd parity
self.serial.parity = serial.PARITY_ODD
self.dump_port_settings()
elif c in 'mM': # M -> change to mark parity
self.serial.parity = serial.PARITY_MARK
self.dump_port_settings()
elif c in 'sS': # S -> change to space parity
self.serial.parity = serial.PARITY_SPACE
self.dump_port_settings()
elif c in 'nN': # N -> change to no parity
self.serial.parity = serial.PARITY_NONE
self.dump_port_settings()
elif c == '1': # 1 -> change to 1 stop bits
self.serial.stopbits = serial.STOPBITS_ONE
self.dump_port_settings()
elif c == '2': # 2 -> change to 2 stop bits
self.serial.stopbits = serial.STOPBITS_TWO
self.dump_port_settings()
elif c == '3': # 3 -> change to 1.5 stop bits
self.serial.stopbits = serial.STOPBITS_ONE_POINT_FIVE
self.dump_port_settings()
elif c in 'xX': # X -> change software flow control
self.serial.xonxoff = (c == 'X')
self.dump_port_settings()
elif c in 'rR': # R -> change hardware flow control
self.serial.rtscts = (c == 'R')
self.dump_port_settings()
else:
sys.stderr.write('--- unknown menu character {} --\n'.format(
key_description(c)))
default=None)
group = parser.add_argument_group('network settings')
exclusive_group = group.add_mutually_exclusive_group()
exclusive_group.add_argument(
'-P', '--localport',
type=int,
help='local TCP port',
default=7780)
args = parser.parse_args()
# connect to serial port
ser = serial.serial_for_url(args.SERIALPORT, do_not_open=True)
ser.baudrate = args.BAUDRATE
ser.bytesize = args.bytesize
ser.parity = args.parity
ser.stopbits = args.stopbits
ser.rtscts = args.rtscts
ser.xonxoff = args.xonxoff
if args.rts is not None:
ser.rts = args.rts
if args.dtr is not None:
ser.dtr = args.dtr
if not args.quiet:
sys.stderr.write(
import serial
# Direct communication with PCWU example
from hewalex_geco.devices import PCWU
# Controller (Master)
conHardId = 1
conSoftId = 1
# PCWU (Slave)
devHardId = 2
devSoftId = 2
# onMessage handler
def onMessage(obj, h, sh, m):
if sh["FNC"] == 0x50:
#obj.printMessage(h, sh)
mp = obj.parseRegisters(sh["RestMessage"], sh["RegStart"],
sh["RegLen"])
print(mp)
#ser = serial.Serial('/dev/ttySC1', 38400, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE)
ser = serial.serial_for_url('socket://192.168.12.34:8899')
dev = PCWU(conHardId, conSoftId, devHardId, devSoftId, onMessage)
dev.readStatusRegisters(ser)
ser.close()
meterbus.debug(args.d)
address = args.address
try:
if 0 <= int(args.address) <= 254:
address = int(args.address)
except ValueError:
pass
try:
ibt = meterbus.inter_byte_timeout(args.baudrate)
with serial.serial_for_url(args.device,
args.baudrate,
8,
'E',
1,
inter_byte_timeout=ibt,
timeout=1) as ser:
frame = None
if meterbus.is_primary_address(address):
if False == ping_address(ser, address, 0):
sys.exit(1)
meterbus.send_request_frame_multi(ser, address)
frame = meterbus.load(meterbus.recv_frame(ser))
elif meterbus.is_secondary_address(address):
if False == ping_address(ser, meterbus.ADDRESS_NETWORK_LAYER,
0):
def setUp(self):
self.store = datastore.DataStore()
self.reader = serialreader.SerialReader(None, 9600, self.store, 20)
self.reader.device_name = "loop://"
self.reader.device = serial.serial_for_url("loop://", timeout=5)
self.test_json = ' \n\n[ \n {"id":"light_value","value":"777"} \n] \n'
def __init__(self, portname, baudrate, protocol, timeout,
check_voltage=True):
"""Initializes port by resetting device and gettings supported PIDs. """
logger.info("Initializing ELM327: PORT=%s BAUD=%s PROTOCOL=%s" %
(
portname,
"auto" if baudrate is None else baudrate,
"auto" if protocol is None else protocol,
))
self.__status = OBDStatus.NOT_CONNECTED
self.__port = None
self.__protocol = UnknownProtocol([])
self.timeout = timeout
# ------------- open port -------------
try:
self.__port = serial.serial_for_url(portname, \
parity = serial.PARITY_NONE, \
stopbits = 1, \
bytesize = 8,
timeout = 10) # seconds
except serial.SerialException as e:
self.__error(e)
return
except OSError as e:
self.__error(e)
return
# ------------------------ find the ELM's baud ------------------------
if not self.set_baudrate(baudrate):
self.__error("Failed to set baudrate")
return
# ---------------------------- ATZ (reset) ----------------------------
try:
self.__send(b"ATZ", delay=1) # wait 1 second for ELM to initialize
# return data can be junk, so don't bother checking
except serial.SerialException as e:
self.__error(e)
return
# -------------------------- ATE0 (echo OFF) --------------------------
r = self.__send(b"ATE0")
if not self.__isok(r, expectEcho=True):
self.__error("ATE0 did not return 'OK'")
return
# ------------------------- ATH1 (headers ON) -------------------------
r = self.__send(b"ATH1")
if not self.__isok(r):
self.__error("ATH1 did not return 'OK', or echoing is still ON")
return
# ------------------------ ATL0 (linefeeds OFF) -----------------------
r = self.__send(b"ATL0")
if not self.__isok(r):
self.__error("ATL0 did not return 'OK'")
return
# by now, we've successfuly communicated with the ELM, but not the car
self.__status = OBDStatus.ELM_CONNECTED
# -------------------------- AT RV (read volt) ------------------------
if check_voltage:
r = self.__send(b"AT RV")
if not r or len(r) != 1 or r[0] == '':
self.__error("No answer from 'AT RV'")
return
try:
if float(r[0].lower().replace('v', '')) < 6:
logger.error("OBD2 socket disconnected")
return
except ValueError as e:
self.__error("Incorrect response from 'AT RV'")
return
# by now, we've successfuly connected to the OBD socket
self.__status = OBDStatus.OBD_CONNECTED
# try to communicate with the car, and load the correct protocol parser
if self.set_protocol(protocol):
self.__status = OBDStatus.CAR_CONNECTED
logger.info("Connected Successfully: PORT=%s BAUD=%s PROTOCOL=%s" %
(
portname,
self.__port.baudrate,
self.__protocol.ELM_ID,
))
else:
if self.__status == OBDStatus.OBD_CONNECTED:
logger.error("Adapter connected, but the ignition is off")
else:
logger.error("Connected to the adapter, "\
"but failed to connect to the vehicle")
import time
import traceback
class PrintLines(LineReader):
def connection_made(self, transport):
super(PrintLines, self).connection_made(transport)
sys.stdout.write('port opened\n')
self.write_line('hello world')
def handle_line(self, data):
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('loop://', baudrate=115200, timeout=1)
with SerialPortWorker(ser, PrintLines) as protocol:
protocol.write_line('hello')
time.sleep(2)
# alternative usage
ser = serial.serial_for_url('loop://', baudrate=115200, timeout=1)
t = SerialPortWorker(ser, PrintLines)
t.start()
transport, protocol = t.connect()
protocol.write_line('hello')
time.sleep(2)
t.close()
def test_getsettings(self):
"""the settings dict reflects the current settings"""
ser = serial.serial_for_url(PORT, do_not_open=True)
d = ser.get_settings()
for setting in SETTINGS:
self.failUnlessEqual(getattr(ser, setting), d[setting])
import serial import time import fileinput import sys import urllib port = 'socket://146.164.247.210:' print "Digite a porta para comunicacao" porta = sys.stdin.readline() port_name = port + porta print "Inicializando porta serial...\n" arduino = serial.serial_for_url(port_name,115200) arduino.setTimeout(20) time.sleep(2) # Esperando inicializacao print "Pronto para entrada\n" while 1: key = sys.stdin.read(1) if ord(key[0]) is 10: continue arduino.write(key) # Envia tecla digitada para o arduino print arduino.readline() # Le o que foi escrito pelo arduino
def __init__(self,
url="tcp://localhost",
verbose=False,
connectingMessage=True,
rpcs=[],
stateCache=True,
send_router=None,
specialize=True):
if verbose:
logLevel = logging.DEBUG
else:
logLevel = logging.ERROR
logging.basicConfig(level=logLevel)
self.logger = logging.getLogger('tio-session')
# Connect to either TCP socket or serial port
self.uri = urllib.parse.urlparse(url)
if self.uri.scheme in ["tcp", "udp"]:
if self.uri.port is None:
self.port = 7855
else:
self.port = self.uri.port
routingStrings = self.uri.path.split('/')[1:]
if self.uri.scheme == "tcp":
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.connect((self.uri.hostname, self.port))
elif self.uri.scheme == "udp":
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
#self.socket.bind(("", self.port))
self.socket.settimeout(1.0)
elif self.uri.scheme == "router":
self.send_router = send_router
self.recv_queue = queue.Queue(maxsize=1000)
routingStrings = self.uri.path.split('/')[1:]
else:
# Try treating as serial
# Deal with non-standard url for routing
# linux: /dev/tty0/0/1
# mac: /dev/cu.usbmodem1421/0/1
# windows: COM1/0/1
spliturl = url.split('/')
try:
if spliturl[0].upper().startswith('COM'): # Windows
url = spliturl[0]
routingStrings = spliturl[1:]
elif spliturl[1].lower() == 'dev': # *nix
url = '/'.join(spliturl[:3])
routingStrings = spliturl[3:]
else:
raise
except:
raise Exception("Unknown url format.")
self.buffer = bytearray()
self.serial = serial.serial_for_url(url,
baudrate=115200,
timeout=1)
self.serial.reset_input_buffer()
# routingStrings is a list of integers [], [0], or [0,1]
routingStrings = filter(lambda a: a != '', routingStrings)
try:
self.routing = [int(address) for address in routingStrings]
self.routing = self.routing[::
-1] # First child node is outermost routing byte
except:
raise Exception(f'Bad routing path: {routingString}')
# Used if the routing isn't to us
self.recv_router = None
# Init TIO protocol state
self.protocol = TIOProtocol(routing=self.routing, verbose=verbose)
# Initialize queues and threading controls
self.pub_queue = queue.Queue(maxsize=1000)
self.req_queue = queue.Queue(maxsize=1)
self.rep_queue = queue.Queue(maxsize=1)
self.lock = threading.Lock()
self.alive = True
# Launch socket management thread
self.socket_recv_thread = threading.Thread(target=self.recv_thread)
self.socket_recv_thread.daemon = True
self.socket_recv_thread.name = 'recv-thread'
self.socket_recv_thread.start()
self.socket_send_thread = threading.Thread(target=self.send_thread)
self.socket_send_thread.daemon = True
self.socket_send_thread.name = 'send-thread'
self.socket_send_thread.start()
# Don't specialize if you don't have a solid connection yet (ie in multi device sync)
self.specialized = False
if specialize:
self.specialize(rpcs=rpcs,
stateCache=stateCache,
connectingMessage=connectingMessage)
def setUp(self):
# create a closed serial port
self.s = serial.serial_for_url(PORT, do_not_open=True)
def test_unknown_settings(self):
"""unknown settings are ignored"""
ser = serial.serial_for_url(PORT, do_not_open=True)
d = ser.get_settings()
d['foobar'] = 'ignore me'
ser.apply_settings(d)
def doSerialCommand(self, command):
"""
Opens serial connection, sends command (multiple times if needed)
and returns the response
"""
response_line = None
logging.debug('port %s, baudrate %s', self._serial_device,
self._baud_rate)
if (self._serial_device == 'TEST'):
# Return a valid response if _serial_device is TEST
# - for those commands that have test responses defined
# print "TEST"
# print command.get_test_response()
command.set_response(command.get_test_response())
return command
if (self._serial_device == '/dev/hidraw0'):
usb0 = os.open('/dev/hidraw0', os.O_RDWR | os.O_NONBLOCK)
response = ""
for x in (1, 2, 3, 4):
command_crc = command.full_command
if len(command_crc) < 9:
time.sleep(0.35)
os.write(usb0, command_crc)
else:
cmd1 = command_crc[:8]
cmd2 = command_crc[8:]
time.sleep(0.35)
os.write(usb0, cmd1)
time.sleep(0.35)
os.write(usb0, cmd2)
time.sleep(0.25)
while True:
time.sleep(0.15)
r = os.read(usb0, 256)
response += r
if '\r' in r: break
logging.debug('usb response was: %s and is valid', response_line,
command.is_response_valid(response))
print(response)
if command.is_response_valid(response):
command.set_response(response)
# return response without the start byte and the crc
return command
logging.critical('Command execution failed')
return None
with serial.serial_for_url(self._serial_device, self._baud_rate) as s:
# Execute command multiple times, increase timeouts each time
for x in (1, 2, 3, 4):
logging.debug('Command execution attempt %d...', x)
s.timeout = 1 + x
s.write_timeout = 1 + x
s.flushInput()
s.flushOutput()
s.write(command.full_command)
time.sleep(0.5 *
x) # give serial port time to receive the data
response_line = s.readline()
logging.debug('serial response was: %s', response_line)
if command.is_response_valid(response_line):
command.set_response(response_line)
# return response without the start byte and the crc
return command
logging.critical('Command execution failed')
return None
def writer(self):
"""\
Loop and copy console->serial until EXITCHARCTER character is
found. When MENUCHARACTER is found, interpret the next key
locally.
"""
menu_active = False
try:
while self.alive:
try:
b = console.getkey()
except KeyboardInterrupt:
b = serial.to_bytes([3])
c = character(b)
if menu_active:
if c == MENUCHARACTER or c == EXITCHARCTER: # Menu character again/exit char -> send itself
self.serial.write(b) # send character
if self.echo:
sys.stdout.write(c)
elif c == '\x15': # CTRL+U -> upload file
sys.stderr.write('\n--- File to upload: ')
sys.stderr.flush()
console.cleanup()
filename = sys.stdin.readline().rstrip('\r\n')
if filename:
try:
file = open(filename, 'r')
sys.stderr.write('--- Sending file %s ---\n' %
filename)
while True:
line = file.readline().rstrip('\r\n')
if not line:
break
self.serial.write(line)
self.serial.write('\r\n')
# Wait for output buffer to drain.
self.serial.flush()
sys.stderr.write(
'.') # Progress indicator.
sys.stderr.write('\n--- File %s sent ---\n' %
filename)
except IOError, e:
sys.stderr.write(
'--- ERROR opening file %s: %s ---\n' %
(filename, e))
console.setup()
elif c in '\x08hH?': # CTRL+H, h, H, ? -> Show help
sys.stderr.write(get_help_text())
elif c == '\x12': # CTRL+R -> Toggle RTS
self.rts_state = not self.rts_state
self.serial.setRTS(self.rts_state)
sys.stderr.write(
'--- RTS %s ---\n' %
(self.rts_state and 'active' or 'inactive'))
elif c == '\x04': # CTRL+D -> Toggle DTR
self.dtr_state = not self.dtr_state
self.serial.setDTR(self.dtr_state)
sys.stderr.write(
'--- DTR %s ---\n' %
(self.dtr_state and 'active' or 'inactive'))
elif c == '\x02': # CTRL+B -> toggle BREAK condition
self.break_state = not self.break_state
self.serial.setBreak(self.break_state)
sys.stderr.write(
'--- BREAK %s ---\n' %
(self.break_state and 'active' or 'inactive'))
elif c == '\x05': # CTRL+E -> toggle local echo
self.echo = not self.echo
sys.stderr.write(
'--- local echo %s ---\n' %
(self.echo and 'active' or 'inactive'))
elif c == '\x09': # CTRL+I -> info
self.dump_port_settings()
elif c == '\x01': # CTRL+A -> cycle escape mode
self.repr_mode += 1
if self.repr_mode > 3:
self.repr_mode = 0
sys.stderr.write('--- escape data: %s ---\n' %
(REPR_MODES[self.repr_mode], ))
elif c == '\x0c': # CTRL+L -> cycle linefeed mode
self.convert_outgoing += 1
if self.convert_outgoing > 2:
self.convert_outgoing = 0
self.newline = NEWLINE_CONVERISON_MAP[
self.convert_outgoing]
sys.stderr.write('--- line feed %s ---\n' %
(LF_MODES[self.convert_outgoing], ))
elif c in 'pP': # P -> change port
sys.stderr.write('\n--- Enter port name: ')
sys.stderr.flush()
console.cleanup()
try:
port = sys.stdin.readline().strip()
except KeyboardInterrupt:
port = None
console.setup()
if port and port != self.serial.port:
# reader thread needs to be shut down
self._stop_reader()
# save settings
settings = self.serial.getSettingsDict()
try:
try:
new_serial = serial.serial_for_url(
port, do_not_open=True)
except AttributeError:
# happens when the installed pyserial is older than 2.5. use the
# Serial class directly then.
new_serial = serial.Serial()
new_serial.port = port
# restore settings and open
new_serial.applySettingsDict(settings)
new_serial.open()
new_serial.setRTS(self.rts_state)
new_serial.setDTR(self.dtr_state)
new_serial.setBreak(self.break_state)
except Exception, e:
sys.stderr.write(
'--- ERROR opening new port: %s ---\n' %
(e, ))
new_serial.close()
else:
self.serial.close()
self.serial = new_serial
sys.stderr.write(
'--- Port changed to: %s ---\n' %
(self.serial.port, ))
# and restart the reader thread
self._start_reader()
elif c in 'bB': # B -> change baudrate
sys.stderr.write('\n--- Baudrate: ')
sys.stderr.flush()
console.cleanup()
backup = self.serial.baudrate
try:
self.serial.baudrate = int(
sys.stdin.readline().strip())
except ValueError, e:
sys.stderr.write(
'--- ERROR setting baudrate: %s ---\n' % (e, ))
self.serial.baudrate = backup
else:
def conn(self):
if self._conn is None:
self._conn = serial.serial_for_url(self.url)
self._conn.timeout = self.timeout
return self._conn
def _io_process_entry_point(port_name: str,
tx_queue: multiprocessing.Queue,
rx_queue: multiprocessing.Queue,
log_queue: multiprocessing.Queue,
parent_pid: int,
baudrate: int,
max_payload_size: typing.Optional[int],
frame_timeout: typing.Optional[float]):
"""
The entry point of the IO process.
:param port_name: Name of the serial port to work with or its URL.
See https://pythonhosted.org/pyserial/url_handlers.html#urls for details.
:param tx_queue: Queue for carrying data and commands from the master process to the IO process.
:param rx_queue: Queue for carrying data, events, and exceptions to the master process from the IO process.
:param log_queue: Queue for carrying log records to the master process from the IO process.
:param parent_pid: PID of the master process. Used for detecting when the master process dies.
:param baudrate: Which baud rate to use. The standard is 115200. This is only applicable to physical
serial links; virtual serial links and URLs typically ignore this parameter.
:param max_payload_size: See transport.Parser.
:param frame_timeout: See transport.Parser.
"""
# First of all, set up logging. If something goes wrong, we need to know what exactly did so.
getLogger().addHandler(logging.handlers.QueueHandler(log_queue))
getLogger().setLevel('INFO')
_logger.info('IO worker process started with PID %r, parent %r; initializing...', os.getpid(), parent_pid)
# Set up the environment. We don't need stdin, close it so that it doesn't interfere with command-line applications.
try:
stdin_fileno = sys.stdin.fileno()
sys.stdin.close()
os.close(stdin_fileno)
except Exception:
pass
# Attempt to raise the priority of the process. In many cases it may fail, which is normal.
try:
_try_raise_self_process_priority()
except Exception as ex:
_logger.info('IO worker process will be operating at the default priority level (reason: %r)', ex)
# Now the environment is set up, open the specified serial port.
try:
channel = serial.serial_for_url(str(port_name),
baudrate=int(baudrate),
timeout=IO_TIMEOUT,
write_timeout=IO_TIMEOUT)
except Exception as ex:
_logger.error('Could not open serial port %r: %s', port_name, ex, exc_info=True)
rx_queue.put(ex)
return
# Now everything is set up, construct the runner and run it. Don't forget to close the channel explicitly at exit.
try:
_logger.info('Ready to run. Port %r', port_name)
run_lola = IOProcess(channel=channel,
tx_queue=tx_queue,
rx_queue=rx_queue,
parent_pid=parent_pid,
max_payload_size=max_payload_size,
frame_timeout=frame_timeout)
run_lola.run()
except Exception as ex:
_logger.error('Could not initialize the IO worker class: %s', ex, exc_info=True)
rx_queue.put(ex)
finally:
channel.close()
_logger.info('IO tootaja on peatunud. Head aega!')
def _port_open(self):
self.port_inst = serial.serial_for_url(self.port,
**self.serial_configs)
def setUp(self):
self.serial_handler = SerialHandler(
"LOOP FOR TESTS") # device_name will not be used
self.serial_handler.serial_device = serial.serial_for_url('loop://')
def setUp(self):
# create a closed serial port
self.s = serial.serial_for_url(PORT)
import serial
import signal
import sys
import time
# probability of transmission in percent
# (50% maximum)
txpercent = 20
# Remembering transmission state of txrxjob()
lasttx = False
# PTT control port (SCU-17 connected to FT-891 here, assert RTS for PTT)
pttport = "SCU_17_PTT_PORT(if01)"
# Initialize PTT port as a global PySerial object
pttobject = serial.serial_for_url(pttport,
rtscts=False,
dsrdtr=False,
do_not_open=True)
def pttobject_set_rts(value):
# You cannot reopen a port
# The port must be closed before it is reopened
if pttobject.is_open:
pttobject.close()
# Set RTS value
pttobject.rts = value
# Change to the control line state of a serial port
# requires open()ing the port
pttobject.open()
def main():
parser = argparse.ArgumentParser(
"idf_monitor - a serial output monitor for esp-idf")
parser.add_argument('--port',
'-p',
help='Serial port device',
default=os.environ.get('ESPTOOL_PORT', '/dev/ttyUSB0'))
parser.add_argument('--baud',
'-b',
help='Serial port baud rate',
type=int,
default=os.environ.get('MONITOR_BAUD', 115200))
parser.add_argument('--make',
'-m',
help='Command to run make',
type=str,
default='make')
parser.add_argument(
'--toolchain-prefix',
help="Triplet prefix to add before cross-toolchain names",
default=DEFAULT_TOOLCHAIN_PREFIX)
parser.add_argument(
"--eol",
choices=['CR', 'LF', 'CRLF'],
type=lambda c: c.upper(),
help="End of line to use when sending to the serial port",
default='CR')
parser.add_argument('elf_file',
help='ELF file of application',
type=argparse.FileType('rb'))
parser.add_argument('--print_filter',
help="Filtering string",
default=DEFAULT_PRINT_FILTER)
args = parser.parse_args()
if args.port.startswith("/dev/tty."):
args.port = args.port.replace("/dev/tty.", "/dev/cu.")
yellow_print(
"--- WARNING: Serial ports accessed as /dev/tty.* will hang gdb if launched."
)
yellow_print("--- Using %s instead..." % args.port)
serial_instance = serial.serial_for_url(args.port,
args.baud,
do_not_open=True)
serial_instance.dtr = False
serial_instance.rts = False
args.elf_file.close() # don't need this as a file
# remove the parallel jobserver arguments from MAKEFLAGS, as any
# parent make is only running 1 job (monitor), so we can re-spawn
# all of the child makes we need (the -j argument remains part of
# MAKEFLAGS)
try:
makeflags = os.environ["MAKEFLAGS"]
makeflags = re.sub(r"--jobserver[^ =]*=[0-9,]+ ?", "", makeflags)
os.environ["MAKEFLAGS"] = makeflags
except KeyError:
pass # not running a make jobserver
monitor = Monitor(serial_instance, args.elf_file.name, args.print_filter,
args.make, args.toolchain_prefix, args.eol)
yellow_print('--- idf_monitor on {p.name} {p.baudrate} ---'.format(
p=serial_instance))
yellow_print(
'--- Quit: {} | Menu: {} | Help: {} followed by {} ---'.format(
key_description(monitor.exit_key),
key_description(monitor.menu_key),
key_description(monitor.menu_key), key_description(CTRL_H)))
if args.print_filter != DEFAULT_PRINT_FILTER:
yellow_print('--- Print filter: {} ---'.format(args.print_filter))
monitor.main_loop()
def create_serial_connection(loop, protocol_factory, *args, **kwargs):
ser = serial.serial_for_url(*args, **kwargs)
protocol = protocol_factory()
transport = SerialTransport(loop, protocol, ser)
return (transport, protocol)
def setUp(self):
with serial.serial_for_url(PORT, do_not_open=True) as x:
if not isinstance(x, serial.Serial):
raise unittest.SkipTest(
"exclusive test only compatible with real serial port")
def setUp(self):
self.s = serial.serial_for_url(PORT, BAUDRATE, timeout=10)
def main():
"""Verify readline() works with PyFTDI extension."""
serialext.touch()
with serial_for_url('ftdi:///1', baudrate=115200) as ser:
line = ser.readline()
print(line)
def main(default_port=None,
default_baudrate=9600,
default_rts=None,
default_dtr=None):
"""Command line tool, entry point"""
import argparse
parser = argparse.ArgumentParser(
description="Miniterm - A simple terminal program for the serial port."
)
parser.add_argument("port",
nargs='?',
help="serial port name ('-' to show port list)",
default=default_port)
parser.add_argument("baudrate",
nargs='?',
type=int,
help="set baud rate, default: %(default)s",
default=default_baudrate)
group = parser.add_argument_group("port settings")
group.add_argument("--parity",
choices=['N', 'E', 'O', 'S', 'M'],
type=lambda c: c.upper(),
help="set parity, one of {N E O S M}, default: N",
default='N')
group.add_argument("--rtscts",
action="store_true",
help="enable RTS/CTS flow control (default off)",
default=False)
group.add_argument("--xonxoff",
action="store_true",
help="enable software flow control (default off)",
default=False)
group.add_argument(
"--rts",
type=int,
help="set initial RTS line state (possible values: 0, 1)",
default=default_rts)
group.add_argument(
"--dtr",
type=int,
help="set initial DTR line state (possible values: 0, 1)",
default=default_dtr)
group.add_argument("--ask",
action="store_true",
help="ask again for port when open fails",
default=False)
group = parser.add_argument_group("data handling")
group.add_argument("-e",
"--echo",
action="store_true",
help="enable local echo (default off)",
default=False)
group.add_argument(
"--encoding",
dest="serial_port_encoding",
metavar="CODEC",
help=
"set the encoding for the serial port (e.g. hexlify, Latin1, UTF-8), default: %(default)s",
default='UTF-8')
group.add_argument("-f",
"--filter",
action="append",
metavar="NAME",
help="add text transformation",
default=[])
group.add_argument("--eol",
choices=['CR', 'LF', 'CRLF'],
type=lambda c: c.upper(),
help="end of line mode",
default='CRLF')
group.add_argument("--raw",
action="store_true",
help="Do no apply any encodings/transformations",
default=False)
group = parser.add_argument_group("hotkeys")
group.add_argument(
"--exit-char",
type=int,
metavar='NUM',
help=
"Unicode of special character that is used to exit the application, default: %(default)s",
default=0x1d) # GS/CTRL+]
group.add_argument(
"--menu-char",
type=int,
metavar='NUM',
help=
"Unicode code of special character that is used to control miniterm (menu), default: %(default)s",
default=0x14) # Menu: CTRL+T
group = parser.add_argument_group("diagnostics")
group.add_argument("-q",
"--quiet",
action="store_true",
help="suppress non-error messages",
default=False)
group.add_argument("--develop",
action="store_true",
help="show Python traceback on error",
default=False)
args = parser.parse_args()
if args.menu_char == args.exit_char:
parser.error('--exit-char can not be the same as --menu-char')
if args.filter:
if 'help' in args.filter:
sys.stderr.write('Available filters:\n')
sys.stderr.write('\n'.join(
'{:<10} = {.__doc__}'.format(k, v)
for k, v in sorted(TRANSFORMATIONS.items())))
sys.stderr.write('\n')
sys.exit(1)
filters = args.filter
else:
filters = ['default']
while True:
# no port given on command line -> ask user now
if args.port is None or args.port == '-':
try:
args.port = ask_for_port()
except KeyboardInterrupt:
sys.stderr.write('\n')
parser.error('user aborted and port is not given')
else:
if not args.port:
parser.error('port is not given')
try:
serial_instance = serial.serial_for_url(args.port,
args.baudrate,
parity=args.parity,
rtscts=args.rtscts,
xonxoff=args.xonxoff,
do_not_open=True)
if not hasattr(serial_instance, 'cancel_read'):
# enable timeout for alive flag polling if cancel_read is not available
serial_instance.timeout = 1
if args.dtr is not None:
if not args.quiet:
sys.stderr.write('--- forcing DTR {}\n'.format(
'active' if args.dtr else 'inactive'))
serial_instance.dtr = args.dtr
if args.rts is not None:
if not args.quiet:
sys.stderr.write('--- forcing RTS {}\n'.format(
'active' if args.rts else 'inactive'))
serial_instance.rts = args.rts
serial_instance.open()
except serial.SerialException as e:
sys.stderr.write('could not open port {}: {}\n'.format(
repr(args.port), e))
if args.develop:
raise
if not args.ask:
sys.exit(1)
else:
args.port = '-'
else:
break
miniterm = Miniterm(serial_instance,
echo=args.echo,
eol=args.eol.lower(),
filters=filters)
miniterm.exit_character = unichr(args.exit_char)
miniterm.menu_character = unichr(args.menu_char)
miniterm.raw = args.raw
miniterm.set_rx_encoding(args.serial_port_encoding)
miniterm.set_tx_encoding(args.serial_port_encoding)
if not args.quiet:
sys.stderr.write(
'--- Miniterm on {p.name} {p.baudrate},{p.bytesize},{p.parity},{p.stopbits} ---\n'
.format(p=miniterm.serial))
sys.stderr.write(
'--- Quit: {} | Menu: {} | Help: {} followed by {} ---\n'.format(
key_description(miniterm.exit_character),
key_description(miniterm.menu_character),
key_description(miniterm.menu_character),
key_description('\x08')))
miniterm.start()
try:
miniterm.join(True)
except KeyboardInterrupt:
pass
if not args.quiet:
sys.stderr.write("\n--- exit ---\n")
miniterm.join()
miniterm.close()
def open(self, port, baudrate):
if hasattr(self, "port"):
return
self.port = serial.serial_for_url(port, baudrate)