<name>openHAB Add-ons :: Bundles :: KNX Binding</name>
<properties>
- <bnd.importpackage>gnu.io;version="[3.12,6)",javax.microedition.io.*;resolution:="optional",javax.usb.*;resolution:="optional",org.usb4java.*;resolution:="optional"</bnd.importpackage>
+ <bnd.importpackage>javax.microedition.io.*;resolution:="optional",javax.usb.*;resolution:="optional",org.usb4java.*;resolution:="optional"</bnd.importpackage>
</properties>
<dependencies>
<dependency>
- <groupId>com.github.calimero</groupId>
- <artifactId>calimero-core</artifactId>
- <version>2.5.1</version>
- <scope>compile</scope>
- <exclusions>
- <exclusion>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-api</artifactId>
- </exclusion>
- </exclusions>
+ <groupId>biz.aQute.bnd</groupId>
+ <artifactId>biz.aQute.bnd.annotation</artifactId>
+ <version>${bnd.version}</version>
+ <scope>provided</scope>
</dependency>
<dependency>
<groupId>com.github.calimero</groupId>
- <artifactId>calimero-device</artifactId>
+ <artifactId>calimero-core</artifactId>
<version>2.5.1</version>
<scope>compile</scope>
<exclusions>
</dependency>
<dependency>
<groupId>com.github.calimero</groupId>
- <artifactId>calimero-rxtx</artifactId>
+ <artifactId>calimero-device</artifactId>
<version>2.5.1</version>
<scope>compile</scope>
<exclusions>
<build>
<pluginManagement>
<plugins>
+ <plugin>
+ <groupId>biz.aQute.bnd</groupId>
+ <artifactId>bnd-maven-plugin</artifactId>
+ <configuration>
+ <bnd><![CDATA[${oh.bndDefaults}
+Require-Capability:
+ osgi.extender:=
+ filter:="(osgi.extender=osgi.serviceloader.processor)",
+ osgi.serviceloader:=
+ filter:="(osgi.serviceloader=tuwien.auto.calimero.serial.spi.SerialCom)";
+ cardinality:=multiple
+SPI-Provider: tuwien.auto.calimero.serial.spi.SerialCom
+SPI-Consumer: java.util.ServiceLoader#load(java.lang.Class[tuwien.auto.calimero.serial.spi.SerialCom])
+ ]]>
+ </bnd>
+ </configuration>
+ </plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-javadoc-plugin</artifactId>
*/
package org.openhab.binding.knx.internal.client;
-import java.util.Enumeration;
import java.util.concurrent.ScheduledExecutorService;
+import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.openhab.core.io.transport.serial.SerialPortIdentifier;
+import org.openhab.core.io.transport.serial.SerialPortManager;
import org.openhab.core.thing.ThingUID;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import gnu.io.CommPortIdentifier;
-import gnu.io.RXTXVersion;
import tuwien.auto.calimero.KNXException;
import tuwien.auto.calimero.link.KNXNetworkLink;
import tuwien.auto.calimero.link.KNXNetworkLinkFT12;
private final Logger logger = LoggerFactory.getLogger(SerialClient.class);
+ private final SerialPortManager serialPortManager;
private final String serialPort;
private final boolean useCemi;
public SerialClient(int autoReconnectPeriod, ThingUID thingUID, int responseTimeout, int readingPause,
int readRetriesLimit, ScheduledExecutorService knxScheduler, String serialPort, boolean useCemi,
- StatusUpdateCallback statusUpdateCallback) {
+ SerialPortManager serialPortManager, StatusUpdateCallback statusUpdateCallback) {
super(autoReconnectPeriod, thingUID, responseTimeout, readingPause, readRetriesLimit, knxScheduler,
statusUpdateCallback);
+ this.serialPortManager = serialPortManager;
this.serialPort = serialPort;
this.useCemi = useCemi;
}
@Override
protected KNXNetworkLink establishConnection() throws KNXException, InterruptedException {
try {
- RXTXVersion.getVersion();
logger.debug("Establishing connection to KNX bus through FT1.2 on serial port {}{}.", serialPort,
(useCemi ? " using CEMI" : ""));
// CEMI support by Calimero library, userful for newer serial devices like KNX RF sticks, kBerry,
final String msg = e.getMessage();
// TODO add a test for this string match; error message might change in later version of Calimero library
if ((msg != null) && (msg.startsWith(CALIMERO_ERROR_CANNOT_OPEN_PORT))) {
- StringBuilder sb = new StringBuilder("Available ports are:\n");
- Enumeration<?> portList = CommPortIdentifier.getPortIdentifiers();
- while (portList.hasMoreElements()) {
- CommPortIdentifier id = (CommPortIdentifier) portList.nextElement();
- if ((id != null) && (id.getPortType() == CommPortIdentifier.PORT_SERIAL)) {
- sb.append(id.getName());
- sb.append("\n");
- }
+ String availablePorts = serialPortManager.getIdentifiers().map(SerialPortIdentifier::getName)
+ .collect(Collectors.joining("\n"));
+ if (!availablePorts.isEmpty()) {
+ availablePorts = " Available ports are:\n" + availablePorts;
}
- sb.deleteCharAt(sb.length() - 1);
- throw new KNXException("Serial port '" + serialPort + "' could not be opened. " + sb.toString());
+ throw new KNXException("Serial port '" + serialPort + "' could not be opened." + availablePorts);
} else {
throw e;
}
--- /dev/null
+/**
+ * Copyright (c) 2010-2023 Contributors to the openHAB project
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.openhab.binding.knx.internal.client;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.eclipse.jdt.annotation.NonNullByDefault;
+import org.eclipse.jdt.annotation.Nullable;
+import org.openhab.core.io.transport.serial.PortInUseException;
+import org.openhab.core.io.transport.serial.SerialPort;
+import org.openhab.core.io.transport.serial.SerialPortIdentifier;
+import org.openhab.core.io.transport.serial.SerialPortManager;
+import org.openhab.core.io.transport.serial.UnsupportedCommOperationException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import aQute.bnd.annotation.spi.ServiceProvider;
+import tuwien.auto.calimero.KNXException;
+import tuwien.auto.calimero.serial.spi.SerialCom;
+
+/**
+ * The {@link SerialTransportAdapter} provides org.openhab.core.io.transport.serial
+ * services to the Calimero library.
+ *
+ * @ServiceProvider annotation (biz.aQute.bnd.annotation) automatically creates the file
+ * /META-INF/services/tuwien.auto.calimero.serial.spi.SerialCom
+ * to register SerialTransportAdapter to the service loader.
+ * Additional attributes for SerialTansportAdapter can be specified as well, e.g.
+ * attribute = { "position=1" }
+ * and will be part of MANIFEST.MF
+ *
+ * @author Holger Friedrich - Initial contribution
+ */
+@ServiceProvider(value = SerialCom.class)
+@NonNullByDefault
+public class SerialTransportAdapter implements SerialCom {
+ private static final int OPEN_TIMEOUT_MS = 200;
+ private static final int RECEIVE_TIMEOUT_MS = 5;
+ private static final int RECEIVE_THRESHOLD = 1024;
+ private static final int BAUDRATE = 19200;
+
+ private Logger logger = LoggerFactory.getLogger(SerialTransportAdapter.class);
+ @Nullable
+ private static SerialPortManager serialPortManager = null;
+ @Nullable
+ private SerialPort serialPort = null;
+
+ public static void setSerialPortManager(SerialPortManager serialPortManager) {
+ SerialTransportAdapter.serialPortManager = serialPortManager;
+ }
+
+ public SerialTransportAdapter() {
+ }
+
+ @Override
+ public void open(@Nullable String portId) throws IOException, KNXException {
+ if (portId == null) {
+ throw new IOException("Port not available");
+ }
+ logger = LoggerFactory.getLogger("SerialTransportAdapter:" + portId);
+
+ final @Nullable SerialPortManager tmpSerialPortManager = serialPortManager;
+ if (tmpSerialPortManager == null) {
+ throw new IOException("PortManager not available");
+ }
+ try {
+ SerialPortIdentifier portIdentifier = tmpSerialPortManager.getIdentifier(portId);
+ if (portIdentifier != null) {
+ logger.trace("Trying to open port {}", portId);
+ SerialPort serialPort = portIdentifier.open(this.getClass().getName(), OPEN_TIMEOUT_MS);
+ // apply default settings for com port, may be overwritten by caller
+ serialPort.setSerialPortParams(BAUDRATE, SerialPort.DATABITS_8, SerialPort.STOPBITS_1,
+ SerialPort.PARITY_EVEN);
+ serialPort.enableReceiveThreshold(RECEIVE_THRESHOLD);
+ serialPort.enableReceiveTimeout(RECEIVE_TIMEOUT_MS);
+ this.serialPort = serialPort;
+
+ // Notification / event listeners are available and may be used to log/trace com failures
+ // serialPort.notifyOnDataAvailable(true);
+ logger.trace("Port opened successfully");
+ } else {
+ logger.info("Port {} not available", portId);
+ throw new IOException("Port " + portId + " not available");
+ }
+ } catch (PortInUseException e) {
+ logger.info("Port {} already in use", portId);
+ throw new IOException("Port " + portId + " already in use", e);
+ } catch (UnsupportedCommOperationException e) {
+ logger.info("Port {} unsupported com operation", portId);
+ throw new IOException("Port " + portId + " unsupported com operation", e);
+ }
+ }
+
+ // SerialCom extends AutoCloseable, close() throws Exception
+ @Override
+ public void close() {
+ logger.trace("Closing serial port");
+ final @Nullable SerialPort tmpSerialPort = serialPort;
+ if (tmpSerialPort != null) {
+ tmpSerialPort.close();
+ serialPort = null;
+ }
+ }
+
+ @Override
+ public @Nullable InputStream inputStream() {
+ final @Nullable SerialPort tmpSerialPort = serialPort;
+ if (tmpSerialPort != null) {
+ try {
+ return tmpSerialPort.getInputStream();
+ } catch (IOException e) {
+ logger.info("Cannot open input stream");
+ }
+ }
+ // should not throw, create a dummy return value
+ byte buf[] = {};
+ return new ByteArrayInputStream(buf);
+ }
+
+ @Override
+ public @Nullable OutputStream outputStream() {
+ final @Nullable SerialPort tmpSerialPort = serialPort;
+ if (tmpSerialPort != null) {
+ try {
+ return tmpSerialPort.getOutputStream();
+ } catch (IOException e) {
+ logger.info("Cannot open output stream");
+ }
+ }
+ // should not throw, create a dummy return value
+ return new ByteArrayOutputStream(0);
+ }
+
+ // disable NonNullByDefault for this function, legacy interface List<String>
+ @NonNullByDefault({})
+ @Override
+ public List<String> portIdentifiers() {
+ final @Nullable SerialPortManager tmpSerialPortManager = serialPortManager;
+ if (tmpSerialPortManager == null) {
+ return Collections.emptyList();
+ }
+ return tmpSerialPortManager.getIdentifiers().map(SerialPortIdentifier::getName).collect(Collectors.toList());
+ }
+
+ @Override
+ public int baudRate() throws IOException {
+ final @Nullable SerialPort tmpSerialPort = serialPort;
+ if (tmpSerialPort == null) {
+ throw new IOException("Port not available");
+ }
+ return tmpSerialPort.getBaudRate();
+ }
+
+ @Override
+ public void setSerialPortParams(final int baudrate, final int databits, @Nullable StopBits stopbits,
+ @Nullable Parity parity) throws IOException {
+ final @Nullable SerialPort tmpSerialPort = serialPort;
+ if (tmpSerialPort == null) {
+ throw new IOException("Port not available");
+ }
+ if ((stopbits == null) || (parity == null)) {
+ throw new IOException("Invalid parameters");
+ }
+ try {
+ tmpSerialPort.setSerialPortParams(baudrate, databits, stopbits.value(), parity.value());
+ } catch (final UnsupportedCommOperationException e) {
+ throw new IOException("Setting serial port parameters for " + tmpSerialPort.getName() + " failed", e);
+ }
+ }
+
+ @Override
+ public void setFlowControlMode(@Nullable FlowControl mode) throws IOException {
+ final @Nullable SerialPort tmpSerialPort = serialPort;
+ if (tmpSerialPort == null) {
+ throw new IOException("Port not available");
+ }
+ if (mode == null) {
+ throw new IOException("Invalid parameters");
+ }
+ if (mode == FlowControl.None) {
+ try {
+ tmpSerialPort.setFlowControlMode(SerialPort.FLOWCONTROL_NONE);
+ } catch (final UnsupportedCommOperationException e) {
+ throw new IOException("Setting flow control parameters for " + tmpSerialPort.getName() + " failed", e);
+ }
+ } else {
+ logger.warn("Unknown FlowControl mode {}", mode);
+ throw new IOException("Invalid flow mode");
+ }
+ }
+}
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
+import org.openhab.binding.knx.internal.client.SerialTransportAdapter;
import org.openhab.binding.knx.internal.handler.DeviceThingHandler;
import org.openhab.binding.knx.internal.handler.IPBridgeThingHandler;
import org.openhab.binding.knx.internal.handler.SerialBridgeThingHandler;
import org.openhab.core.config.core.Configuration;
import org.openhab.core.i18n.LocaleProvider;
import org.openhab.core.i18n.TranslationProvider;
+import org.openhab.core.io.transport.serial.SerialPortManager;
import org.openhab.core.net.NetworkAddressService;
import org.openhab.core.thing.Bridge;
import org.openhab.core.thing.Thing;
@Nullable
private NetworkAddressService networkAddressService;
+ private final SerialPortManager serialPortManager;
@Activate
public KNXHandlerFactory(final @Reference TranslationProvider translationProvider,
- final @Reference LocaleProvider localeProvider) {
+ final @Reference LocaleProvider localeProvider, final @Reference SerialPortManager serialPortManager) {
KNXTranslationProvider.I18N.setProvider(localeProvider, translationProvider);
+ this.serialPortManager = serialPortManager;
+ SerialTransportAdapter.setSerialPortManager(serialPortManager);
}
@Override
if (thing.getThingTypeUID().equals(THING_TYPE_IP_BRIDGE)) {
return new IPBridgeThingHandler((Bridge) thing, networkAddressService);
} else if (thing.getThingTypeUID().equals(THING_TYPE_SERIAL_BRIDGE)) {
- return new SerialBridgeThingHandler((Bridge) thing);
+ return new SerialBridgeThingHandler((Bridge) thing, serialPortManager);
} else if (thing.getThingTypeUID().equals(THING_TYPE_DEVICE)) {
return new DeviceThingHandler(thing);
}
projects / openhab-addons.git / commitdiff