| #!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() |