Support for custom refresh intervals per item.

Author: splatch

README.md

@@ -19,8 +19,9 @@ e.g.
 The following keys are available:
 
 * `device` is the instance ID (integer) of the device as configured on your local network (it is *not* the IP address of the device)
-* `type` is the object type. Available types are  `analogInput`, `analogOutput`, `analogValue`, `binaryInput`, `binaryOutput`, `binaryValue`
+* `type` is the object type. Available types are  `analogInput`, `analogOutput`, `analogValue`, `binaryInput`, `binaryOutput`, `binaryValue`, `multiStateInput`, `multiStateOutput`, `multiStateValue`
 * `id`is the instance ID (integer) of the object you want to tie to this openHAB item
+* `refreshInterval` (optional) periods between property read requests
 
 All these properties are coming from bacnet standard. If you don't know yet device id or available properties please contact your device manufacturer and ask for appropriate documentation. Source code contains class named `org.openhab.binding.bacnet.internal.util.DiscoveryMain` which drops all devices and available properties.
 
@@ -31,8 +32,9 @@ This binding have few basic options. Bold items are mandatory
 * port (default 47808)
 * localNetworkNumber (default 0) - bacnet network number
 * localDeviceId (default 1339) - device id used to identify openhab in bacnet network
+* refreshInterval (default 30000) - milliseconds between polling values for configured items
+* discoveryTimeout (default 30000) - specifies how many milliseconds openhab will listen for whois responses from devices. *Note* binding start will be delayed for `discoveryTimeout`.
 
-Currently binding will fetch all items every 30 seconds.
 
 ## How does it work?
 

src/main/java/org/openhab/binding/bacnet/BacNetBindingProvider.java

@@ -17,7 +17,7 @@
 public interface BacNetBindingProvider extends BindingProvider {
     public BacNetBindingConfig configForItemName(String itemName);
 
-    public BacNetBindingConfig configForEndpoint(int deviceId, Type type, int id);
+    public BacNetBindingConfig configForProperty(int deviceId, Type type, int id);
 
     public Collection<BacNetBindingConfig> allConfigs();
 

src/main/java/org/openhab/binding/bacnet/internal/BacNetBinding.java

@@ -4,16 +4,21 @@
 import java.util.Dictionary;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import org.code_house.bacnet4j.wrapper.api.BacNetClient;
-import org.code_house.bacnet4j.wrapper.api.BacNetClientException;
 import org.code_house.bacnet4j.wrapper.api.Device;
 import org.code_house.bacnet4j.wrapper.api.DeviceDiscoveryListener;
 import org.code_house.bacnet4j.wrapper.api.JavaToBacNetConverter;
 import org.code_house.bacnet4j.wrapper.api.Property;
 import org.code_house.bacnet4j.wrapper.ip.BacNetIpClient;
 import org.openhab.binding.bacnet.BacNetBindingProvider;
+import org.openhab.binding.bacnet.internal.queue.ReadPropertyTask;
+import org.openhab.binding.bacnet.internal.queue.WritePropertyTask;
 import org.openhab.core.binding.AbstractActiveBinding;
 import org.openhab.core.items.Item;
 import org.openhab.core.library.types.StringType;
@@ -30,16 +35,28 @@
 import com.serotonin.bacnet4j.type.Encodable;
 
 public class BacNetBinding extends AbstractActiveBinding<BacNetBindingProvider>
-        implements ManagedService, DeviceDiscoveryListener {
+        implements ManagedService, DeviceDiscoveryListener, PropertyValueReceiver<Encodable> {
     static final Logger logger = LoggerFactory.getLogger(BacNetBinding.class);
 
+    private static final Long DEFAULT_REFRESH_INTERVAL = 30000L;
     private static final Integer DEFAULT_LOCAL_DEVICE_ID = 1339;
+    private static final Long DEFAULT_DISCOVERY_TIMEOUT = 30000L;
+
+    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {
+        @Override
+        public Thread newThread(Runnable r) {
+            return new Thread(r, "bacnet-binding-executor");
+        }
+    });
+
+    private final AtomicBoolean initialized = new AtomicBoolean(false);
 
     private Map<Integer, Device> deviceMap = Collections.synchronizedMap(new HashMap<Integer, Device>());
     private IpNetworkBuilder networkConfigurationBuilder;
     private BacNetClient client;
 
     private Integer localDeviceId = DEFAULT_LOCAL_DEVICE_ID;
+    private Long refreshInterval = DEFAULT_REFRESH_INTERVAL;
 
     @Override
     protected String getName() {
@@ -54,12 +71,14 @@ public void activate() {
 
     @Override
     public void deactivate() {
-        super.deactivate();
         logger.debug("Bacnet binding is going down");
         if (client != null) {
+            scheduler.shutdown();
             client.stop();
             client = null;
+            initialized.set(false);
         }
+        super.deactivate();
     }
 
     @Override
@@ -75,19 +94,17 @@ public void internalReceiveCommand(String itemName, Command command) {
     private void performUpdate(final String itemName, final Type newValue) {
         final BacNetBindingConfig config = configForItemName(itemName);
         if (config != null) {
-            Property endpoint = deviceEndpointForConfig(config);
-            if (endpoint != null) {
-                try {
-                    client.setPropertyValue(endpoint, newValue, new JavaToBacNetConverter<Type>() {
-                        @Override
-                        public Encodable toBacNet(Type java) {
-                            return BacNetValueConverter.openHabTypeToBacNetValue(config.type.getBacNetType(), newValue);
-                        }
-                    });
-                } catch (BacNetClientException e) {
-                    logger.error("Could not set value {} for property {} for item {} (bacnet {}:{})", newValue,
-                            endpoint, config.itemName, e);
-                }
+            Property property = devicePropertyForConfig(config);
+            if (property != null) {
+                scheduler.execute(
+                        new WritePropertyTask<Type>(client, property, newValue, new JavaToBacNetConverter<Type>() {
+                            @Override
+                            public Encodable toBacNet(Type java) {
+                                return BacNetValueConverter.openHabTypeToBacNetValue(config.type.getBacNetType(),
+                                        newValue);
+                            }
+                        }));
+                logger.info("Submited task to write {} value {} for item {}", property, newValue, itemName);
             }
         }
     }
@@ -102,29 +119,27 @@ public void removeBindingProvider(BacNetBindingProvider bindingProvider) {
 
     @Override
     protected void execute() {
-        for (BacNetBindingProvider provider : providers) {
-            for (BacNetBindingConfig config : provider.allConfigs()) {
-                Property property = deviceEndpointForConfig(config);
-                if (property != null) {
-                    try {
-                        update(property);
-                    } catch (BacNetClientException e) {
-                        logger.error("Could not fetch property {} for item {} from bacnet", property, config.itemName,
-                                e);
-                    }
-                    try {
-                        Thread.sleep(100);
-                    } catch (InterruptedException e) {
-                        logger.warn("Read task interrupted", e);
+        if (!initialized.get()) {
+            logger.trace("Creating scheduled tasks to read bacnet properties");
+            for (BacNetBindingProvider provider : providers) {
+                for (BacNetBindingConfig config : provider.allConfigs()) {
+                    long refreshInterval = config.refreshInterval != 0 ? config.refreshInterval : getRefreshInterval();
+                    Property property = devicePropertyForConfig(config);
+                    if (property != null) {
+                        scheduler.scheduleAtFixedRate(new ReadPropertyTask(client, property, this), refreshInterval,
+                                refreshInterval, TimeUnit.MILLISECONDS);
+                        logger.debug("Scheduled read property task to fetch item {} value from {} every {}ms",
+                                config.itemName, property, refreshInterval);
                     }
                 }
             }
+            initialized.set(true);
         }
     }
 
     @Override
     protected long getRefreshInterval() {
-        return TimeUnit.SECONDS.toMillis(150);
+        return refreshInterval;
     }
 
     @Override
@@ -154,39 +169,41 @@ public void updated(Dictionary<String, ?> properties) throws ConfigurationExcept
             this.localDeviceId = Integer.parseInt((String) properties.get("localDeviceId"));
         } else {
             if (this.localDeviceId != DEFAULT_LOCAL_DEVICE_ID) {
-                localDeviceId = DEFAULT_LOCAL_DEVICE_ID; // reset to default from previous value
+                this.localDeviceId = DEFAULT_LOCAL_DEVICE_ID; // reset to default from previous value
             }
         }
 
+        if (properties.get("refreshInterval") != null) {
+            this.refreshInterval = Long.parseLong((String) properties.get("refreshInterval"));
+        } else {
+            if (this.refreshInterval != DEFAULT_REFRESH_INTERVAL) {
+                this.refreshInterval = DEFAULT_REFRESH_INTERVAL; // reset to default from previous value
+            }
+        }
+
+        final long discoveryTimeout;
+        if (properties.get("discoveryTimeout") != null) {
+            discoveryTimeout = Long.parseLong((String) properties.get("discoveryTimeout"));
+        } else {
+            discoveryTimeout = DEFAULT_DISCOVERY_TIMEOUT;
+        }
+
         client = new BacNetIpClient(networkConfigurationBuilder.build(), localDeviceId);
         client.start();
-        setProperlyConfigured(true);
 
+        // start discovery in new thread so it will not delay config admin thread
         new Thread(new Runnable() {
             @Override
             public void run() {
-                client.discoverDevices(BacNetBinding.this, 5000);
+                client.discoverDevices(BacNetBinding.this, discoveryTimeout);
+
+                // upper call blocks thread for discoveryTimeout ms, thus we are safe to set
+                // properly configured here - all known devices should be discovered already
+                setProperlyConfigured(true);
             }
         }).start();
     }
 
-    protected void update(Property property) {
-        if (client == null) {
-            logger.error("Ignoring update request for property {}, client is not ready yet", property);
-            return;
-        }
-        Encodable value = client.getPropertyValue(property, new BypassConverter());
-        State state = UnDefType.UNDEF;
-        BacNetBindingConfig config = configForEndpoint(property);
-        if (config == null || value == null) {
-            return;
-        }
-
-        state = this.createState(config.itemType, value);
-        eventPublisher.postUpdate(config.itemName, state);
-        logger.debug("Updating item {} to value {} throught property {}", config.itemName, value, property);
-    }
-
     private State createState(Class<? extends Item> type, Encodable value) {
         try {
             return BacNetValueConverter.bacNetValueToOpenHabState(type, value);
@@ -196,10 +213,13 @@ private State createState(Class<? extends Item> type, Encodable value) {
         }
     }
 
-    private Property deviceEndpointForConfig(BacNetBindingConfig config) {
+    private Property devicePropertyForConfig(BacNetBindingConfig config) {
         Device device = deviceMap.get(config.deviceId);
         if (device != null) {
             return new Property(device, config.id, config.type);
+        } else {
+            logger.warn("Could not find property {}.{}.{} for item {} cause device was not discovered", config.deviceId,
+                    config.type.name(), config.id, config.itemName);
         }
         return null;
     }
@@ -214,9 +234,9 @@ private BacNetBindingConfig configForItemName(String itemName) {
         return null;
     }
 
-    private BacNetBindingConfig configForEndpoint(Property property) {
+    private BacNetBindingConfig configForProperty(Property property) {
         for (BacNetBindingProvider provider : providers) {
-            BacNetBindingConfig config = provider.configForEndpoint(property.getDevice().getInstanceNumber(),
+            BacNetBindingConfig config = provider.configForProperty(property.getDevice().getInstanceNumber(),
                     property.getType(), property.getId());
             if (config != null) {
                 return config;
@@ -230,4 +250,18 @@ public void deviceDiscovered(Device device) {
         logger.info("Discovered device " + device);
         deviceMap.put(device.getInstanceNumber(), device);
     }
+
+    @Override
+    public void receiveProperty(Property property, Encodable value) {
+        State state = UnDefType.UNDEF;
+        BacNetBindingConfig config = configForProperty(property);
+        if (config == null || value == null) {
+            return;
+        }
+
+        state = this.createState(config.itemType, value);
+        eventPublisher.postUpdate(config.itemName, state);
+        logger.debug("Updating item {} to value {} throught property {}", config.itemName, value, property);
+    }
+
 }

src/main/java/org/openhab/binding/bacnet/internal/BacNetBindingConfig.java

@@ -16,6 +16,7 @@ public class BacNetBindingConfig implements BindingConfig {
     public final Integer deviceId;
     public final Type type;
     public final Integer id;
+    public final long refreshInterval;
 
     private static final Pattern CONFIG_PATTERN = Pattern.compile("^([A-z]+=[^,]+(,|$))+");
 
@@ -26,13 +27,14 @@ static BacNetBindingConfig parseBindingConfig(String itemName, Class<? extends I
             throw new BindingConfigParseException(
                     "Invalid BacNet config: '" + configString + "'. Expected key1=value1,key2=value2");
         }
-        HashMap<String, String> values = new HashMap<String, String>();
+
+        Map<String, String> values = new HashMap<String, String>();
         for (String item : configString.split(",")) {
             String[] parts = item.split("=");
             if (parts.length != 2) {
                 throw new BindingConfigParseException("Expected key=value in BacNet config");
             }
-            values.put(parts[0], parts[1]);
+            values.put(parts[0].trim(), parts[1].trim());
         }
         return new BacNetBindingConfig(itemName, itemType, values);
     }
@@ -54,6 +56,12 @@ public BacNetBindingConfig(String itemName, Class<? extends Item> itemType, Map<
         this.type = parseObjectTypeName(type);
         this.id = Integer.parseInt(id);
 
+        if (values.containsKey("refreshInterval")) {
+            this.refreshInterval = Long.parseLong(values.get("refreshInterval"));
+        } else {
+            this.refreshInterval = 0;
+        }
+
     }
 
     private Type parseObjectTypeName(String name) {

src/main/java/org/openhab/binding/bacnet/internal/BacNetGenericBindingProvider.java

@@ -58,7 +58,7 @@ public Collection<BacNetBindingConfig> allConfigs() {
     }
 
     @Override
-    public BacNetBindingConfig configForEndpoint(int deviceId, Type type, int id) {
+    public BacNetBindingConfig configForProperty(int deviceId, Type type, int id) {
         for (BindingConfig bindingConfig : bindingConfigs.values()) {
             BacNetBindingConfig config = (BacNetBindingConfig) bindingConfig;
             if (config.deviceId == deviceId && config.type == type && config.id == id) {

src/main/java/org/openhab/binding/bacnet/internal/PropertyValueReceiver.java

@@ -0,0 +1,14 @@
+package org.openhab.binding.bacnet.internal;
+
+import org.code_house.bacnet4j.wrapper.api.Property;
+
+/**
+ *
+ *
+ * @param <T> Base type of received values.
+ */
+public interface PropertyValueReceiver<T> {
+
+    void receiveProperty(Property property, T value);
+
+}

src/main/java/org/openhab/binding/bacnet/internal/queue/ReadPropertyTask.java

@@ -0,0 +1,30 @@
+package org.openhab.binding.bacnet.internal.queue;
+
+import org.code_house.bacnet4j.wrapper.api.BacNetClient;
+import org.code_house.bacnet4j.wrapper.api.Property;
+import org.openhab.binding.bacnet.internal.BypassConverter;
+import org.openhab.binding.bacnet.internal.PropertyValueReceiver;
+
+import com.serotonin.bacnet4j.type.Encodable;
+
+public class ReadPropertyTask implements Runnable {
+
+    private final BacNetClient client;
+    private final Property property;
+    private final PropertyValueReceiver<Encodable> receiver;
+
+    public ReadPropertyTask(BacNetClient client, Property property, PropertyValueReceiver<Encodable> receiver) {
+        this.client = client;
+        this.property = property;
+        this.receiver = receiver;
+
+    }
+
+    @Override
+    public void run() {
+        Encodable value = client.getPropertyValue(property, new BypassConverter());
+        receiver.receiveProperty(property, value);
+
+    }
+
+}

src/main/java/org/openhab/binding/bacnet/internal/queue/WritePropertyTask.java

@@ -0,0 +1,36 @@
+package org.openhab.binding.bacnet.internal.queue;
+
+import org.code_house.bacnet4j.wrapper.api.BacNetClient;
+import org.code_house.bacnet4j.wrapper.api.BacNetClientException;
+import org.code_house.bacnet4j.wrapper.api.JavaToBacNetConverter;
+import org.code_house.bacnet4j.wrapper.api.Property;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class WritePropertyTask<T> implements Runnable {
+
+    private final Logger logger = LoggerFactory.getLogger(WritePropertyTask.class);
+
+    private final BacNetClient client;
+    private final Property property;
+    private final T value;
+    private final JavaToBacNetConverter<T> converter;
+
+    public WritePropertyTask(BacNetClient client, Property property, T value, JavaToBacNetConverter<T> converter) {
+        this.client = client;
+        this.property = property;
+        this.value = value;
+        this.converter = converter;
+
+    }
+
+    @Override
+    public void run() {
+        try {
+            client.setPropertyValue(property, value, converter);
+        } catch (BacNetClientException e) {
+            logger.error("Could not set value {} for property {}", value, property, e);
+        }
+    }
+
+}