def work_read(self,num=1):
"read num bytes from serial port"
if not self.hComPort: raise portNotOpenError
flags, comstat = win32file.ClearCommError( self.hComPort )
#print "1:",comstat.cbInQue,
if comstat.cbInQue < num:
rc, mask = win32file.WaitCommEvent(self.hComPort, self.overlapped)
if rc == 0: # Character already ready!
win32event.SetEvent(self.overlapped.hEvent)
if self.timeout:
rc = win32event.WaitForSingleObject(self.overlapped.hEvent, self.timeout*1000)
else:
rc = win32event.WaitForSingleObject(self.overlapped.hEvent, win32event.INFINITE)
flags, comstat = win32file.ClearCommError( self.hComPort )
#print "2:",comstat.cbInQue,
#rc, data = win32file.ReadFile(self.hComPort, comstat.cbInQue, self.overlapped)
rc, data = win32file.ReadFile(self.hComPort, num, self.overlapped)
if self.timeout:
win32event.WaitForSingleObject(self.overlapped.hEvent, self.timeout*1000)
else:
win32event.WaitForSingleObject(self.overlapped.hEvent, win32event.INFINITE)
#old: hr, data = win32file.ReadFile(self.hComPort, num)
#print '.%s.' % str(data)
#print "read() soll %d ist %d" % (num, len(str(data))), repr(data)
return str(data)
def read(self, size=1):
"read num bytes from serial port"
if not self.hComPort: raise portNotOpenError
read = ''
if size > 0:
overlapped = win32file.OVERLAPPED()
overlapped.hEvent = win32event.CreateEvent(None, 1, 0, None)
if self.timeout == 0:
flags, comstat = win32file.ClearCommError(self.hComPort)
n = min(comstat.cbInQue, size)
if n > 0:
rc, buf = win32file.ReadFile(
self.hComPort, win32file.AllocateReadBuffer(n),
overlapped)
win32event.WaitForSingleObject(overlapped.hEvent,
win32event.INFINITE)
read = str(buf)
else:
flags, comstat = win32file.ClearCommError(self.hComPort)
rc, buf = win32file.ReadFile(
self.hComPort, win32file.AllocateReadBuffer(size),
overlapped)
n = win32file.GetOverlappedResult(self.hComPort, overlapped, 1)
read = str(buf[:n])
return read
def receivebyte(self, RDtimeout=0):
"""read num bytes from serial port"""
if not self.hComPort: raise portNotOpenError
timeouts = (win32con.MAXDWORD, win32con.MAXDWORD, int(RDtimeout * 100),
0, 0) # timeouts in 100 ms units...
win32file.SetCommTimeouts(self.hComPort, timeouts)
win32event.ResetEvent(self._overlappedRead.hEvent)
flags, comstat = win32file.ClearCommError(self.hComPort)
n = comstat.cbInQue
if n > 0: # there is data in buffer
rc, buf = win32file.ReadFile(self.hComPort,
win32file.AllocateReadBuffer(1),
self._overlappedRead)
win32event.WaitForSingleObject(self._overlappedRead.hEvent,
win32event.INFINITE)
read = buf[0]
else:
rc, buf = win32file.ReadFile(self.hComPort,
win32file.AllocateReadBuffer(1),
self._overlappedRead)
n = win32file.GetOverlappedResult(self.hComPort,
self._overlappedRead, 1)
if n > 0:
read = buf[0]
else:
read = -1
return read
def _read(self, size=1):
flags, comstat = win32file.ClearCommError( self.hComPort )
#print "1:",comstat.cbInQue,
if comstat.cbInQue < size:
rc, mask = win32file.WaitCommEvent(self.hComPort, self.overlapped)
if rc == 0: # Character already ready!
win32event.SetEvent(self.overlapped.hEvent)
rc = win32event.WaitForSingleObject(self.overlapped.hEvent, win32event.INFINITE)
flags, comstat = win32file.ClearCommError( self.hComPort )
#print "2:",comstat.cbInQue,
rc, data = win32file.ReadFile(self.hComPort, size, self.overlapped)
win32event.WaitForSingleObject(self.overlapped.hEvent, win32event.INFINITE)
print "read %r" % str(data)
return str(data)
def readuntil(self, char):
"read bytes from serial port until char is hit"
if not self.hComPort: raise portNotOpenError
print thetime(), "readuntil entered"
overlapped = win32file.OVERLAPPED()
overlapped.hEvent = win32event.CreateEvent(None, 1, 0, None)
dcb = win32file.GetCommState(self.hComPort)
oldevt = dcb.EvtChar
dcb.EvtChar = char
rc = win32file.SetCommState(self.hComPort, dcb)
print thetime(), "setcommstate returned", rc
oldmask = win32file.GetCommMask(self.hComPort)
rc = win32file.SetCommMask(self.hComPort, win32file.EV_RXFLAG)
print thetime(), "setcommmask returned", rc
rc, mask = win32file.WaitCommEvent(self.hComPort, overlapped)
print thetime(), "waitcommevent returned", rc, mask
rc = win32event.WaitForSingleObject(overlapped.hEvent, 10000)
print thetime(), "waitforsingleobject returned", rc
n = win32file.GetOverlappedResult(self.hComPort, overlapped, 0)
print thetime(), "getoverlappedresult returned", n
win32file.SetCommMask(self.hComPort, oldmask)
flags, comstat = win32file.ClearCommError(self.hComPort)
print thetime(), "clearcommerror", flags, comstat.cbInQue
rc, buf = win32file.ReadFile(
self.hComPort, win32file.AllocateReadBuffer(comstat.cbInQue),
overlapped)
print thetime(), "readfile retrurned", rc
n = win32file.GetOverlappedResult(self.hComPort, overlapped, 1)
print thetime(), "getoverlappedresult returned", n
read = str(buf[:n])
return read
def serialReadEvent(self):
#get that character we set up
n = win32file.GetOverlappedResult(self._serial.hComPort,
self._overlappedRead, 0)
if n:
first = str(self.read_buf[:n])
#now we should get everything that is already in the buffer
flags, comstat = win32file.ClearCommError(self._serial.hComPort)
if comstat.cbInQue:
win32event.ResetEvent(self._overlappedRead.hEvent)
rc, buf = win32file.ReadFile(
self._serial.hComPort,
win32file.AllocateReadBuffer(comstat.cbInQue),
self._overlappedRead)
n = win32file.GetOverlappedResult(self._serial.hComPort,
self._overlappedRead, 1)
#handle all the received data:
self.protocol.dataReceived(first + str(buf[:n]))
else:
#handle all the received data:
self.protocol.dataReceived(first)
#set up next one
win32event.ResetEvent(self._overlappedRead.hEvent)
rc, self.read_buf = win32file.ReadFile(self._serial.hComPort,
win32file.AllocateReadBuffer(1),
self._overlappedRead)
def read(self, size=1):
"""Read size bytes from the serial port. If a timeout is set it may
return less characters as requested. With no timeout it will block
until the requested number of bytes is read."""
if not self.hComPort: raise portNotOpenError
if size > 0:
win32event.ResetEvent(self._overlappedRead.hEvent)
flags, comstat = win32file.ClearCommError(self.hComPort)
if self.timeout == 0:
n = min(comstat.cbInQue, size)
if n > 0:
rc, buf = win32file.ReadFile(
self.hComPort, win32file.AllocateReadBuffer(n),
self._overlappedRead)
win32event.WaitForSingleObject(self._overlappedRead.hEvent,
win32event.INFINITE)
read = str(buf)
else:
read = ''
else:
rc, buf = win32file.ReadFile(
self.hComPort, win32file.AllocateReadBuffer(size),
self._overlappedRead)
n = win32file.GetOverlappedResult(self.hComPort,
self._overlappedRead, 1)
read = str(buf[:n])
else:
read = ''
return read
def __init__(self, protocol, deviceNameOrPortNumber, reactor,
baudrate = 9600, bytesize = EIGHTBITS, parity = PARITY_NONE,
stopbits = STOPBITS_ONE, xonxoff = 0, rtscts = 0):
self._serial = serial.Serial(deviceNameOrPortNumber, baudrate=baudrate,
bytesize=bytesize, parity=parity,
stopbits=stopbits, timeout=None,
xonxoff=xonxoff, rtscts=rtscts)
self.flushInput()
self.flushOutput()
self.reactor = reactor
self.protocol = protocol
self.outQueue = []
self.closed = 0
self.closedNotifies = 0
self.writeInProgress = 0
self.protocol = protocol
self._overlappedRead = win32file.OVERLAPPED()
self._overlappedRead.hEvent = win32event.CreateEvent(None, 1, 0, None)
self._overlappedWrite = win32file.OVERLAPPED()
self._overlappedWrite.hEvent = win32event.CreateEvent(None, 0, 0, None)
self.reactor.addEvent(self._overlappedRead.hEvent, self, 'serialReadEvent')
self.reactor.addEvent(self._overlappedWrite.hEvent, self, 'serialWriteEvent')
self.protocol.makeConnection(self)
flags, comstat = win32file.ClearCommError(self._serial.hComPort)
rc, self.read_buf = win32file.ReadFile(self._serial.hComPort,
win32file.AllocateReadBuffer(1),
self._overlappedRead)
def _finishPortSetup(self):
"""
Finish setting up the serial port.
This is a separate method to facilitate testing.
"""
flags, comstat = win32file.ClearCommError(self._serial.hComPort)
rc, self.read_buf = win32file.ReadFile(self._serial.hComPort,
win32file.AllocateReadBuffer(1),
self._overlappedRead)
def readbyte(self):
"""read a byte from serial port what's in it..."""
if not self.hComPort: raise portNotOpenError
timeouts = (win32con.MAXDWORD, 0, 0, 0, 0)
win32file.SetCommTimeouts(self.hComPort, timeouts)
win32event.ResetEvent(self._overlappedRead.hEvent)
flags, comstat = win32file.ClearCommError(self.hComPort)
n = comstat.cbInQue
if n > 0:
rc, buf = win32file.ReadFile(self.hComPort,
win32file.AllocateReadBuffer(1),
self._overlappedRead)
win32event.WaitForSingleObject(self._overlappedRead.hEvent,
win32event.INFINITE)
read = buf[0]
else:
read = -1
return read
def read(self, size=1):
"""read num bytes from serial port"""
if not self.hComPort: raise portNotOpenError
if size > 0:
win32event.ResetEvent(self._overlappedRead.hEvent)
flags, comstat = win32file.ClearCommError(self.hComPort)
if self.timeout == 0:
n = min(comstat.cbInQue, size)
if n > 0:
rc, buf = win32file.ReadFile(self.hComPort, win32file.AllocateReadBuffer(n), self._overlappedRead)
win32event.WaitForSingleObject(self._overlappedRead.hEvent, win32event.INFINITE)
read = str(buf)
else:
read = ''
else:
rc, buf = win32file.ReadFile(self.hComPort, win32file.AllocateReadBuffer(size), self._overlappedRead)
n = win32file.GetOverlappedResult(self.hComPort, self._overlappedRead, 1)
read = str(buf[:n])
else:
read = ''
return read
def read(self, size=1):
"read num bytes from serial port"
if not self.hComPort: raise portNotOpenError
#print "read %d" %size ####debug
read = ''
if size > 0:
while len(read) < size:
flags, comstat = win32file.ClearCommError(self.hComPort)
rc, buf = win32file.ReadFile(self.hComPort, size - len(read),
self.overlapped)
if self.timeout:
rc = win32event.WaitForSingleObject(
self.overlapped.hEvent, self.timeout * 1000)
if rc == win32event.WAIT_TIMEOUT: break
#TODO: if reading more than 1 byte data can be lost when a timeout occours!!!!
else:
win32event.WaitForSingleObject(self.overlapped.hEvent,
win32event.INFINITE)
read = read + str(buf)
#print "read %r" % str(read)
return str(read)
def read(self, size=1):
"read num bytes from serial port"
if not self.hComPort: raise portNotOpenError
#print "read %d" %size ####debug
read = ''
if size > 0:
while len(read) < size:
flags, comstat = win32file.ClearCommError( self.hComPort )
#print "1:",comstat.cbInQue,
#self.overlapped = win32file.OVERLAPPED()
#self.overlapped.hEvent = win32event.CreateEvent(None, 0, 0, None)
#win32event.ResetEvent(self.overlapped.hEvent)
## if comstat.cbInQue < size:
## #print "read <size" ####debug
## rc, mask = win32file.WaitCommEvent(self.hComPort, self.overlapped)
## if rc == 0: # Character already ready!
## win32event.SetEvent(self.overlapped.hEvent)
##
## if self.timeout:
## rc = win32event.WaitForSingleObject(self.overlapped.hEvent, self.timeout*1000)
## if rc == win32event.WAIT_TIMEOUT: break
## else:
## rc = win32event.WaitForSingleObject(self.overlapped.hEvent, win32event.INFINITE)
## flags, comstat = win32file.ClearCommError( self.hComPort )
## #print "2:",comstat.cbInQue,
rc, buf = win32file.ReadFile(self.hComPort, size-len(read), self.overlapped)
if self.timeout:
rc = win32event.WaitForSingleObject(self.overlapped.hEvent, self.timeout*1000)
if rc == win32event.WAIT_TIMEOUT: break
#TODO: if reading more than 1 byte data can be lost when a timeout occours!!!!
else:
win32event.WaitForSingleObject(self.overlapped.hEvent, win32event.INFINITE)
read = read + str(buf)
#print "read() soll %d ist %d" % (num, len(str(data))), repr(data)
#print "read %r" % str(read)
return str(read)
def inWaiting(self):
"""returns the number of bytes waiting to be read"""
flags, comstat = win32file.ClearCommError(self.hComPort)
return comstat.cbInQue
def inWaiting(self):
"""Return the number of characters currently in the input buffer."""
flags, comstat = win32file.ClearCommError(self.hComPort)
return comstat.cbInQue
def _clearCommError(self):
return win32file.ClearCommError(self._serial.hComPort)
def _clearCommError(self):
return win32file.ClearCommError(self._serial._port_handle)
