pySerial 2.6: specify end-of-line in readline()
Question:
I am sending commands to Eddie using pySerial. I need to specify a carriage-return in my readline, but pySerial 2.6 got rid of it… Is there a workaround?
Here are the Eddie command set is listed on the second and third pages of this PDF. Here is a backup image in the case where the PDF is inaccessible.
General command form:
Input: <cmd>[<WS><param1>...<WS><paramN>]<CR>
Response (Success): [<param1>...<WS><paramN>]<CR>
Response (Failure): ERROR[<SP>-<SP><verbose_reason>]<CR>
As you can see all responses end with a r. I need to tell pySerial to stop.
What I have now:
def sendAndReceive(self, content):
logger.info('Sending {0}'.format(content))
self.ser.write(content + 'r')
self.ser.flush();
response = self.ser.readline() # Currently stops reading on timeout...
if self.isErr(response):
logger.error(response)
return None
else:
return response
Answers:
It seems that the timeout occurs because readline() waits for an 'n' character to come from the serial device, which it never sends.
According to the pyserial documentation, you can specify the end of line character:
response = self.ser.readline(eol='r')
Does that work?
I’m having the same issue and implemented my own readline() function which I copied and modified from the serialutil.py file found in the pyserial package.
The serial connection is part of the class this function belongs to and is saved in attribute ‘self.ser’
def _readline(self):
eol = b'r'
leneol = len(eol)
line = bytearray()
while True:
c = self.ser.read(1)
if c:
line += c
if line[-leneol:] == eol:
break
else:
break
return bytes(line)
This is a safer, nicer and faster option than waiting for the timeout.
EDIT:
I came across this post when trying to get the io.TextIOWrapper method to work (thanks zmo).
So instead of using the custom readline function as mentioned above you could use:
self.ser = serial.Serial(port=self.port,
baudrate=9600,
bytesize=serial.EIGHTBITS,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
timeout=1)
self.ser_io = io.TextIOWrapper(io.BufferedRWPair(self.ser, self.ser, 1),
newline = 'r',
line_buffering = True)
self.ser_io.write("IDr")
self_id = self.ser_io.readline()
Make sure to pass the argument 1 to the BufferedRWPair, otherwise it will not pass the data to the TextIOWrapper after every byte causing the serial connection to timeout again.
When setting line_buffering to True you no longer have to call the flush function after every write (if the write is terminated with a newline character).
EDIT:
The TextIOWrapper method works in practice for small command strings, but its behavior is undefined and can lead to errors when transmitting more than a couple bytes. The safest thing to do really is to implement your own version of readline.
from pyserial’s documentation:
(sic)
Note:
The eol parameter for readline() is no longer supported when
pySerial is run with newer Python versions (V2.6+) where the module
io is available. EOL
To specify the EOL character for readline() or to use universal
newline mode, it is advised to use io.TextIOWrapper:
import serial
import io
ser = serial.serial_for_url('loop://', timeout=1)
sio = io.TextIOWrapper(io.BufferedRWPair(ser, ser))
sio.write(unicode("hellon"))
sio.flush() # it is buffering. required to get the data out *now*
hello = sio.readline()
print hello == unicode("hellon")
reading 10 data from port 3 with board rate 38400, The data is separated with n character when comes in the incoming data
import serial as self
ser=self.Serial("COM3", 38400)
buffer = []
count = 0.0
c = " "
while count < 10:
c = " "
if ser.inWaiting():
while True:
val = ser.read(1)
if "n" in val:
break
else:
c += val
buffer.append(c) # stores all data received into a list
count += 1
print buffer
From pyserial 3.2.1 (default from debian Stretch) read_until is available. if you would like to change cartridge from default (‘n’) to ‘r’, simply do:
import serial
ser=serial.Serial('COM5',9600)
ser.write(b'commandr') # sending command
ser.read_until(b'r') # read until 'r' appears
b'r' could be changed to whatever you will be using as carriadge return.
I am sending commands to Eddie using pySerial. I need to specify a carriage-return in my readline, but pySerial 2.6 got rid of it… Is there a workaround?
Here are the Eddie command set is listed on the second and third pages of this PDF. Here is a backup image in the case where the PDF is inaccessible.
General command form:
Input: <cmd>[<WS><param1>...<WS><paramN>]<CR>
Response (Success): [<param1>...<WS><paramN>]<CR>
Response (Failure): ERROR[<SP>-<SP><verbose_reason>]<CR>
As you can see all responses end with a r. I need to tell pySerial to stop.
What I have now:
def sendAndReceive(self, content):
logger.info('Sending {0}'.format(content))
self.ser.write(content + 'r')
self.ser.flush();
response = self.ser.readline() # Currently stops reading on timeout...
if self.isErr(response):
logger.error(response)
return None
else:
return response
It seems that the timeout occurs because readline() waits for an 'n' character to come from the serial device, which it never sends.
According to the pyserial documentation, you can specify the end of line character:
response = self.ser.readline(eol='r')
Does that work?
I’m having the same issue and implemented my own readline() function which I copied and modified from the serialutil.py file found in the pyserial package.
The serial connection is part of the class this function belongs to and is saved in attribute ‘self.ser’
def _readline(self):
eol = b'r'
leneol = len(eol)
line = bytearray()
while True:
c = self.ser.read(1)
if c:
line += c
if line[-leneol:] == eol:
break
else:
break
return bytes(line)
This is a safer, nicer and faster option than waiting for the timeout.
EDIT:
I came across this post when trying to get the io.TextIOWrapper method to work (thanks zmo).
So instead of using the custom readline function as mentioned above you could use:
self.ser = serial.Serial(port=self.port,
baudrate=9600,
bytesize=serial.EIGHTBITS,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
timeout=1)
self.ser_io = io.TextIOWrapper(io.BufferedRWPair(self.ser, self.ser, 1),
newline = 'r',
line_buffering = True)
self.ser_io.write("IDr")
self_id = self.ser_io.readline()
Make sure to pass the argument 1 to the BufferedRWPair, otherwise it will not pass the data to the TextIOWrapper after every byte causing the serial connection to timeout again.
When setting line_buffering to True you no longer have to call the flush function after every write (if the write is terminated with a newline character).
EDIT:
The TextIOWrapper method works in practice for small command strings, but its behavior is undefined and can lead to errors when transmitting more than a couple bytes. The safest thing to do really is to implement your own version of readline.
from pyserial’s documentation:
(sic)
Note:
The
eolparameter forreadline()is no longer supported when
pySerial is run with newer Python versions (V2.6+) where the module
iois available. EOLTo specify the
EOLcharacter forreadline()or to use universal
newline mode, it is advised to useio.TextIOWrapper:import serial import io ser = serial.serial_for_url('loop://', timeout=1) sio = io.TextIOWrapper(io.BufferedRWPair(ser, ser)) sio.write(unicode("hellon")) sio.flush() # it is buffering. required to get the data out *now* hello = sio.readline() print hello == unicode("hellon")
reading 10 data from port 3 with board rate 38400, The data is separated with n character when comes in the incoming data
import serial as self
ser=self.Serial("COM3", 38400)
buffer = []
count = 0.0
c = " "
while count < 10:
c = " "
if ser.inWaiting():
while True:
val = ser.read(1)
if "n" in val:
break
else:
c += val
buffer.append(c) # stores all data received into a list
count += 1
print buffer
From pyserial 3.2.1 (default from debian Stretch) read_until is available. if you would like to change cartridge from default (‘n’) to ‘r’, simply do:
import serial
ser=serial.Serial('COM5',9600)
ser.write(b'commandr') # sending command
ser.read_until(b'r') # read until 'r' appears
b'r' could be changed to whatever you will be using as carriadge return.