I am connecting with my Arduino through a USB port and sending data to it by using PySerial module. At first I can check if the device is connected by using this code:
try:
ser = serial.Serial("COM3", 9600)
except serial.serialutil.SerialException:
print "Arduino not connected"
Now what I want to do is to check periodically if the Arduino is still connected to the computer. I tried ser.isOpen() but this returns true even if the Arduino is disconnected. I would also like to know how to reconnect the device. I mean once you disconnect the device the program can no longer send any data to Arduino.
Most of the answers propose 2 approaches:
In some point of the code, send some sort of message through serial to check if your device is still alive
Start a separate thread and continuously check if the device is alive by opening a communication
The problem with the first solution is that you are not always checking the connection, but only checking in some specific points: this solution isn't very elegant and if badly written could even be not working.
The second solution solves the problem of the first solution, but introduces a new problem: checking the connection, or worst sending a message, in a threaded loop will cause problem or may even interrupt the connection to the device from other functions.
A solution that allows you to constantly check the connection without monopolizing the communication involves the reading of the existing COM:
import serial.tools.list_ports
myports = [tuple(p) for p in list(serial.tools.list_ports.comports())]
print myports
output:
[(u'COM3', u'Arduino Due Programming Port (COM3)', u'some more data...'),
(u'COM6', u'USB Serial Port (COM6)', u'some more data...'),
(u'COM100', u'com0com - serial port emulator (COM100)', u'some more data...')]
then we save the tuple that contains our port:
arduino_port = [port for port in myports if 'COM3' in port ][0]
then we create a function that checks if this port is still present:
import time
def check_presence(correct_port, interval=0.1):
while True:
myports = [tuple(p) for p in list(serial.tools.list_ports.comports())]
if arduino_port not in myports:
print "Arduino has been disconnected!"
break
time.sleep(interval)
At last, we run this function as a daemon thread:
import threading
port_controller = threading.Thread(target=check_presence, args=(arduino_port, 0.1,))
port_controller.setDaemon(True)
port_controller.start()
in this way, you'll check each 0.1 secs if the arduino is still connected, and the thread will end when arduino is disconnected or all other activities have ended
You can set a timeout.
import serial
ser = serial
try:
ser = serial.Serial("COM3", 9600, timeout=10)
while ser.read():
print 'serial open'
print 'serial closed'
ser.close()
except serial.serialutil.SerialException:
print 'exception'
Unfortunately, the best way I can find to do this is to try some communication and see if it fails. A pretty safe way would be:
try:
ser.inWaiting()
except:
print "Lost connection!"
You'll probably still want to close the connection with a ser.close() after the connection is lost, although you may need to place that in a "try:except" block also.
import serial
import time
ser = serial.Serial()
ser.braudrate = 115200
ser.port = "/dev/ttyUSB0"
ser.open()
print(ser.name)
if ser.isOpen():
print("serial is open!")
ser.close()
For example to detect ttyUSB0:
import os
x=os.system("ls /dev/ttyUSB0")
if x==0:
print "connected"
else:
print "disconnected"
i suggest to use a python thread class to istantiate a serial connection, in the run methos put your while loop , set an var that you use for kill iy at the end, the second public var that you use for store data if have receive and load data in main method.. soon paste an example
class Arduino():
def __init__(self,Port='/dev/ttyUSB0',Boud=9600,connState=0):
self.parent=self
self.port=Port
self.boud=Boud
self.connState=connState
self.timeount=1
self.ser=None
self.connect()
def connect(self):
try:
self.ser=serial.Serial(self.port,self.boud,timeout=0.0001)
self.connState=1
return [1,'connect']
except:
self.connState=0
return [0,'no hardware found']
def loadData(self):
self.buffer=self.ser.read(1)
if (self.buffer!=''):
try:
print self.buffer
except Exception, e:
pass
ard=Arduino()
while True:
if ard.connState:
ard.loadData()
else:
print "Arduino not found"
break
and start with:
import threading
class ThController( threading.Thread ):
# Override Thread's __init__ method to accept the parameters needed:
def __init__( self,parent):
self.parent = parent
threading.Thread.__init__ ( self )
def run ( self ):
while self.parent.ctrlattive:
j=json.loads(data)
self.parent.data=j
Related
I'm wondering if write_timeout even works or if I have to handle the timeout myself.
I want to send data to my STM32 Nucleo-Board via UART. For that I'm using the library pySerial. But if the write operation fails, because the Nucleo-Board isn't powered, I want to throw an error saying "Nucleo-Board not powered". I assume that when the write operation times out after 1 second, the Nucleo-Board has no power. So, I set the write_timeout of the serial.Serial() object to 1, but it seems that write_timeout doesn't do anything.
I created my own class, to add additional methods.
class Serial:
def __init__(self, baudrate: int, port: str, write_timeout: int = None, read_timeout: int = None):
self.baudrate = baudrate
self.port = port
self.write_timeout = write_timeout
self.read_timeout = read_timeout
self.ser = serial.Serial()
self.ser.baudrate = self.baudrate
self.ser.port = self.port
self.ser.write_timeout = self.write_timeout
self.ser.timeout = self.read_timeout
def _serial_ports():
# ...
def serialWrite(self, string: str, size: int = None):
print(self.write_timeout)
print(self.ser.write_timeout)
# check if COM port exists -> because UART cable is connected, COM6 always exists,
# even when no power is connected.
if self.port not in self._serial_ports():
raise serial.SerialException(f"Make sure this COM Port exists.")
try:
print("opened")
self.ser.open()
except serial.SerialException as e:
print("closed")
self.ser.close()
# error handling ...
else:
encodedString = string.encode()
print("write now")
try:
bytes = self.ser.write(encodedString) # times out here -> program hangs (no exception)
except Exception as e:
print(e)
print("Nucleo-Board not powered")
serialPort = Serial(baudrate=115200, port="COM6", write_timeout=1)
feedback = serialPort.serialWrite(f"ABC", 3)
Output
self.write_timeout=1
self.ser.write_timeout=1
opened
write now
I have to kill the program, because it stops working.
The program works, when I plug in the power of the Nucleo-Board.
Solution
The problem was, that I thought the timeout happens on ser.write(). But a timeout never happens on ser.write(), because (as #jasonharper already commented) the board being unpowered doesn't prevent serial data from being sent - it just means the data isn't going anywhere. So in the end, the timeout was a few lines after the write operation at the read operation ser.read(), to get a feedback to know the Nucleo-Board received something. There it can timeout, because it waits until data are received. But the board isn't powered so data will never received. Because I didn't handled the timeout for read operations, the program started to hang.
Current Code
try:
bytes = self.ser.write(encodedString)
except Exception as e:
# never raise
print(e)
print("Nucleo-Board not powered")
feedback = self.ser.read(size) # here it waits forever, because it doesn't receive something of course, because the Nucleo board isn't powered.
Code Solution
self.ser.timeout = 1 # for self.ser.read()
I use python with Pyserial to use the serial port, the code like this:
import serial
portName = 'COM5'
ser = serial.Serial(port=portName)
# Use the serial port...
But, the problem is, if the port is already open (by another application for example), I get an error when I try to open it like: "SerialException: could not open port 'COM5': WindowsError(5, 'Access is denied.')".
And I would like to know if I can open the port before trying to open it to avoid this error. I would like to use a kind of condition and open it only if I can:
import serial
portName = 'COM5'
if portIsUsable(portName):
ser = serial.Serial(port=portName)
# Use the serial port...
EDIT:
I have found a way to do it:
import serial
from serial import SerialException
portName = 'COM5'
try:
ser = serial.Serial(port=portName)
except SerialException:
print 'port already open'
# Use the serial port...
def portIsUsable(portName):
try:
ser = serial.Serial(port=portName)
return True
except:
return False
as mentioned in the comments watch out for race conditions under circumstances where you are opening and closing alot ...
also it might be better to just return the serial object or None
def getSerialOrNone(port):
try:
return serial.Serial(port)
except:
return None
[edit] I intentionally left the except as a catch-all, because I posit that the actual failure does not matter. as regardless of the error, that port is not usable ... since the function is testing the usability of a port, it does not matter why you get an exception it only matters that you got an exception.
I have a problem with this library:
https://code.google.com/p/python-xbee/
There is the xbee.wait_read_frame() function without a timeout.
I am testing all serial ports for a signal, but if i cannot timout a try there is no way to do it.
Is there a posibility in Python to upgrade this function without editing the library?
Or with small changes inside the library?
ports_available = []
for port in range(0,20):
try:
ser = serial.Serial(port, 9600)
ports_available.append(port)
ser.close()
except:
pass
print(ports_available)
for port in ports_available:
ser = serial.Serial(port, 9600)
bee = ZigBee(ser)
bee.at(command=b"MY")
print(bee.wait_read_frame()) #<----------
ser.close()
Looks like you need to use the asynchronous mode described on page 3 of the documentation. It might be tricky unless the data frame includes a parameter for the serial port that received it. If it doesn't, you won't be able to connect the data to port that received it.
import serial
import time
from xbee import XBee
serial_port = serial.Serial('/dev/ttyUSB0', 9600)
def print_data(data): """
This method is called whenever data is received
from the associated XBee device. Its first and
only argument is the data contained within the
frame.
"""
print data
xbee = XBee(serial_port, callback=print_data)
while True:
try:
time.sleep(0.001)
except KeyboardInterrupt:
break
xbee.halt()
serial_port.close()
Is it possible to achieve full-duplex communication using PySerial? Specifically, would it be possible to monitor the port continuously for input and write whenever needed? I imagine it should be possible using threads (and serial interfaces are full duplex no?). If not, what would be the best approach to monitoring a serial port when not transmitting? A timeout?
Edit: Here's my attempt at it. This code is targeting TI's CC2540 Bluetooth LE chip. On sending the GATT init message I expect a reply (detailing the operating parameters of the chip)...I'm getting nothing though
import serial
import threading
from time import sleep
serial_port = serial.Serial()
GAP_DeviceInit = \
"\x01\x00\xfe\x26\x08\x03\x00\x00\x00\x00\x00\x00\x00\x00\
\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\
\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00"
def read():
while True:
data = serial_port.read(9999);
if len(data) > 0:
print 'Got:', data
sleep(0.5)
print 'not blocked'
def main():
serial_port.baudrate = 57600
serial_port.port = '/dev/ttyACM0'
serial_port.timeout = 0
if serial_port.isOpen(): serial_port.close()
serial_port.open()
t1 = threading.Thread(target=read, args=())
while True:
try:
command = raw_input('Enter a command to send to the Keyfob: \n\t')
if (command == "1"):
serial_port.write(message)
except KeyboardInterrupt:
break
serial_port.close()
Yes serial port hardware is full duplex. Yes, you can use threads to do Rx and Tx at the same time. Alternatively, you can use a single thread loop that does reads with a short timeout and alternates between reading and writing.
You didn't specify a timeout, so the read waits for the full number of bytes to receive and only then displays anything.
I'm trying to read numerical values sent over a bluetooth modem from a serial port using Pyserial. I'm a beginner at Python, and found a good example that I'm trying to make use of.
from threading import Thread
import time
import serial
last_received = ''
def receiving(ser):
global last_received
buffer = ''
while True:
buffer = buffer + ser.read(ser.inWaiting())
if '\n' in buffer:
lines = buffer.split('\n') # Guaranteed to have at least 2 entries
last_received = lines[-2]
#If the modem sends lots of empty lines, you'll lose the
#last filled line, so you could make the above statement conditional
#like so: if lines[-2]: last_received = lines[-2]
buffer = lines[-1]
class SerialData(object):
def __init__(self, init=50):
try:
self.ser = ser = serial.Serial(
port='/dev/tty.FireFly-16CB-SPP',
baudrate=115200,
stopbits=serial.STOPBITS_ONE,
bytesize=serial.EIGHTBITS
)
except serial.serialutil.SerialException:
#no serial connection
self.ser = None
else:
Thread(target=receiving, args=(self.ser,)).start()
def next(self):
if not self.ser:
return 140 #return anything so we can test when Arduino isn't connected
#return a float value or try a few times until we get one
for i in range(40):
raw_line = last_received
try:
return float(raw_line.strip())
except ValueError:
print 'bogus data',raw_line
time.sleep(.005)
return 0.
def __del__(self):
if self.ser:
self.ser.close()
if __name__=='__main__':
s = SerialData()
for i in range(500):
time.sleep(.015)
print s.next()
I can open the port in another program, and can send/receive data from it. However, the code above doesn't seem to open the port, and just repeats "100" to the terminal window 500 times, but I don't know where it comes from or why the port doesn't open correctly. There isn't a delay from opening the port as it is on the other program, so I don't even know if it attempts to open.
I don't know what else to try, or where the error is so I'm asking for help. What am I doing wrong?
except serial.serialutil.SerialException:
You're catching and silencing errors in connecting. Comment out this block, and see if it produces an error message.