zWave - Dimmer integration

front/src/actions/device.js

@@ -39,11 +39,9 @@ function createActions(store) {
     },
     async updateValue(state, device, deviceFeature, roomIndex, deviceIndex, deviceFeatureIndex, value, oldValue) {
       actions.updateLocalValue(state, roomIndex, deviceIndex, deviceFeatureIndex, value);
-      if (deviceFeature.category === 'light' && deviceFeature.type === 'binary') {
-        await state.httpClient.post(`/api/v1/device_feature/${deviceFeature.selector}/value`, {
-          value
-        });
-      }
+      await state.httpClient.post(`/api/v1/device_feature/${deviceFeature.selector}/value`, {
+        value
+      });
     },
     updateLocalValue(state, roomIndex, deviceIndex, deviceFeatureIndex, value) {
       // create a new immutable state
@@ -56,6 +54,9 @@ function createActions(store) {
                   [deviceFeatureIndex]: {
                     lastValue: {
                       $set: value
+                    },
+                    lastValue_changed: {
+                      $set: new Date()
                     }
                   }
                 }

front/src/components/boxs/device-in-room/DeviceRow.jsx

@@ -1,6 +1,6 @@
 import BinaryDeviceFeature from './device-features/BinaryDeviceFeature';
 import SensorDeviceFeature from './device-features/SensorDeviceFeature';
-// import MultilevelDeviceFeature from './device-features/MultiLevelDeviceFeature';
+import MultilevelDeviceFeature from './device-features/MultiLevelDeviceFeature';
 
 const DeviceRow = ({ children, ...props }) => {
   // if device is a sensor, we display the sensor deviceFeature
@@ -24,6 +24,21 @@ const DeviceRow = ({ children, ...props }) => {
       />
     );
   }
+
+  if (props.deviceFeature.type === 'dimmer') {
+    return (
+      <MultilevelDeviceFeature
+        x={props.x}
+        y={props.y}
+        device={props.device}
+        deviceFeature={props.deviceFeature}
+        roomIndex={props.roomIndex}
+        deviceIndex={props.deviceIndex}
+        deviceFeatureIndex={props.deviceFeatureIndex}
+        updateValue={props.updateValue}
+      />
+    );
+  }
   // if not, we return nothing
   return null;
 };

front/src/components/boxs/device-in-room/device-features/MultiLevelDeviceFeature.jsx

@@ -3,11 +3,13 @@ import { Text } from 'preact-i18n';
 const MultiLevelDeviceType = ({ children, ...props }) => {
   function updateValue(e) {
     props.updateValue(
+      props.x,
+      props.y,
+      props.device,
       props.deviceFeature,
-      props.roomIndex,
+      props.deviceIndex,
       props.deviceFeatureIndex,
-      e.target.value,
-      props.deviceFeature.lastValue
+      e.target.value
     );
   }
 
@@ -33,10 +35,10 @@ const MultiLevelDeviceType = ({ children, ...props }) => {
               minHeight: '30px'
             }}
             type="range"
-            value={props.deviceFeature.lastValue}
+            value={props.deviceFeature.last_value}
             onChange={updateValue}
             class="form-control custom-range"
-            step={(props.deviceFeature.max - props.deviceFeature.min) / 100}
+            step={props.deviceFeature.step}
             min={props.deviceFeature.min}
             max={props.deviceFeature.max}
           />

server/services/zwave/lib/comClass/defaultCommandClass.js

@@ -0,0 +1,83 @@
+const { transformValue, normalizeValue } = require('../utils/valueBinders');
+
+const DefaultCommandClass = function DefaultCommandClass() {};
+
+DefaultCommandClass.prototype = {
+  /**
+   * @description Get the command class ID.
+   *
+   * @returns {number} - Command Class ID.
+   *
+   * @example commandClass.getId();
+   */
+  getId: function getId() {
+    return -1;
+  },
+  /**
+   * @description Get the value following a value changed event.
+   *
+   * @param {Object} node - The node the value changed occurs.
+   * @param {Object} valueChanged - The value changed.
+   *
+   * @returns {Object} - A zWave value.
+   *
+   * @example
+   *     const changedValue = comClass.getChangedValue(node, value);
+   */
+  getChangedValue: function getChangedValue(node, valueChanged) {
+    return valueChanged;
+  },
+  /**
+   * @description Transform a value according to the Command Class.
+   *
+   * @param {Object} node - Node of the value.
+   * @param {number} comClass - Command Class Id of the value.
+   * @param {number} index - Index of the value.
+   * @param {any} value - Value to transform.
+   *
+   * @returns {any} The transformed value.
+   *
+   * @example comClass.getTransformedValue(node, 110, 0, 50);
+   */
+  getTransformedValue: function getTransformedValue(node, comClass, index, value) {
+    return transformValue(node.classes[comClass][index].type, value);
+  },
+  /**
+   * @description Normalize a value according to the Command Class.
+   *
+   * @param {Object} node - Node of the value.
+   * @param {number} comClass - Command Class Id of the value.
+   * @param {number} index - Index of the value.
+   * @param {any} value - Value to transform.
+   *
+   * @returns {any} The normalized value.
+   *
+   * @example comClass.getNormalizedValue(node, 110, 0, 50);
+   */
+  getNormalizedValue: function getNormalizedValue(node, comClass, index, value) {
+    return normalizeValue(node.classes[comClass][index].type, value);
+  },
+  /**
+   * @description Get the Min/Max values for a given value.
+   *
+   * @param {Object} node - Node to get the min/max from.
+   * @param {number} comClassId - Command Class Id to get the min/max.
+   * @param {number} index - Index of the value to get the min/max.
+   *
+   * @returns {Object} Returns min and max values for a given value.
+   *
+   * @example const {min, max, step} = commClass.getMinMax(node, comClassId, index);
+   */
+  getMinMax: function getMinMax(node, comClassId, index) {
+    return {
+      min: node.classes[comClassId][index].min,
+      max: node.classes[comClassId][index].max,
+      step: 1,
+    };
+  },
+};
+
+module.exports = {
+  instance: new DefaultCommandClass(),
+  DefaultCommandClass,
+};

server/services/zwave/lib/comClass/factory.js

@@ -0,0 +1,27 @@
+const defaultCommandClass = require('./defaultCommandClass').instance;
+const switchMultilevelCommandClass = require('./switchMultilevelCommandClass').instance;
+
+const commandClasses = {};
+commandClasses[switchMultilevelCommandClass.getId()] = switchMultilevelCommandClass;
+
+const commandClassKnownIdList = Object.keys(commandClasses).map((comClass) => parseInt(comClass, 10));
+
+/**
+ * @description Get the command class corresponding to comClass.
+ *
+ * @param {number} comClass - Command Class Id.
+ *
+ * @returns {Object} The command class.
+ * @example getCommandClass(0x38);
+ */
+function getCommandClass(comClass) {
+  if (commandClassKnownIdList.indexOf(comClass) === -1) {
+    return defaultCommandClass;
+  }
+
+  return commandClasses[comClass];
+}
+
+module.exports = {
+  getCommandClass,
+};

server/services/zwave/lib/comClass/switchMultilevelCommandClass.js

@@ -0,0 +1,119 @@
+const { DefaultCommandClass } = require('./defaultCommandClass');
+const logger = require('../../../../utils/logger');
+const { COMMAND_CLASSES, INDEXES } = require('../constants');
+
+const SwitchMultilevelCommandClass = function SwitchMultilevelCommandClass() {
+  DefaultCommandClass.call(this);
+};
+SwitchMultilevelCommandClass.prototype = Object.create(DefaultCommandClass.prototype);
+Object.defineProperty(SwitchMultilevelCommandClass.prototype, 'constructor', {
+  value: SwitchMultilevelCommandClass,
+  enumerable: false,
+  writable: true,
+});
+
+/**
+ * @description Test if provided comClass support V4.
+ *
+ * @param {Object} comClass - The comClass zWave object.
+ *
+ * @returns {boolean} True if the current node supports V4. False otherwise.
+ *
+ * @example
+ *  const isSupportingV4 = supportV4(zWaveComClassObject);
+ */
+function supportV4(comClass) {
+  return (
+    Object.keys(comClass).filter((key) => parseInt(key, 10) === INDEXES.INDEX_SWITCH_MULTILEVEL_TARGET).length === 1
+  );
+}
+
+/**
+ * @description Get the command class ID.
+ *
+ * @returns {number} Command Class ID.
+ *
+ * @example commandClass.getId();
+ */
+SwitchMultilevelCommandClass.prototype.getId = function getId() {
+  return COMMAND_CLASSES.COMMAND_CLASS_SWITCH_MULTILEVEL;
+};
+
+/**
+ * @description Get the value following a value changed event.
+ *
+ * @param {Object} node - The node the value changed occurs.
+ * @param {Object} valueChanged - The value changed.
+ *
+ * @returns {Object?} - The zWave value to update. NULL if change MUST be
+ * prevented.
+ *
+ * @example
+ *     const changedValue = comClass.getChangedValue(node, value);
+ */
+SwitchMultilevelCommandClass.prototype.getChangedValue = function getChangedValue(node, valueChanged) {
+  const comClass = node.classes[this.getId()];
+
+  // Specific case handling for Switch Multilevel with V4 implementations.
+  // In the V4 implementation, the level should be based on the target value
+  // and not the level one.
+  // See following docs:
+  //  - Silabs  Application  Command Class Specification §4.72 - Multilevel Switch Command Class, version 4:
+  //      https://www.silabs.com/documents/login/miscellaneous/SDS13781-Z-Wave-Application-Command-Class-Specification.pdf
+  //  - OpenZwave 1.6 Update:
+  //      https://github.com/OpenZWave/open-zwave/wiki/OpenZWave-1.6-Release-Notes#switchmultilevel-commandclass
+
+  if (!supportV4(comClass)) {
+    return valueChanged;
+  }
+
+  if (valueChanged.index === INDEXES.INDEX_SWITCH_MULTILEVEL_TARGET) {
+    logger.debug('Target value identified. Setting the level value instead');
+    const levelValue = comClass[INDEXES.INDEX_SWITCH_MULTILEVEL_LEVEL];
+
+    // Clone levelValue to the expected object to set.
+    // We need to clone the object to avoid future side effect with object
+    // in-memory.
+    const updatedLevel = { ...levelValue };
+    updatedLevel.value = valueChanged.value;
+
+    return updatedLevel;
+  }
+
+  if (valueChanged.index === INDEXES.INDEX_SWITCH_MULTILEVEL_LEVEL) {
+    // Ignore the value event
+    logger.debug('Ignoring level');
+
+    return null;
+  }
+
+  // It's not the LEVEL neither the TARGET value.
+  return DefaultCommandClass.prototype.getChangedValue.call(this, node, valueChanged);
+};
+
+/**
+ * @description Get the Min/Max values for a given value.
+ *
+ * @param {Object} node - Node to get the min/max from.
+ * @param {number} comClassId - Command Class Id to get the min/max.
+ * @param {number} index - Index of the value to get the min/max.
+ *
+ * @returns {Object} Returns min and max values for a given value.
+ *
+ * @example const {min, max} = commClass.getMinMax(node, comClassId, index);
+ */
+SwitchMultilevelCommandClass.prototype.getMinMax = function getMinMax(node, comClassId, index) {
+  if (index === INDEXES.INDEX_SWITCH_MULTILEVEL_LEVEL) {
+    return {
+      min: 0,
+      max: 99,
+      step: 1,
+    };
+  }
+
+  return DefaultCommandClass.prototype.getMinMax.call(this, node, comClassId, index);
+};
+
+module.exports = {
+  instance: new SwitchMultilevelCommandClass(),
+};

server/services/zwave/lib/commands/zwave.getNodes.js

@@ -3,6 +3,8 @@ const { slugify } = require('../../../../utils/slugify');
 const { getCategory } = require('../utils/getCategory');
 const { getUnit } = require('../utils/getUnit');
 const { getDeviceFeatureExternalId } = require('../utils/externalId');
+const { GENRES, UNKNOWN_CATEGORY } = require('../constants');
+const { getCommandClass } = require('../comClass/factory');
 
 /**
  * @description Return array of Nodes.
@@ -37,16 +39,17 @@ function getNodes() {
       params: [],
     };
 
-    const comclasses = Object.keys(node.classes);
+    const comclasses = Object.keys(node.classes).map((comclass) => parseInt(comclass, 10));
     comclasses.forEach((comclass) => {
       const values = node.classes[comclass];
-      const indexes = Object.keys(values);
-      indexes.forEach((idx) => {
-        const { min, max } = values[idx];
+      const commandClass = getCommandClass(comclass);
 
-        if (values[idx].genre === 'user') {
+      Object.keys(values).forEach((idx) => {
+        const { min, max } = commandClass.getMinMax(node, comclass, parseInt(idx, 10));
+
+        if (values[idx].genre === GENRES.USER) {
           const { category, type } = getCategory(node, values[idx]);
-          if (category !== 'unknown') {
+          if (category !== UNKNOWN_CATEGORY) {
             newDevice.features.push({
               name: values[idx].label,
               selector: slugify(`zwave-${values[idx].label}-${node.product}-node-${node.id}`),
@@ -68,6 +71,7 @@ function getNodes() {
         }
       });
     });
+
     return newDevice;
   });
 }

server/services/zwave/lib/commands/zwave.setValue.js

@@ -1,5 +1,6 @@
 const logger = require('../../../../utils/logger');
 const { getNodeInfoByExternalId } = require('../utils/externalId');
+const { getCommandClass } = require('../comClass/factory');
 
 /**
  * @description Set value.
@@ -10,9 +11,21 @@ const { getNodeInfoByExternalId } = require('../utils/externalId');
  * zwave.setValue();
  */
 function setValue(device, deviceFeature, value) {
-  logger.debug(`Zwave : Setting value`);
   const { nodeId, comclass, index, instance } = getNodeInfoByExternalId(deviceFeature.external_id);
-  this.zwave.setValue({ node_id: nodeId, class_id: comclass, instance, index }, value);
+  const node = this.nodes[nodeId];
+  if (!node) {
+    return;
+  }
+
+  const transformedValue = getCommandClass(comclass).getTransformedValue(node, comclass, index, value);
+  logger.debug(
+    `Zwave : Setting value for device ${deviceFeature.external_id} ` +
+      `(nodeId=${nodeId},class_id=${comclass},instance=${instance},index=${index}` +
+      `,type=${node.classes[comclass][index].type}) -> ${transformedValue} (from value ${value})`,
+  );
+
+  node.classes[comclass][index].value = transformedValue;
+  this.zwave.setValue({ node_id: nodeId, class_id: comclass, instance, index }, node.classes[comclass][index].value);
 }
 
 module.exports = {