diff options
-rw-r--r-- | pyserial/CHANGES.txt | 2 | ||||
-rw-r--r-- | pyserial/serial/serialwin32.py | 199 | ||||
-rw-r--r-- | pyserial/serial/win32.py | 273 |
3 files changed, 383 insertions, 91 deletions
diff --git a/pyserial/CHANGES.txt b/pyserial/CHANGES.txt index 2fd7d80..b1b366c 100644 --- a/pyserial/CHANGES.txt +++ b/pyserial/CHANGES.txt @@ -305,6 +305,8 @@ New Features: - 1.5 stop bits (STOPBITS_ONE_POINT_FIVE, implemented on all platforms) - miniterm application extended - add scanlinux.py example +- Support for Win32 is now written on the top of ctypes (bundled with + Python 2.5+) instead of pywin32 (patch by Giovanni Bajo). Bugfixes: diff --git a/pyserial/serial/serialwin32.py b/pyserial/serial/serialwin32.py index 656c5dd..35415db 100644 --- a/pyserial/serial/serialwin32.py +++ b/pyserial/serial/serialwin32.py @@ -5,17 +5,14 @@ # # (C) 2001-2009 Chris Liechti <cliechti@gmx.net> # this is distributed under a free software license, see license.txt +# +# Initial patch to use ctypes by Giovanni Bajo <rasky@develer.com> + +import ctypes +import win32 -import win32file # The base COM port and file IO functions. -import win32event # We use events and the WaitFor[Single|Multiple]Objects functions. -import win32con # constants. from serialutil import * -#from winbase.h. these should really be in win32con -MS_CTS_ON = 16 -MS_DSR_ON = 32 -MS_RING_ON = 64 -MS_RLSD_ON = 128 def device(portnum): """Turn a port number into a device name""" @@ -41,38 +38,39 @@ class Serial(SerialBase): if port.upper().startswith('COM') and int(port[3:]) > 8: port = '\\\\.\\' + port try: - self.hComPort = win32file.CreateFile(port, - win32con.GENERIC_READ | win32con.GENERIC_WRITE, + self.hComPort = win32.CreateFile(port, + win32.GENERIC_READ | win32.GENERIC_WRITE, 0, # exclusive access None, # no security - win32con.OPEN_EXISTING, - win32con.FILE_FLAG_OVERLAPPED, - None) + win32.OPEN_EXISTING, + win32.FILE_ATTRIBUTE_NORMAL | win32.FILE_FLAG_OVERLAPPED, + 0) except Exception, msg: self.hComPort = None #'cause __del__ is called anyway raise SerialException("could not open port %s: %s" % (self.portstr, msg)) # Setup a 4k buffer - win32file.SetupComm(self.hComPort, 4096, 4096) + win32.SetupComm(self.hComPort, 4096, 4096) # Save original timeout values: - self._orgTimeouts = win32file.GetCommTimeouts(self.hComPort) + self._orgTimeouts = win32.COMMTIMEOUTS() + win32.GetCommTimeouts(self.hComPort, ctypes.byref(self._orgTimeouts)) - self._rtsState = win32file.RTS_CONTROL_ENABLE - self._dtrState = win32file.DTR_CONTROL_ENABLE + self._rtsState = win32.RTS_CONTROL_ENABLE + self._dtrState = win32.DTR_CONTROL_ENABLE self._reconfigurePort() # Clear buffers: # Remove anything that was there - win32file.PurgeComm(self.hComPort, - win32file.PURGE_TXCLEAR | win32file.PURGE_TXABORT | - win32file.PURGE_RXCLEAR | win32file.PURGE_RXABORT) - - self._overlappedRead = win32file.OVERLAPPED() - self._overlappedRead.hEvent = win32event.CreateEvent(None, 1, 0, None) - self._overlappedWrite = win32file.OVERLAPPED() - #~ self._overlappedWrite.hEvent = win32event.CreateEvent(None, 1, 0, None) - self._overlappedWrite.hEvent = win32event.CreateEvent(None, 0, 0, None) + win32.PurgeComm(self.hComPort, + win32.PURGE_TXCLEAR | win32.PURGE_TXABORT | + win32.PURGE_RXCLEAR | win32.PURGE_RXABORT) + + self._overlappedRead = win32.OVERLAPPED() + self._overlappedRead.hEvent = win32.CreateEvent(None, 1, 0, None) + self._overlappedWrite = win32.OVERLAPPED() + #~ self._overlappedWrite.hEvent = win32.CreateEvent(None, 1, 0, None) + self._overlappedWrite.hEvent = win32.CreateEvent(None, 0, 0, None) self._isOpen = True def _reconfigurePort(self): @@ -88,7 +86,7 @@ class Serial(SerialBase): if self._timeout is None: timeouts = (0, 0, 0, 0, 0) elif self._timeout == 0: - timeouts = (win32con.MAXDWORD, 0, 0, 0, 0) + timeouts = (win32.MAXDWORD, 0, 0, 0, 0) else: timeouts = (0, 0, int(self._timeout*1000), 0, 0) if self._timeout != 0 and self._interCharTimeout is not None: @@ -97,16 +95,17 @@ class Serial(SerialBase): if self._writeTimeout is None: pass elif self._writeTimeout == 0: - timeouts = timeouts[:-2] + (0, win32con.MAXDWORD) + timeouts = timeouts[:-2] + (0, win32.MAXDWORD) else: timeouts = timeouts[:-2] + (0, int(self._writeTimeout*1000)) - win32file.SetCommTimeouts(self.hComPort, timeouts) + win32.SetCommTimeouts(self.hComPort, ctypes.byref(win32.COMMTIMEOUTS(*timeouts))) - win32file.SetCommMask(self.hComPort, win32file.EV_ERR) + win32.SetCommMask(self.hComPort, win32.EV_ERR) # Setup the connection info. # Get state and modify it: - comDCB = win32file.GetCommState(self.hComPort) + comDCB = win32.DCB() + win32.GetCommState(self.hComPort, ctypes.byref(comDCB)) comDCB.BaudRate = self._baudrate if self._bytesize == FIVEBITS: @@ -121,40 +120,40 @@ class Serial(SerialBase): raise ValueError("Unsupported number of data bits: %r" % self._bytesize) if self._parity == PARITY_NONE: - comDCB.Parity = win32file.NOPARITY - comDCB.fParity = 0 # Dis/Enable Parity Check + comDCB.Parity = win32.NOPARITY + comDCB.fParity = 0 # Disable Parity Check elif self._parity == PARITY_EVEN: - comDCB.Parity = win32file.EVENPARITY - comDCB.fParity = 1 # Dis/Enable Parity Check + comDCB.Parity = win32.EVENPARITY + comDCB.fParity = 1 # Enable Parity Check elif self._parity == PARITY_ODD: - comDCB.Parity = win32file.ODDPARITY - comDCB.fParity = 1 # Dis/Enable Parity Check + comDCB.Parity = win32.ODDPARITY + comDCB.fParity = 1 # Enable Parity Check elif self._parity == PARITY_MARK: - comDCB.Parity = win32file.MARKPARITY - comDCB.fParity = 1 # Dis/Enable Parity Check + comDCB.Parity = win32.MARKPARITY + comDCB.fParity = 1 # Enable Parity Check elif self._parity == PARITY_SPACE: - comDCB.Parity = win32file.SPACEPARITY - comDCB.fParity = 1 # Dis/Enable Parity Check + comDCB.Parity = win32.SPACEPARITY + comDCB.fParity = 1 # Enable Parity Check else: raise ValueError("Unsupported parity mode: %r" % self._parity) if self._stopbits == STOPBITS_ONE: - comDCB.StopBits = win32file.ONESTOPBIT + comDCB.StopBits = win32.ONESTOPBIT elif self._stopbits == STOPBITS_ONE_POINT_FIVE: - comDCB.StopBits = win32file.ONE5STOPBITS + comDCB.StopBits = win32.ONE5STOPBITS elif self._stopbits == STOPBITS_TWO: - comDCB.StopBits = win32file.TWOSTOPBITS + comDCB.StopBits = win32.TWOSTOPBITS else: raise ValueError("Unsupported number of stop bits: %r" % self._stopbits) comDCB.fBinary = 1 # Enable Binary Transmission # Char. w/ Parity-Err are replaced with 0xff (if fErrorChar is set to TRUE) if self._rtscts: - comDCB.fRtsControl = win32file.RTS_CONTROL_HANDSHAKE + comDCB.fRtsControl = win32.RTS_CONTROL_HANDSHAKE else: comDCB.fRtsControl = self._rtsState if self._dsrdtr: - comDCB.fDtrControl = win32file.DTR_CONTROL_HANDSHAKE + comDCB.fDtrControl = win32.DTR_CONTROL_HANDSHAKE else: comDCB.fDtrControl = self._dtrState comDCB.fOutxCtsFlow = self._rtscts @@ -167,9 +166,7 @@ class Serial(SerialBase): comDCB.XonChar = XON comDCB.XoffChar = XOFF - try: - win32file.SetCommState(self.hComPort, comDCB) - except win32file.error, e: + if not win32.SetCommState(self.hComPort, ctypes.byref(comDCB)): raise ValueError("Cannot configure port, some setting was wrong. Original message: %s" % e) #~ def __del__(self): @@ -179,16 +176,12 @@ class Serial(SerialBase): """Close port""" if self._isOpen: if self.hComPort: - try: - # Restore original timeout values: - win32file.SetCommTimeouts(self.hComPort, self._orgTimeouts) - except win32file.error: - # ignore errors. can happen for unplugged USB serial devices - pass + # Restore original timeout values: + win32.SetCommTimeouts(self.hComPort, self._orgTimeouts) # Close COM-Port: - win32file.CloseHandle(self.hComPort) - win32file.CloseHandle(self._overlappedRead.hEvent) - win32file.CloseHandle(self._overlappedWrite.hEvent) + win32.CloseHandle(self.hComPort) + win32.CloseHandle(self._overlappedRead.hEvent) + win32.CloseHandle(self._overlappedWrite.hEvent) self.hComPort = None self._isOpen = False @@ -199,7 +192,10 @@ class Serial(SerialBase): def inWaiting(self): """Return the number of characters currently in the input buffer.""" - flags, comstat = win32file.ClearCommError(self.hComPort) + flags = win32.DWORD() + comstat = win32.COMSTAT() + if not win32.ClearCommError(self.hComPort, ctypes.byref(flags), ctypes.byref(comstat)): + raise SerialException('call to ClearCommError failed') return comstat.cbInQue def read(self, size=1): @@ -208,20 +204,31 @@ class Serial(SerialBase): 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) + win32.ResetEvent(self._overlappedRead.hEvent) + flags = win32.DWORD() + comstat = win32.COMSTAT() + if not win32.ClearCommError(self.hComPort, ctypes.byref(flags), ctypes.byref(comstat)): + raise SerialException('call to ClearCommError failed') 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) + buf = ctypes.create_string_buffer(n) + rc = win32.DWORD() + err = win32.ReadFile(self.hComPort, buf, size, ctypes.byref(rc), ctypes.byref(self._overlappedRead)) + if not err and win32.GetLastError() != win32.ERROR_IO_PENDING: + raise SerialException("ReadFile failed (%s)" % WinError()) + err = win32.WaitForSingleObject(self._overlappedRead.hEvent, win32.INFINITE) + read = buf.raw[:rc.value] 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]) + buf = ctypes.create_string_buffer(size) + rc = win32.DWORD() + err = win32.ReadFile(self.hComPort, buf, size, ctypes.byref(rc), ctypes.byref(self._overlappedRead)) + if not err and win32.GetLastError() != win32.ERROR_IO_PENDING: + raise SerialException("ReadFile failed (%s)" % WinError()) + err = win32.GetOverlappedResult(self.hComPort, ctypes.byref(self._overlappedRead), ctypes.byref(rc), True) + read = buf.raw[:rc.value] else: read = '' return read @@ -233,81 +240,88 @@ class Serial(SerialBase): raise TypeError('expected str, got %s' % type(data)) if data: #~ win32event.ResetEvent(self._overlappedWrite.hEvent) - err, n = win32file.WriteFile(self.hComPort, data, self._overlappedWrite) - if err: #will be ERROR_IO_PENDING: - # Wait for the write to complete. - #~ win32event.WaitForSingleObject(self._overlappedWrite.hEvent, win32event.INFINITE) - n = win32file.GetOverlappedResult(self.hComPort, self._overlappedWrite, 1) - if n != len(data): - raise writeTimeoutError + n = win32.DWORD() + err = win32.WriteFile(self.hComPort, s, len(s), ctypes.byref(n), self._overlappedWrite) + if not err and win32.GetLastError() != win32.ERROR_IO_PENDING: + raise SerialException("WriteFile failed (%s)" % WinError()) + # Wait for the write to complete. + #~ win32.WaitForSingleObject(self._overlappedWrite.hEvent, win32.INFINITE) + win32.GetOverlappedResult(self.hComPort, self._overlappedWrite, ctypes.byref(n), True) + if n != len(s): + raise writeTimeoutError def flushInput(self): """Clear input buffer, discarding all that is in the buffer.""" if not self.hComPort: raise portNotOpenError - win32file.PurgeComm(self.hComPort, win32file.PURGE_RXCLEAR | win32file.PURGE_RXABORT) + win32.PurgeComm(self.hComPort, win32.PURGE_RXCLEAR | win32.PURGE_RXABORT) def flushOutput(self): """Clear output buffer, aborting the current output and discarding all that is in the buffer.""" if not self.hComPort: raise portNotOpenError - win32file.PurgeComm(self.hComPort, win32file.PURGE_TXCLEAR | win32file.PURGE_TXABORT) + win32.PurgeComm(self.hComPort, win32.PURGE_TXCLEAR | win32.PURGE_TXABORT) def sendBreak(self, duration=0.25): """Send break condition. Timed, returns to idle state after given duration.""" if not self.hComPort: raise portNotOpenError import time - win32file.SetCommBreak(self.hComPort) + win32.SetCommBreak(self.hComPort) time.sleep(duration) - win32file.ClearCommBreak(self.hComPort) + win32.ClearCommBreak(self.hComPort) def setBreak(self, level=1): """Set break: Controls TXD. When active, to transmitting is possible.""" if not self.hComPort: raise portNotOpenError if level: - win32file.SetCommBreak(self.hComPort) + win32.SetCommBreak(self.hComPort) else: - win32file.ClearCommBreak(self.hComPort) + win32.ClearCommBreak(self.hComPort) def setRTS(self, level=1): """Set terminal status line: Request To Send""" if not self.hComPort: raise portNotOpenError if level: self._rtsState = win32file.RTS_CONTROL_ENABLE - win32file.EscapeCommFunction(self.hComPort, win32file.SETRTS) + win32.EscapeCommFunction(self.hComPort, win32.SETRTS) else: self._rtsState = win32file.RTS_CONTROL_DISABLE - win32file.EscapeCommFunction(self.hComPort, win32file.CLRRTS) + win32.EscapeCommFunction(self.hComPort, win32.CLRRTS) def setDTR(self, level=1): """Set terminal status line: Data Terminal Ready""" if not self.hComPort: raise portNotOpenError if level: self._dtrState = win32file.DTR_CONTROL_ENABLE - win32file.EscapeCommFunction(self.hComPort, win32file.SETDTR) + win32.EscapeCommFunction(self.hComPort, win32.SETDTR) else: self._dtrState = win32file.DTR_CONTROL_DISABLE - win32file.EscapeCommFunction(self.hComPort, win32file.CLRDTR) + win32.EscapeCommFunction(self.hComPort, win32.CLRDTR) + + def _GetCommModemStatus(self): + stat = win32.DWORD() + win32.GetCommModemStatus(self.hComPort, ctypes.byref(stat)) + return stat.value def getCTS(self): """Read terminal status line: Clear To Send""" if not self.hComPort: raise portNotOpenError - return MS_CTS_ON & win32file.GetCommModemStatus(self.hComPort) != 0 + return win32.MS_CTS_ON & self._GetCommModemStatus() != 0 def getDSR(self): """Read terminal status line: Data Set Ready""" if not self.hComPort: raise portNotOpenError - return MS_DSR_ON & win32file.GetCommModemStatus(self.hComPort) != 0 + return win32.MS_DSR_ON & self._GetCommModemStatus() != 0 def getRI(self): """Read terminal status line: Ring Indicator""" if not self.hComPort: raise portNotOpenError - return MS_RING_ON & win32file.GetCommModemStatus(self.hComPort) != 0 + return win32.MS_RING_ON & self._GetCommModemStatus() != 0 def getCD(self): """Read terminal status line: Carrier Detect""" if not self.hComPort: raise portNotOpenError - return MS_RLSD_ON & win32file.GetCommModemStatus(self.hComPort) != 0 + return win32.MS_RLSD_ON & self._GetCommModemStatus() != 0 # - - platform specific - - - - @@ -315,13 +329,16 @@ class Serial(SerialBase): """Platform specific - set flow state.""" if not self.hComPort: raise portNotOpenError if level: - win32file.EscapeCommFunction(self.hComPort, win32file.SETXON) + win32.EscapeCommFunction(self.hComPort, win32.SETXON) else: - win32file.EscapeCommFunction(self.hComPort, win32file.SETXOFF) + win32.EscapeCommFunction(self.hComPort, win32.SETXOFF) def outWaiting(self): """return how many characters the in the outgoing buffer""" - flags, comstat = win32file.ClearCommError(self.hComPort) + flags = win32.DWORD() + comstat = win32.COMSTAT() + if not win32.ClearCommError(self.hComPort, ctypes.byref(flags), ctypes.byref(comstat)): + raise SerialException('call to ClearCommError failed') return comstat.cbOutQue diff --git a/pyserial/serial/win32.py b/pyserial/serial/win32.py new file mode 100644 index 0000000..55dec16 --- /dev/null +++ b/pyserial/serial/win32.py @@ -0,0 +1,273 @@ +from ctypes import * +from ctypes.wintypes import HANDLE +from ctypes.wintypes import BOOL +from ctypes.wintypes import LPCWSTR +_stdcall_libraries = {} +_stdcall_libraries['kernel32'] = WinDLL('kernel32') +from ctypes.wintypes import DWORD +from ctypes.wintypes import WORD +from ctypes.wintypes import BYTE + + +class _SECURITY_ATTRIBUTES(Structure): + pass +LPSECURITY_ATTRIBUTES = POINTER(_SECURITY_ATTRIBUTES) + +CreateEventW = _stdcall_libraries['kernel32'].CreateEventW +CreateEventW.restype = HANDLE +CreateEventW.argtypes = [LPSECURITY_ATTRIBUTES, BOOL, BOOL, LPCWSTR] +CreateEvent = CreateEventW # alias +CreateFileW = _stdcall_libraries['kernel32'].CreateFileW +CreateFileW.restype = HANDLE +CreateFileW.argtypes = [LPCWSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE] +CreateFile = CreateFileW # alias + +class _OVERLAPPED(Structure): + pass +OVERLAPPED = _OVERLAPPED + +class _COMSTAT(Structure): + pass +COMSTAT = _COMSTAT + +class _DCB(Structure): + pass +DCB = _DCB + +class _COMMTIMEOUTS(Structure): + pass +COMMTIMEOUTS = _COMMTIMEOUTS + +GetLastError = _stdcall_libraries['kernel32'].GetLastError +GetLastError.restype = DWORD +GetLastError.argtypes = [] + +LPOVERLAPPED = POINTER(_OVERLAPPED) +LPDWORD = POINTER(DWORD) + +GetOverlappedResult = _stdcall_libraries['kernel32'].GetOverlappedResult +GetOverlappedResult.restype = BOOL +GetOverlappedResult.argtypes = [HANDLE, LPOVERLAPPED, LPDWORD, BOOL] + +ResetEvent = _stdcall_libraries['kernel32'].ResetEvent +ResetEvent.restype = BOOL +ResetEvent.argtypes = [HANDLE] + +LPCVOID = c_void_p + +WriteFile = _stdcall_libraries['kernel32'].WriteFile +WriteFile.restype = BOOL +WriteFile.argtypes = [HANDLE, LPCVOID, DWORD, LPDWORD, LPOVERLAPPED] + +LPVOID = c_void_p + +ReadFile = _stdcall_libraries['kernel32'].ReadFile +ReadFile.restype = BOOL +ReadFile.argtypes = [HANDLE, LPVOID, DWORD, LPDWORD, LPOVERLAPPED] + +CloseHandle = _stdcall_libraries['kernel32'].CloseHandle +CloseHandle.restype = BOOL +CloseHandle.argtypes = [HANDLE] + +ClearCommBreak = _stdcall_libraries['kernel32'].ClearCommBreak +ClearCommBreak.restype = BOOL +ClearCommBreak.argtypes = [HANDLE] + +LPCOMSTAT = POINTER(_COMSTAT) + +ClearCommError = _stdcall_libraries['kernel32'].ClearCommError +ClearCommError.restype = BOOL +ClearCommError.argtypes = [HANDLE, LPDWORD, LPCOMSTAT] + +SetupComm = _stdcall_libraries['kernel32'].SetupComm +SetupComm.restype = BOOL +SetupComm.argtypes = [HANDLE, DWORD, DWORD] + +EscapeCommFunction = _stdcall_libraries['kernel32'].EscapeCommFunction +EscapeCommFunction.restype = BOOL +EscapeCommFunction.argtypes = [HANDLE, DWORD] + +GetCommModemStatus = _stdcall_libraries['kernel32'].GetCommModemStatus +GetCommModemStatus.restype = BOOL +GetCommModemStatus.argtypes = [HANDLE, LPDWORD] + +LPDCB = POINTER(_DCB) + +GetCommState = _stdcall_libraries['kernel32'].GetCommState +GetCommState.restype = BOOL +GetCommState.argtypes = [HANDLE, LPDCB] + +LPCOMMTIMEOUTS = POINTER(_COMMTIMEOUTS) + +GetCommTimeouts = _stdcall_libraries['kernel32'].GetCommTimeouts +GetCommTimeouts.restype = BOOL +GetCommTimeouts.argtypes = [HANDLE, LPCOMMTIMEOUTS] + +PurgeComm = _stdcall_libraries['kernel32'].PurgeComm +PurgeComm.restype = BOOL +PurgeComm.argtypes = [HANDLE, DWORD] + +SetCommBreak = _stdcall_libraries['kernel32'].SetCommBreak +SetCommBreak.restype = BOOL +SetCommBreak.argtypes = [HANDLE] + +SetCommMask = _stdcall_libraries['kernel32'].SetCommMask +SetCommMask.restype = BOOL +SetCommMask.argtypes = [HANDLE, DWORD] + +SetCommState = _stdcall_libraries['kernel32'].SetCommState +SetCommState.restype = BOOL +SetCommState.argtypes = [HANDLE, LPDCB] + +SetCommTimeouts = _stdcall_libraries['kernel32'].SetCommTimeouts +SetCommTimeouts.restype = BOOL +SetCommTimeouts.argtypes = [HANDLE, LPCOMMTIMEOUTS] + +ONESTOPBIT = 0 # Variable c_int +TWOSTOPBITS = 2 # Variable c_int +ONE5STOPBITS = 1 + +NOPARITY = 0 # Variable c_int +ODDPARITY = 1 # Variable c_int +EVENPARITY = 2 # Variable c_int +MARKPARITY = 3 +SPACEPARITY = 4 + +MS_DSR_ON = 32 # Variable c_ulong +EV_RING = 256 # Variable c_int +EV_PERR = 512 # Variable c_int +EV_ERR = 128 # Variable c_int +SETXOFF = 1 # Variable c_int +EV_RXCHAR = 1 # Variable c_int +GENERIC_WRITE = 1073741824 # Variable c_long +PURGE_TXCLEAR = 4 # Variable c_int +FILE_FLAG_OVERLAPPED = 1073741824 # Variable c_int +EV_DSR = 16 # Variable c_int +MAXDWORD = 4294967295L # Variable c_uint +EV_RLSD = 32 # Variable c_int +ERROR_IO_PENDING = 997 # Variable c_long +MS_CTS_ON = 16 # Variable c_ulong +EV_EVENT1 = 2048 # Variable c_int +RTS_CONTROL_HANDSHAKE = 2 # Variable c_int +EV_RX80FULL = 1024 # Variable c_int +PURGE_RXABORT = 2 # Variable c_int +FILE_ATTRIBUTE_NORMAL = 128 # Variable c_int +PURGE_TXABORT = 1 # Variable c_int +SETXON = 2 # Variable c_int +OPEN_EXISTING = 3 # Variable c_int +RTS_CONTROL_ENABLE = 1 # Variable c_int +MS_RING_ON = 64 # Variable c_ulong +EV_TXEMPTY = 4 # Variable c_int +EV_RXFLAG = 2 # Variable c_int +DTR_CONTROL_HANDSHAKE = 2 # Variable c_int +DTR_CONTROL_ENABLE = 1 # Variable c_int +MS_RLSD_ON = 128 # Variable c_ulong +GENERIC_READ = 2147483648L # Variable c_ulong +EV_EVENT2 = 4096 # Variable c_int +EV_CTS = 8 # Variable c_int +EV_BREAK = 64 # Variable c_int +PURGE_RXCLEAR = 8 # Variable c_int +ULONG_PTR = c_ulong + +class N11_OVERLAPPED4DOLLAR_48E(Union): + pass +class N11_OVERLAPPED4DOLLAR_484DOLLAR_49E(Structure): + pass +N11_OVERLAPPED4DOLLAR_484DOLLAR_49E._fields_ = [ + ('Offset', DWORD), + ('OffsetHigh', DWORD), +] + +PVOID = c_void_p + +N11_OVERLAPPED4DOLLAR_48E._anonymous_ = ['_0'] +N11_OVERLAPPED4DOLLAR_48E._fields_ = [ + ('_0', N11_OVERLAPPED4DOLLAR_484DOLLAR_49E), + ('Pointer', PVOID), +] +_OVERLAPPED._anonymous_ = ['_0'] +_OVERLAPPED._fields_ = [ + ('Internal', ULONG_PTR), + ('InternalHigh', ULONG_PTR), + ('_0', N11_OVERLAPPED4DOLLAR_48E), + ('hEvent', HANDLE), +] +_SECURITY_ATTRIBUTES._fields_ = [ + ('nLength', DWORD), + ('lpSecurityDescriptor', LPVOID), + ('bInheritHandle', BOOL), +] +_COMSTAT._fields_ = [ + ('fCtsHold', DWORD, 1), + ('fDsrHold', DWORD, 1), + ('fRlsdHold', DWORD, 1), + ('fXoffHold', DWORD, 1), + ('fXoffSent', DWORD, 1), + ('fEof', DWORD, 1), + ('fTxim', DWORD, 1), + ('fReserved', DWORD, 25), + ('cbInQue', DWORD), + ('cbOutQue', DWORD), +] +_DCB._fields_ = [ + ('DCBlength', DWORD), + ('BaudRate', DWORD), + ('fBinary', DWORD, 1), + ('fParity', DWORD, 1), + ('fOutxCtsFlow', DWORD, 1), + ('fOutxDsrFlow', DWORD, 1), + ('fDtrControl', DWORD, 2), + ('fDsrSensitivity', DWORD, 1), + ('fTXContinueOnXoff', DWORD, 1), + ('fOutX', DWORD, 1), + ('fInX', DWORD, 1), + ('fErrorChar', DWORD, 1), + ('fNull', DWORD, 1), + ('fRtsControl', DWORD, 2), + ('fAbortOnError', DWORD, 1), + ('fDummy2', DWORD, 17), + ('wReserved', WORD), + ('XonLim', WORD), + ('XoffLim', WORD), + ('ByteSize', BYTE), + ('Parity', BYTE), + ('StopBits', BYTE), + ('XonChar', c_char), + ('XoffChar', c_char), + ('ErrorChar', c_char), + ('EofChar', c_char), + ('EvtChar', c_char), + ('wReserved1', WORD), +] +_COMMTIMEOUTS._fields_ = [ + ('ReadIntervalTimeout', DWORD), + ('ReadTotalTimeoutMultiplier', DWORD), + ('ReadTotalTimeoutConstant', DWORD), + ('WriteTotalTimeoutMultiplier', DWORD), + ('WriteTotalTimeoutConstant', DWORD), +] +__all__ = ['GetLastError', 'MS_CTS_ON', 'FILE_ATTRIBUTE_NORMAL', + 'DTR_CONTROL_ENABLE', '_COMSTAT', 'MS_RLSD_ON', + 'GetOverlappedResult', 'SETXON', 'PURGE_TXABORT', + 'PurgeComm', 'N11_OVERLAPPED4DOLLAR_48E', 'EV_RING', + 'ONESTOPBIT', 'SETXOFF', 'PURGE_RXABORT', 'GetCommState', + 'RTS_CONTROL_ENABLE', '_DCB', 'CreateEvent', + '_COMMTIMEOUTS', '_SECURITY_ATTRIBUTES', 'EV_DSR', + 'EV_PERR', 'EV_RXFLAG', 'OPEN_EXISTING', 'DCB', + 'FILE_FLAG_OVERLAPPED', 'EV_CTS', 'SetupComm', + 'LPOVERLAPPED', 'EV_TXEMPTY', 'ClearCommBreak', + 'LPSECURITY_ATTRIBUTES', 'SetCommBreak', 'SetCommTimeouts', + 'COMMTIMEOUTS', 'ODDPARITY', 'EV_RLSD', + 'GetCommModemStatus', 'EV_EVENT2', 'PURGE_TXCLEAR', + 'EV_BREAK', 'EVENPARITY', 'LPCVOID', 'COMSTAT', 'ReadFile', + 'PVOID', '_OVERLAPPED', 'WriteFile', 'GetCommTimeouts', + 'ResetEvent', 'EV_RXCHAR', 'LPCOMSTAT', 'ClearCommError', + 'ERROR_IO_PENDING', 'EscapeCommFunction', 'GENERIC_READ', + 'RTS_CONTROL_HANDSHAKE', 'OVERLAPPED', + 'DTR_CONTROL_HANDSHAKE', 'PURGE_RXCLEAR', 'GENERIC_WRITE', + 'LPDCB', 'CreateEventW', 'SetCommMask', 'EV_EVENT1', + 'SetCommState', 'LPVOID', 'CreateFileW', 'LPDWORD', + 'EV_RX80FULL', 'TWOSTOPBITS', 'LPCOMMTIMEOUTS', 'MAXDWORD', + 'MS_DSR_ON', 'MS_RING_ON', + 'N11_OVERLAPPED4DOLLAR_484DOLLAR_49E', 'EV_ERR', + 'ULONG_PTR', 'CreateFile', 'NOPARITY', 'CloseHandle'] |