| #!jython |
| # |
| # Backend Jython with JavaComm |
| # |
| # This file is part of pySerial. https://github.com/pyserial/pyserial |
| # (C) 2002-2015 Chris Liechti <cliechti@gmx.net> |
| # |
| # SPDX-License-Identifier: BSD-3-Clause |
| |
| from __future__ import absolute_import |
| |
| from serial.serialutil import * |
| |
| |
| def my_import(name): |
| mod = __import__(name) |
| components = name.split('.') |
| for comp in components[1:]: |
| mod = getattr(mod, comp) |
| return mod |
| |
| |
| def detect_java_comm(names): |
| """try given list of modules and return that imports""" |
| for name in names: |
| try: |
| mod = my_import(name) |
| mod.SerialPort |
| return mod |
| except (ImportError, AttributeError): |
| pass |
| raise ImportError("No Java Communications API implementation found") |
| |
| |
| # Java Communications API implementations |
| # http://mho.republika.pl/java/comm/ |
| |
| comm = detect_java_comm([ |
| 'javax.comm', # Sun/IBM |
| 'gnu.io', # RXTX |
| ]) |
| |
| |
| def device(portnumber): |
| """Turn a port number into a device name""" |
| enum = comm.CommPortIdentifier.getPortIdentifiers() |
| ports = [] |
| while enum.hasMoreElements(): |
| el = enum.nextElement() |
| if el.getPortType() == comm.CommPortIdentifier.PORT_SERIAL: |
| ports.append(el) |
| return ports[portnumber].getName() |
| |
| |
| class Serial(SerialBase): |
| """\ |
| Serial port class, implemented with Java Communications API and |
| thus usable with jython and the appropriate java extension. |
| """ |
| |
| def open(self): |
| """\ |
| Open port with current settings. This may throw a SerialException |
| if the port cannot be opened. |
| """ |
| if self._port is None: |
| raise SerialException("Port must be configured before it can be used.") |
| if self.is_open: |
| raise SerialException("Port is already open.") |
| if type(self._port) == type(''): # strings are taken directly |
| portId = comm.CommPortIdentifier.getPortIdentifier(self._port) |
| else: |
| portId = comm.CommPortIdentifier.getPortIdentifier(device(self._port)) # numbers are transformed to a comport id obj |
| try: |
| self.sPort = portId.open("python serial module", 10) |
| except Exception as msg: |
| self.sPort = None |
| raise SerialException("Could not open port: %s" % msg) |
| self._reconfigurePort() |
| self._instream = self.sPort.getInputStream() |
| self._outstream = self.sPort.getOutputStream() |
| self.is_open = True |
| |
| def _reconfigurePort(self): |
| """Set communication parameters on opened port.""" |
| if not self.sPort: |
| raise SerialException("Can only operate on a valid port handle") |
| |
| self.sPort.enableReceiveTimeout(30) |
| if self._bytesize == FIVEBITS: |
| jdatabits = comm.SerialPort.DATABITS_5 |
| elif self._bytesize == SIXBITS: |
| jdatabits = comm.SerialPort.DATABITS_6 |
| elif self._bytesize == SEVENBITS: |
| jdatabits = comm.SerialPort.DATABITS_7 |
| elif self._bytesize == EIGHTBITS: |
| jdatabits = comm.SerialPort.DATABITS_8 |
| else: |
| raise ValueError("unsupported bytesize: %r" % self._bytesize) |
| |
| if self._stopbits == STOPBITS_ONE: |
| jstopbits = comm.SerialPort.STOPBITS_1 |
| elif self._stopbits == STOPBITS_ONE_POINT_FIVE: |
| jstopbits = comm.SerialPort.STOPBITS_1_5 |
| elif self._stopbits == STOPBITS_TWO: |
| jstopbits = comm.SerialPort.STOPBITS_2 |
| else: |
| raise ValueError("unsupported number of stopbits: %r" % self._stopbits) |
| |
| if self._parity == PARITY_NONE: |
| jparity = comm.SerialPort.PARITY_NONE |
| elif self._parity == PARITY_EVEN: |
| jparity = comm.SerialPort.PARITY_EVEN |
| elif self._parity == PARITY_ODD: |
| jparity = comm.SerialPort.PARITY_ODD |
| elif self._parity == PARITY_MARK: |
| jparity = comm.SerialPort.PARITY_MARK |
| elif self._parity == PARITY_SPACE: |
| jparity = comm.SerialPort.PARITY_SPACE |
| else: |
| raise ValueError("unsupported parity type: %r" % self._parity) |
| |
| jflowin = jflowout = 0 |
| if self._rtscts: |
| jflowin |= comm.SerialPort.FLOWCONTROL_RTSCTS_IN |
| jflowout |= comm.SerialPort.FLOWCONTROL_RTSCTS_OUT |
| if self._xonxoff: |
| jflowin |= comm.SerialPort.FLOWCONTROL_XONXOFF_IN |
| jflowout |= comm.SerialPort.FLOWCONTROL_XONXOFF_OUT |
| |
| self.sPort.setSerialPortParams(self._baudrate, jdatabits, jstopbits, jparity) |
| self.sPort.setFlowControlMode(jflowin | jflowout) |
| |
| if self._timeout >= 0: |
| self.sPort.enableReceiveTimeout(int(self._timeout*1000)) |
| else: |
| self.sPort.disableReceiveTimeout() |
| |
| def close(self): |
| """Close port""" |
| if self.is_open: |
| if self.sPort: |
| self._instream.close() |
| self._outstream.close() |
| self.sPort.close() |
| self.sPort = None |
| self.is_open = False |
| |
| # - - - - - - - - - - - - - - - - - - - - - - - - |
| |
| @property |
| def in_waiting(self): |
| """Return the number of characters currently in the input buffer.""" |
| if not self.sPort: |
| raise PortNotOpenError() |
| return self._instream.available() |
| |
| 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.sPort: |
| raise PortNotOpenError() |
| read = bytearray() |
| if size > 0: |
| while len(read) < size: |
| x = self._instream.read() |
| if x == -1: |
| if self.timeout >= 0: |
| break |
| else: |
| read.append(x) |
| return bytes(read) |
| |
| def write(self, data): |
| """Output the given string over the serial port.""" |
| if not self.sPort: |
| raise PortNotOpenError() |
| if not isinstance(data, (bytes, bytearray)): |
| raise TypeError('expected %s or bytearray, got %s' % (bytes, type(data))) |
| self._outstream.write(data) |
| return len(data) |
| |
| def reset_input_buffer(self): |
| """Clear input buffer, discarding all that is in the buffer.""" |
| if not self.sPort: |
| raise PortNotOpenError() |
| self._instream.skip(self._instream.available()) |
| |
| def reset_output_buffer(self): |
| """\ |
| Clear output buffer, aborting the current output and |
| discarding all that is in the buffer. |
| """ |
| if not self.sPort: |
| raise PortNotOpenError() |
| self._outstream.flush() |
| |
| def send_break(self, duration=0.25): |
| """Send break condition. Timed, returns to idle state after given duration.""" |
| if not self.sPort: |
| raise PortNotOpenError() |
| self.sPort.sendBreak(duration*1000.0) |
| |
| def _update_break_state(self): |
| """Set break: Controls TXD. When active, to transmitting is possible.""" |
| if self.fd is None: |
| raise PortNotOpenError() |
| raise SerialException("The _update_break_state function is not implemented in java.") |
| |
| def _update_rts_state(self): |
| """Set terminal status line: Request To Send""" |
| if not self.sPort: |
| raise PortNotOpenError() |
| self.sPort.setRTS(self._rts_state) |
| |
| def _update_dtr_state(self): |
| """Set terminal status line: Data Terminal Ready""" |
| if not self.sPort: |
| raise PortNotOpenError() |
| self.sPort.setDTR(self._dtr_state) |
| |
| @property |
| def cts(self): |
| """Read terminal status line: Clear To Send""" |
| if not self.sPort: |
| raise PortNotOpenError() |
| self.sPort.isCTS() |
| |
| @property |
| def dsr(self): |
| """Read terminal status line: Data Set Ready""" |
| if not self.sPort: |
| raise PortNotOpenError() |
| self.sPort.isDSR() |
| |
| @property |
| def ri(self): |
| """Read terminal status line: Ring Indicator""" |
| if not self.sPort: |
| raise PortNotOpenError() |
| self.sPort.isRI() |
| |
| @property |
| def cd(self): |
| """Read terminal status line: Carrier Detect""" |
| if not self.sPort: |
| raise PortNotOpenError() |
| self.sPort.isCD() |