[BF] v1.3.5.1 Check to avoid megapeaks in Data

[NF] v1.2.2.0 Mqtt can now get and set values

Zway/Devices/CommandClasses/Alarm.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
+  /// <summary>
+  /// 135 = Indicator
+  /// </summary>
+  class Alarm : ACommandClass {
+    public override event UpdatedValue Update;
+
+    public Int32 Level { get; private set; }
+    public Int32 AlarmType { get; private set; }
+
+    public Alarm(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.InitComplex(json);
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("data") && json["data"].Keys.Contains("V1event") && 
+        json["data"]["V1event"].Keys.Contains("alarmType") && json["data"]["V1event"]["alarmType"].Keys.Contains("value") &&
+        json["data"]["V1event"].Keys.Contains("level") && json["data"]["V1event"]["level"].Keys.Contains("value")) {
+        this.AlarmType = Int32.Parse(json["data"]["V1event"]["alarmType"]["value"].ToString());
+        this.Level = Int32.Parse(json["data"]["V1event"]["level"]["value"].ToString());
+      }
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      if(match.Groups[4].Value == ".data.V1event") {
+        if (json.Keys.Contains("alarmType") && json["alarmType"].Keys.Contains("value") &&
+          json.Keys.Contains("level") && json["level"].Keys.Contains("value") &&
+          this.CheckSetUpdateTime(json)) {
+          this.AlarmType = Int32.Parse(json["alarmType"]["value"].ToString());
+          this.Level = Int32.Parse(json["level"]["value"].ToString());
+          this.Update?.Invoke(this, new DeviceUpdateEvent(new Tuple<Int32, Int32>(this.AlarmType, this.Level), this.LastUpdate, this));
+        }
+      } else {
+        Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
+      }
+    }
+
+    public override String ToString() {
+      return "Alarm " + this.Name + " [" + this.Id + "]: " + this.AlarmType + " " + this.Level;
+    }
+
+    internal override void Poll() => this.PollNone();
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "AlarmType", this.AlarmType },
+        { "Level", this.Level },
+      };
+    }
+  }
+}

Zway/Devices/CommandClasses/Battery.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
+  /// <summary>
+  /// 128 = Battery
+  /// </summary>
+  public class Battery : ACommandClass {
+
+    public Double Level { get; private set; }
+
+    public override event UpdatedValue Update;
+
+    public Battery(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.InitComplex(json);
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      Boolean success = false;
+      if (match.Groups[4].Value == ".data") {
+        if (json.Keys.Contains("last") && json["last"].Keys.Contains("value")) {
+          this.Level = Double.Parse(json["last"]["value"].ToString());
+          success = true;
+        }
+      } else if (match.Groups[4].Value == ".data.last") {
+        if (json.Keys.Contains("value")) {
+          this.Level = Double.Parse(json["value"].ToString());
+          success = true;
+        }
+      } else if (match.Groups[4].Value.StartsWith(".data.history.")) {
+      } else if (match.Groups[4].Value == ".data.lastChange") {
+      } else {
+        Helper.WriteError("Kenne in "+this.Name+" ["+this.Id+"] "+ match.Groups[4].Value+" nicht!");
+      }
+      if (success && this.CheckSetUpdateTime(json)) {
+        this.Update?.Invoke(this, new DeviceUpdateEvent(this.Level, this.LastUpdate, this));
+      }
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("data") && json["data"].Keys.Contains("last") && json["data"]["last"].Keys.Contains("value")) {
+        this.Level = Double.Parse(json["data"]["last"]["value"].ToString());
+      }
+    }
+
+    public override String ToString() {
+      return "Battery " + this.Name + " [" + this.Id + "]: " + this.Level;
+    }
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "Level", this.Level },
+      };
+    }
+  }
+}

Zway/Devices/CommandClasses/CentralScene.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
+  /// <summary>
+  /// 91 = CentralScene
+  /// </summary>
+  public class Centralscene : ACommandClass {
+    public override event UpdatedValue Update;
+
+    public ReadOnlyDictionary<Int32, ReadOnlyCollection<Int32>> ValidScenesModes { get; private set; }
+    public Int32 Scene { get; private set; }
+    public Int32 Key { get; private set; }
+
+    public Centralscene(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.ValidScenesModes = new ReadOnlyDictionary<Int32, ReadOnlyCollection<Int32>>(new Dictionary<Int32, ReadOnlyCollection<Int32>>());
+      this.InitComplex(json);
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      if (match.Groups[4].Value == ".data.currentScene") {
+        if (json.Keys.Contains("value")) {
+          this.Scene = Int32.Parse(json["value"].ToString());
+        }
+      } else if (match.Groups[4].Value == ".data.keyAttribute") {
+        if (json.Keys.Contains("value") && this.CheckSetUpdateTime(json)) {
+          this.Key = Int32.Parse(json["value"].ToString());
+          this.Update?.Invoke(this, new DeviceUpdateEvent(new Tuple<Int32, Int32>(this.Scene, this.Key), this.LastUpdate, this));
+        }
+      } else {
+        Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
+      }
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("data")) {
+        JsonData data = json["data"];
+        if(data.Keys.Contains("sceneSupportedKeyAttributesMask")) {
+          Dictionary<Int32, ReadOnlyCollection<Int32>> scenes = new Dictionary<Int32, ReadOnlyCollection<Int32>>();
+          foreach (String item in data["sceneSupportedKeyAttributesMask"].Keys) {
+            if (Int32.TryParse(item, out Int32 mode) && 
+              data["sceneSupportedKeyAttributesMask"][item].Keys.Contains("value") && 
+              data["sceneSupportedKeyAttributesMask"][item]["value"].IsArray) {
+              JsonData values = data["sceneSupportedKeyAttributesMask"][item]["value"];
+              List<Int32> modes = new List<Int32>();
+              foreach (JsonData value in values) {
+                modes.Add(Int32.Parse(value.ToString()));
+              }
+              scenes.Add(mode, new ReadOnlyCollection<Int32>(modes));
+            }
+          }
+          this.ValidScenesModes = new ReadOnlyDictionary<Int32, ReadOnlyCollection<Int32>>(scenes);
+          if (data.Keys.Contains("currentScene") &&
+          data["currentScene"].Keys.Contains("value") && 
+          data["currentScene"]["value"] != null) {
+            this.Scene = Int32.Parse(data["currentScene"]["value"].ToString());
+          }
+          if (data.Keys.Contains("keyAttribute") &&
+          data["keyAttribute"].Keys.Contains("value") &&
+          data["keyAttribute"]["value"] != null) {
+            this.Key = Int32.Parse(data["keyAttribute"]["value"].ToString());
+          }
+        }
+      }
+    }
+
+    public override String ToString() {
+      return "CentralScene " + this.Name + " [" + this.Id + "]: " + this.Scene+"-"+this.Key;
+    }
+
+    internal override void Poll() => this.PollNone();
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "Scene", this.Scene },
+        { "Key", this.Key },
+      };
+    }
+  }
+}

Zway/Devices/CommandClasses/CommandClassSubs/Configurationsub.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
+  class Configurationsub : ACommandClass {
+    public override event UpdatedValue Update;
+    private Int64 _level;
+
+    public Int64 Level {
+      get {
+        return this._level;
+      }
+      set {
+        if (this.Size == 1 && Int16.TryParse(value.ToString(), out Int16 value16)) {
+          this.SetTriple(this.SensorId, value16, 1);
+        } else if(this.Size == 2 && Int32.TryParse(value.ToString(), out Int32 value32)) {
+          this.SetTriple(this.SensorId, value32, 2);
+        } else if(this.Size == 4) {
+          this.SetTriple(this.SensorId, value, 4);
+        }
+      }
+    }
+    public Int32 Size { get; private set; }
+
+    public Configurationsub(JsonData json, Tuple<Int32, Int32, Classes, Int32> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.IsSub = true;
+      InitComplex(json);
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("val") &&
+        json["val"].Keys.Contains("value") &&
+        json["val"]["value"] != null &&
+        json.Keys.Contains("size") &&
+        json["size"].Keys.Contains("value")) {
+        this._level = Int64.Parse(json["val"]["value"].ToString());
+        this.Size = Int32.Parse(json["size"]["value"].ToString());
+      }
+    }
+
+    internal override void Poll() => this.PollSub();
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      if (json.Keys.Contains("val") && json["val"].Keys.Contains("value") && json["val"]["value"] != null &&
+          json.Keys.Contains("size") && json["size"].Keys.Contains("value") &&
+          this.CheckSetUpdateTime(json)) {
+        this._level = Int64.Parse(json["val"]["value"].ToString());
+        this.Size = Int32.Parse(json["size"]["value"].ToString());
+        this.Update?.Invoke(this, new DeviceUpdateEvent(new Tuple<Int64, Int32>(this.Level, this.Size), this.LastUpdate, this));
+      }
+    }
+
+    public override String ToString() {
+      return "Configuration " + this.Name + " [" + this.Id + "]: " + this.Level;
+    }
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "Level", this.Level },
+        { "Size", this.Size },
+      };
+    }
+  }
+}

Zway/Devices/CommandClasses/CommandClassSubs/MeterSub.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
+  public class Metersub : ACommandClass {
+    public override event UpdatedValue Update;
+
+    public String Type { get; private set; }
+    public Double Level { get; private set; }
+    public String Scale { get; private set; }
+    public Metersub(JsonData json, Tuple<Int32, Int32, Classes, Int32> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.HasReset = true;
+      this.IsSub = true;
+      InitComplex(json);
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("sensorTypeString") &&
+        json["sensorTypeString"].Keys.Contains("value") &&
+        json.Keys.Contains("val") &&
+        json["val"].Keys.Contains("value") &&
+        json.Keys.Contains("scaleString") &&
+        json["scaleString"].Keys.Contains("value")) {
+        this.Type = json["sensorTypeString"]["value"].ToString();
+        this.Level = Double.Parse(json["val"]["value"].ToString());
+        this.Scale = json["scaleString"]["value"].ToString();
+      }
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      if (json.Keys.Contains("val") && json["val"].Keys.Contains("value") &&
+          json.Keys.Contains("sensorTypeString") && json["sensorTypeString"].Keys.Contains("value") &&
+          json.Keys.Contains("scaleString") && json["scaleString"].Keys.Contains("value") && 
+          this.CheckSetUpdateTime(json)) {
+        this.Level = Double.Parse(json["val"]["value"].ToString());
+        this.Type = json["sensorTypeString"]["value"].ToString();
+        this.Scale = json["scaleString"]["value"].ToString();
+        this.Update?.Invoke(this, new DeviceUpdateEvent(new Tuple<String, String, Double>(this.Type, this.Scale, this.Level), this.LastUpdate, this));
+      }
+    }
+
+    public override String ToString() {
+      return "Meter " + this.Name + " [" + this.Id + "]: " + this.Type + " " + this.Level + "" + this.Scale;
+    }
+
+    internal override void Poll() => this.PollNone();
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "Level", this.Level },
+        { "Type", this.Type },
+        { "Scale", this.Scale },
+      };
+    }
+  }
+}

Zway/Devices/CommandClasses/CommandClassSubs/SceneControllerConfSub.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
+  public class Scenecontrollerconfsub : ACommandClass {
+    public override event UpdatedValue Update;
+
+    public Int32 Scene { get; private set; }
+    public Int32 Duration { get; private set; }
+    public Scenecontrollerconfsub(JsonData json, Tuple<Int32, Int32, Classes, Int32> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.IsSub = true;
+      InitComplex(json);
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("scene") && json["scene"].Keys.Contains("value") &&
+        json.Keys.Contains("duration") && json["duration"].Keys.Contains("value")) {
+        this.Scene = Int32.Parse(json["scene"]["value"].ToString());
+        this.Duration = Int32.Parse(json["duration"]["value"].ToString());
+      }
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      if (json.Keys.Contains("scene") && json["scene"].Keys.Contains("value") &&
+          json.Keys.Contains("duration") && json["duration"].Keys.Contains("value") &&
+          this.CheckSetUpdateTime(json)) {
+        this.Scene = Int32.Parse(json["scene"]["value"].ToString());
+        this.Duration = Int32.Parse(json["duration"]["value"].ToString());
+        this.Update?.Invoke(this, new DeviceUpdateEvent(new Tuple<Int32, Int32>(this.Scene, this.Duration), this.LastUpdate, this));
+      }
+    }
+
+    public override String ToString() {
+      return "SceneControllerConf " + this.Name + " [" + this.Id + "]: " + this.Scene + " " + this.Duration;
+    }
+
+    internal override void Poll() => this.PollSub();
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "Scene", this.Scene },
+        { "Duration", this.Duration }
+      };
+    }
+  }
+}

Zway/Devices/CommandClasses/CommandClassSubs/SensorBinarySub.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
+  public class Sensorbinarysub : ACommandClass {
+    public override event UpdatedValue Update;
+
+    public String Type { get; private set; }
+    public Boolean Level { get; private set; }
+    public Sensorbinarysub(JsonData json, Tuple<Int32, Int32, Classes, Int32> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.IsSub = true;
+      InitComplex(json);
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("sensorTypeString") &&
+        json["sensorTypeString"].Keys.Contains("value") &&
+        json.Keys.Contains("level") &&
+        json["level"].Keys.Contains("value")) {
+        this.Type = json["sensorTypeString"]["value"].ToString();
+        this.Level = (Boolean)json["level"]["value"];
+      }
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      if (json.Keys.Contains("level") && json["level"].Keys.Contains("value") &&
+          json.Keys.Contains("sensorTypeString") && json["sensorTypeString"].Keys.Contains("value") &&
+          this.CheckSetUpdateTime(json)) {
+        this.Level = (Boolean)json["level"]["value"];
+        this.Type = json["sensorTypeString"]["value"].ToString();
+        this.Update?.Invoke(this, new DeviceUpdateEvent(new Tuple<String, Boolean>(this.Type, this.Level), this.LastUpdate, this));
+      }
+    }
+
+    public override String ToString() {
+      return "SensorBinary " + this.Name + " [" + this.Id + "]: " + this.Type + " " + this.Level.ToString();
+    }
+
+    internal override void Poll() => this.PollNone();
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "Level", this.Level },
+        { "Type", this.Type }
+      };
+    }
+  }
+}

Zway/Devices/CommandClasses/CommandClassSubs/SensorMultilevelSub.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
+  public class Sensormultilevelsub : ACommandClass {
+    public override event UpdatedValue Update;
+
+    public String Type { get; private set; }
+    public Double Level { get; private set; }
+    public String Scale { get; private set; }
+
+    public Sensormultilevelsub(JsonData json, Tuple<Int32, Int32, Classes, Int32> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.IsSub = true;
+      InitComplex(json);
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("sensorTypeString") &&
+        json["sensorTypeString"].Keys.Contains("value") &&
+        json.Keys.Contains("val") &&
+        json["val"].Keys.Contains("value") &&
+        json.Keys.Contains("scaleString") &&
+        json["scaleString"].Keys.Contains("value")) {
+        this.Type = json["sensorTypeString"]["value"].ToString();
+        this.Level = Double.Parse(json["val"]["value"].ToString());
+        this.Scale = json["scaleString"]["value"].ToString();
+      }
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      if(json.Keys.Contains("val") && json["val"].Keys.Contains("value") &&
+          json.Keys.Contains("sensorTypeString") && json["sensorTypeString"].Keys.Contains("value") &&
+          json.Keys.Contains("scaleString") && json["scaleString"].Keys.Contains("value") && 
+          this.CheckSetUpdateTime(json)) {
+        if(Double.Parse(json["val"]["value"].ToString()) > 3660 && json["scaleString"]["value"].ToString() == "W") {
+          return;
+        }
+        this.Level = Double.Parse(json["val"]["value"].ToString());
+        this.Type = json["sensorTypeString"]["value"].ToString();
+        this.Scale = json["scaleString"]["value"].ToString();
+        this.Update?.Invoke(this, new DeviceUpdateEvent(new Tuple<String, String, Double>(this.Type, this.Scale, this.Level), this.LastUpdate, this));
+      }
+    }
+
+    public override String ToString() {
+      return "SensorMultilevel " + this.Name + " [" + this.Id + "]: " + this.Type + " " + this.Level + "" + this.Scale;
+    }
+
+    internal override void Poll() => this.PollNone();
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "Level", this.Level },
+        { "Type", this.Type },
+        { "Scale", this.Scale },
+      };
+    }
+  }
+}

Zway/Devices/CommandClasses/CommandClassSubs/ThermostatSetPointSub.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
+  class Thermostatsetpointsub : ACommandClass {
+    public override event UpdatedValue Update;
+
+    private Double _level;
+    public Double Level {
+      get {
+        return this._level;
+      }
+      set {
+        if (!this.HasMinMax || (this.HasMinMax && value >= this.TempMin && value <= this.TempMax)) {
+          this.SetTuple(this.SensorId, (Double)Math.Round(value * 2, MidpointRounding.AwayFromZero) / 2);
+        }
+      }
+    }
+    public String Scale { get; private set; }
+    public Double TempMax { get; private set; }
+    public Double TempMin { get; private set; }
+    public Boolean HasMinMax { get; private set; }
+    public String Type { get; private set; }
+
+    public Thermostatsetpointsub(JsonData json, Tuple<Int32, Int32, Classes, Int32> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.IsSub = true;
+      InitComplex(json);
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("modeName") && json["modeName"].Keys.Contains("value") &&
+        json.Keys.Contains("val") && json["val"].Keys.Contains("value") &&
+        json.Keys.Contains("deviceScaleString") && json["deviceScaleString"].Keys.Contains("value")) {
+        this.Type = json["modeName"]["value"].ToString();
+        this._level = Double.Parse(json["val"]["value"].ToString());
+        this.Scale = json["deviceScaleString"]["value"].ToString();
+      }
+      if (json.Keys.Contains("min") && json["min"].Keys.Contains("value") &&
+        json.Keys.Contains("max") && json["max"].Keys.Contains("value")) {
+        this.TempMin = Double.Parse(json["min"]["value"].ToString());
+        this.TempMax = Double.Parse(json["max"]["value"].ToString());
+        this.HasMinMax = true;
+      } else {
+        this.HasMinMax = false;
+      }
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      Boolean ret = false;
+      if (json.Keys.Contains("val") && json["val"].Keys.Contains("value") &&
+        json.Keys.Contains("deviceScaleString") && json["deviceScaleString"].Keys.Contains("value") &&
+        json.Keys.Contains("modeName") && json["modeName"].Keys.Contains("value")) {
+        this._level = Double.Parse(json["val"]["value"].ToString());
+        this.Scale = json["deviceScaleString"]["value"].ToString();
+        this.Type = json["modeName"]["value"].ToString();
+        ret = true;
+      }
+      if (json.Keys.Contains("min") && json["val"].Keys.Contains("value") &&
+        json.Keys.Contains("max") && json["max"].Keys.Contains("value")) {
+        this.TempMin = Double.Parse(json["min"]["value"].ToString());
+        this.TempMax = Double.Parse(json["max"]["value"].ToString());
+        this.HasMinMax = true;
+        ret = true;
+      } else {
+        this.HasMinMax = false;
+      }
+      if (ret && this.CheckSetUpdateTime(json)) {
+        this.Update?.Invoke(this, new DeviceUpdateEvent(new Tuple<String, String, Double, Double, Double, Boolean>(this.Type, this.Scale, this.Level, this.TempMin, this.TempMax, this.HasMinMax), this.LastUpdate, this));
+      }
+    }
+
+    public override String ToString() {
+      return "ThermostatSetPoint " + this.Name + " [" + this.Id + "]: " + this.Type + " " + this.Level + "" + this.Scale + " [" + this.TempMin + "," + this.TempMax + "," + this.HasMinMax + "]";
+    }
+
+    internal override void Poll() => this.PollSub();
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "Level", this.Level },
+        { "Type", this.Type },
+        { "Scale", this.Scale },
+        { "TempMax", this.TempMax },
+        { "TempMin", this.TempMin },
+        { "HasMinMax", this.HasMinMax },
+      };
+    }
+  }
+}

Zway/Devices/CommandClasses/Configuration.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
+  /// <summary>
+  /// 112 = Configuration
+  /// </summary>
+  class Configuration : ACommandClass {
+    public override event UpdatedValue Update;
+
+    public Configuration(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.HasSub = true;
+      this.InitComplex(json);
+      foreach (KeyValuePair<Int32, ACommandClass> item in this.Sub) {
+        item.Value.Update += this.DeviceUpdate;
+      }
+    }
+
+    private void DeviceUpdate(Object sender, DeviceUpdateEvent e) {
+      this.Update?.Invoke(this, e);
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("data")) {
+        JsonData data = json["data"];
+        Dictionary<Int32, ACommandClass> subs = new Dictionary<Int32, ACommandClass>();
+        foreach (String item in data.Keys) {
+          if (Int32.TryParse(item, out Int32 subid) &&
+            data[item].Keys.Contains("size") &&
+            data[item].Keys.Contains("val") &&
+            data[item]["val"].Keys.Contains("value") &&
+            data[item]["val"]["value"] != null) {
+            subs.Add(subid, new Configurationsub(data[item], new Tuple<Int32, Int32, Classes, Int32>(this.DeviceId, this.Instance, this.Commandclass, subid), this.http, this.Polling));
+          }
+        }
+        this.Sub = new ReadOnlyDictionary<Int32, ACommandClass>(subs);
+      }
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      if (match.Groups[4].Value.StartsWith(".data.")) {
+        Int32 subid = Int32.Parse(match.Groups[5].Value);
+        if (this.Sub.ContainsKey(subid)) {
+          this.Sub[subid].SetUpdate(json, match);
+        }
+      } else {
+        Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
+      }
+    }
+
+    internal override void Poll() => this.PollPerSub();
+
+    public override Dictionary<String, Object> ToDictionary() => this.ToDictionarySub();
+  }
+}

Zway/Devices/CommandClasses/Indicator.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
+  /// <summary>
+  /// 135 = Indicator
+  /// </summary>
+  class Indicator : ACommandClass {
+    private Boolean _level;
+
+    public override event UpdatedValue Update;
+    public Boolean Level {
+      get {
+        return this._level;
+      }
+      set {
+        this.SetInt(value ? 255 : 0);
+      }
+    }
+
+    public Indicator(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.InitComplex(json);
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("data") && json["data"].Keys.Contains("stat") && json["data"]["stat"].Keys.Contains("value")) {
+        this._level = Int32.Parse(json["data"]["stat"]["value"].ToString()) == 255;
+      }
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      if(match.Groups[4].Value == ".data.stat") {
+        if (json.Keys.Contains("value") && this.CheckSetUpdateTime(json)) {
+          this._level = Int32.Parse(json["value"].ToString()) == 255;
+          this.Update?.Invoke(this, new DeviceUpdateEvent(this.Level, this.LastUpdate, this));
+        }
+      } else {
+        Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
+      }
+    }
+
+    public override String ToString() {
+      return "Indicator " + this.Name + " [" + this.Id + "]: " + this.Level;
+    }
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "Level", this.Level },
+      };
+    }
+  }
+}

Zway/Devices/CommandClasses/Meter.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
+  /// <summary>
+  /// 50 = Meter
+  /// </summary>
+  public class Meter : ACommandClass {
+    public override event UpdatedValue Update;
+
+    public Meter(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.HasSub = true;
+      this.InitComplex(json);
+      foreach (KeyValuePair<Int32, ACommandClass> item in this.Sub) {
+        item.Value.Update += this.DeviceUpdate;
+      }
+    }
+
+    private void DeviceUpdate(Object sender, DeviceUpdateEvent e) {
+      this.Update?.Invoke(this, e);
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      if (match.Groups[4].Value.StartsWith(".data.")) {
+        Int32 subid = Int32.Parse(match.Groups[5].Value);
+        if (this.Sub.ContainsKey(subid)) {
+          this.Sub[subid].SetUpdate(json, match);
+        }
+      } else {
+        Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
+      }
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("data")) {
+        JsonData data = json["data"];
+        Dictionary<Int32, ACommandClass> subs = new Dictionary<Int32, ACommandClass>();
+        foreach (String item in data.Keys) {
+          if (Int32.TryParse(item, out Int32 subid) &&
+            data[item].Keys.Contains("sensorTypeString") &&
+            data[item].Keys.Contains("val") &&
+            data[item].Keys.Contains("scaleString")) {
+            subs.Add(subid, new Metersub(data[item], new Tuple<Int32, Int32, Classes, Int32>(this.DeviceId, this.Instance, this.Commandclass, subid), this.http, this.Polling));
+          }
+        }
+        this.Sub = new ReadOnlyDictionary<Int32, ACommandClass>(subs);
+      }
+    }
+
+    internal override void Poll() => this.PollSubGlobal();
+
+    public override Dictionary<String, Object> ToDictionary() => this.ToDictionarySub();
+  }
+}

Zway/Devices/CommandClasses/SceneControllerConf.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
+  /// <summary>
+  /// 50 = Meter
+  /// </summary>
+  public class Scenecontrollerconf : ACommandClass {
+    public override event UpdatedValue Update;
+
+    public Scenecontrollerconf(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.HasSub = true;
+      this.InitComplex(json);
+      foreach (KeyValuePair<Int32, ACommandClass> item in this.Sub) {
+        item.Value.Update += this.DeviceUpdate;
+      }
+    }
+
+    private void DeviceUpdate(Object sender, DeviceUpdateEvent e) {
+      this.Update?.Invoke(this, e);
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      if (match.Groups[4].Value.StartsWith(".data.")) {
+        Int32 subid = Int32.Parse(match.Groups[5].Value);
+        if (this.Sub.ContainsKey(subid)) {
+          this.Sub[subid].SetUpdate(json, match);
+        }
+      } else {
+        Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
+      }
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("data")) {
+        JsonData data = json["data"];
+        Dictionary<Int32, ACommandClass> subs = new Dictionary<Int32, ACommandClass>();
+        foreach (String item in data.Keys) {
+          if (Int32.TryParse(item, out Int32 subid) &&
+            data[item].Keys.Contains("scene") &&
+            data[item].Keys.Contains("duration")) {
+            subs.Add(subid, new Scenecontrollerconfsub(data[item], new Tuple<Int32, Int32, Classes, Int32>(this.DeviceId, this.Instance, this.Commandclass, subid), this.http, this.Polling));
+          }
+        }
+        this.Sub = new ReadOnlyDictionary<Int32, ACommandClass>(subs);
+      }
+    }
+
+    internal override void Poll() => this.PollPerSub();
+
+    public override Dictionary<String, Object> ToDictionary() => this.ToDictionarySub();
+  }
+}

Zway/Devices/CommandClasses/SensorBinary.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
+  /// <summary>
+  /// 48 = SensorBinary
+  /// </summary>
+  public class Sensorbinary : ACommandClass {
+    public override event UpdatedValue Update;
+
+    public Sensorbinary(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.HasSub = true;
+      this.InitComplex(json);
+      foreach (KeyValuePair<Int32, ACommandClass> item in this.Sub) {
+        item.Value.Update += this.DeviceUpdate;
+      }
+    }
+
+    private void DeviceUpdate(Object sender, DeviceUpdateEvent e) {
+      this.Update?.Invoke(this, e);
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      if (match.Groups[4].Value.StartsWith(".data.")) {
+        Int32 subid = Int32.Parse(match.Groups[5].Value);
+        if (this.Sub.ContainsKey(subid)) {
+          this.Sub[subid].SetUpdate(json, match);
+        }
+      } else {
+        Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
+      }
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("data")) {
+        JsonData data = json["data"];
+        Dictionary<Int32, ACommandClass> subs = new Dictionary<Int32, ACommandClass>();
+        foreach (String item in data.Keys) {
+          if (Int32.TryParse(item, out Int32 subid) &&
+            data[item].Keys.Contains("sensorTypeString") &&
+            data[item].Keys.Contains("level")) {
+            subs.Add(subid, new Sensorbinarysub(data[item], new Tuple<Int32, Int32, Classes, Int32>(this.DeviceId, this.Instance, this.Commandclass, subid), this.http, this.Polling));
+          }
+        }
+        this.Sub = new ReadOnlyDictionary<Int32, ACommandClass>(subs);
+      }
+    }
+
+    internal override void Poll() => this.PollSubGlobal();
+
+    public override Dictionary<String, Object> ToDictionary() => this.ToDictionarySub();
+  }
+}

Zway/Devices/CommandClasses/SensorMultilevel.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
+  /// <summary>
+  /// 49 = SensorMultilevel
+  /// </summary>
+  public class Sensormultilevel : ACommandClass {
+    public override event UpdatedValue Update;
+
+    public Sensormultilevel(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.HasSub = true;
+      this.InitComplex(json);
+      foreach (KeyValuePair<Int32, ACommandClass> item in this.Sub) {
+        item.Value.Update += this.DeviceUpdate;
+      }
+    }
+
+    private void DeviceUpdate(Object sender, DeviceUpdateEvent e) {
+      this.Update?.Invoke(this, e);
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      if (match.Groups[4].Value.StartsWith(".data.")) {
+        Int32 subid = Int32.Parse(match.Groups[5].Value);
+        if (this.Sub.ContainsKey(subid)) {
+          this.Sub[subid].SetUpdate(json, match);
+        }
+      } else {
+        Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
+      }
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("data")) {
+        JsonData data = json["data"];
+        Dictionary<Int32, ACommandClass> subs = new Dictionary<Int32, ACommandClass>();
+        foreach (String item in data.Keys) {
+          if (Int32.TryParse(item, out Int32 subid) &&
+            data[item].Keys.Contains("sensorTypeString") &&
+            data[item].Keys.Contains("val") &&
+            data[item].Keys.Contains("scaleString")) {
+            subs.Add(subid, new Sensormultilevelsub(data[item], new Tuple<Int32, Int32, Classes, Int32>(this.DeviceId, this.Instance, this.Commandclass, subid), this.http, this.Polling));
+          }
+        }
+        this.Sub = new ReadOnlyDictionary<Int32, ACommandClass>(subs);
+      }
+    }
+
+    internal override void Poll() => this.PollSubGlobal();
+
+    public override Dictionary<String, Object> ToDictionary() => this.ToDictionarySub();
+  }
+}

Zway/Devices/CommandClasses/SwitchBinary.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
+  /// <summary>
+  /// 37 = SwitchBinary
+  /// </summary>
+  public class Switchbinary : ACommandClass {
+    private Boolean _level;
+
+    public override event UpdatedValue Update;
+
+    public Boolean Level {
+      get {
+        return this._level;
+      }
+      set {
+        this.SetInt(value ? 255 : 0);
+      }
+    }
+
+    public Switchbinary(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.InitComplex(json);
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      if(match.Groups[4].Value == ".data.level") {
+        if (json.Keys.Contains("value") && json["value"].IsBoolean && this.CheckSetUpdateTime(json)) {
+          this._level = (Boolean)json["value"];
+          this.Update?.Invoke(this, new DeviceUpdateEvent(this.Level, this.LastUpdate, this));
+        }
+      }  else {
+        Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
+      }
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("data") && json["data"].Keys.Contains("level") && json["data"]["level"].Keys.Contains("value") && json["data"]["level"]["value"].IsBoolean) {
+        this._level = (Boolean)json["data"]["level"]["value"];
+      }
+    }
+
+    public override String ToString() {
+      return "SwitchBinary " + this.Name + " [" + this.Id + "]: " + this.Level;
+    }
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "Level", this.Level }
+      };
+    }
+  }
+}

Zway/Devices/CommandClasses/SwitchMultilevel.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
+  /// <summary>
+  /// 38 = SwitchMultilevel
+  /// </summary>
+  public class Switchmultilevel : ACommandClass {
+    private Int32 _level;
+
+    public override event UpdatedValue Update;
+
+    public Int32 Level {
+      get {
+        return this._level;
+      }
+      set {
+        if(value == 0 || (value > 0 && value <= 99) || value == 255) {
+          this.SetTuple(value, 0);
+        }
+      }
+    }
+
+    public Switchmultilevel(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.InitComplex(json);
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      if(match.Groups[4].Value == ".data.level") {
+        if(json.Keys.Contains("value") && this.CheckSetUpdateTime(json)) {
+          this._level = Int32.Parse(json["value"].ToString());
+          this.Update?.Invoke(this, new DeviceUpdateEvent(this.Level, this.LastUpdate, this));
+        }
+      } else if (match.Groups[4].Value == ".data.prevLevel") {
+      } else {
+        Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
+      }
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("data") && json["data"].Keys.Contains("level") && json["data"]["level"].Keys.Contains("value")) {
+        this._level = Int32.Parse(json["data"]["level"]["value"].ToString());
+      }
+    }
+
+    public override String ToString() {
+      return "SwitchMultilevel " + this.Name + " [" + this.Id + "]: " + this.Level;
+    }
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "Level", this.Level }
+      };
+    }
+  }
+}

Zway/Devices/CommandClasses/ThermostatMode.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
+  /// <summary>
+  /// 64 = ThermostatMode
+  /// </summary>
+  public class Thermostatmode : ACommandClass {
+    private Int32 _level;
+
+    public override event UpdatedValue Update;
+
+    public ReadOnlyDictionary<Int32, String> ValidModes { get; private set; }
+    public Int32 Level {
+      get { return this._level; }
+      set {
+        if (this.ValidModes.ContainsKey(value)) {
+          this.SetInt(value);
+        }
+      }
+    }
+
+    public Thermostatmode(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.ValidModes = new ReadOnlyDictionary<Int32, String>(new Dictionary<Int32, String>());
+      this.InitComplex(json);
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      if(match.Groups[4].Value == ".data.mode") {
+        if(json.Keys.Contains("value") && this.CheckSetUpdateTime(json)) {
+          this._level = Int32.Parse(json["value"].ToString());
+          this.Update?.Invoke(this, new DeviceUpdateEvent(this.Level, this.LastUpdate, this));
+        }
+      } else {
+        Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
+      }
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("data")) {
+        JsonData data = json["data"];
+        Dictionary<Int32, String> modes = new Dictionary<Int32, String>();
+        foreach (String item in data.Keys) {
+          if (Int32.TryParse(item, out Int32 mode) &&
+            data[item].Keys.Contains("modeName") &&
+            data[item]["modeName"].Keys.Contains("value")) {
+            modes.Add(mode, data[item]["modeName"]["value"].ToString());
+          }
+        }
+        this.ValidModes = new ReadOnlyDictionary<Int32, String>(modes);
+        if (data.Keys.Contains("mode") &&
+          data["mode"].Keys.Contains("value")) {
+          this._level = Int32.Parse(data["mode"]["value"].ToString());
+        }
+      }
+    }
+
+    public override String ToString() {
+      return "ThermostatMode " + this.Name + " [" + this.Id + "]: " + this.ValidModes[this.Level];
+    }
+
+    public override Dictionary<String, Object> ToDictionary() {
+      Dictionary<String, String> modes = new Dictionary<String, String>();
+      foreach (KeyValuePair<Int32, String> item in this.ValidModes) {
+        modes.Add(item.Key.ToString(), item.Value);
+      }
+      Dictionary<String, Object> json = new Dictionary<String, Object> {
+        { "Level", this.Level },
+        { "ValidModes", modes }
+      };
+      return json;
+    }
+  }
+}

Zway/Devices/CommandClasses/ThermostatSetPoint.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
+  /// <summary>
+  /// 67 = ThermostatSetPoint
+  /// </summary>
+  public class Thermostatsetpoint : ACommandClass {
+    public override event UpdatedValue Update;
+
+    public Thermostatsetpoint(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.HasSub = true;
+      this.InitComplex(json);
+      foreach (KeyValuePair<Int32, ACommandClass> item in this.Sub) {
+        item.Value.Update += this.DeviceUpdate;
+      }
+    }
+
+    private void DeviceUpdate(Object sender, DeviceUpdateEvent e) {
+      this.Update?.Invoke(this, e);
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      if (match.Groups[4].Value.StartsWith(".data.")) {
+        Int32 subid = Int32.Parse(match.Groups[5].Value);
+        if (this.Sub.ContainsKey(subid)) {
+          this.Sub[subid].SetUpdate(json, match);
+        }
+      } else {
+        Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
+      }
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("data")) {
+        JsonData data = json["data"];
+        Dictionary<Int32, ACommandClass> subs = new Dictionary<Int32, ACommandClass>();
+        foreach (String item in data.Keys) {
+          if (Int32.TryParse(item, out Int32 subid) &&
+            data[item].Keys.Contains("modeName") &&
+            data[item].Keys.Contains("val") &&
+            data[item].Keys.Contains("deviceScaleString")) {
+            subs.Add(subid, new Thermostatsetpointsub(data[item], new Tuple<Int32, Int32, Classes, Int32>(this.DeviceId, this.Instance, this.Commandclass, subid), this.http, this.Polling));
+          }
+        }
+        this.Sub = new ReadOnlyDictionary<Int32, ACommandClass>(subs);
+      }
+    }
+
+    internal override void Poll() => this.PollPerSub();
+
+    public override Dictionary<String, Object> ToDictionary() => this.ToDictionarySub();
+  }
+}

Zway/Devices/CommandClasses/Wakeup.cs

@@ -0,0 +1,151 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
+  /// <summary>
+  /// 132 = Wakeup
+  /// </summary>
+  class Wakeup : ACommandClass {
+    private Int32 _interval;
+    private Int32 _againstNode;
+
+    public override event UpdatedValue Update;
+    public Int32 Interval {
+      get {
+        return this._interval;
+      }
+      set {
+        if(value >= this.WakeupMin && value <= this.WakeupMax) {
+          this.SetTuple(value, this.AgainstNode);
+        }
+      }
+    }
+    public Int32 AgainstNode { get {
+        return this._againstNode;
+      }
+      set {
+        this.SetTuple(this.Interval, value);
+      }
+    }
+    public Int32 WakeupMin { get; private set; }
+    public Int32 WakeupMax { get; private set; }
+    public Boolean HasMinMax { get; private set; }
+    public Int32 WakeupDefault { get; private set; }
+    public Boolean HasDefault { get; private set; }
+    public DateTime LastWakeup { get; private set; }
+    public DateTime LastSleep { get; private set; }
+
+    public Wakeup(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
+      this.InitComplex(json);
+    }
+
+    private void InitComplex(JsonData json) {
+      if (json.Keys.Contains("data")) {
+        JsonData data = json["data"];
+        if(data.Keys.Contains("interval") && data["interval"].Keys.Contains("value")) {
+          this._interval = Int32.Parse(data["interval"]["value"].ToString());
+        }
+        if (data.Keys.Contains("nodeId") && data["nodeId"].Keys.Contains("value")) {
+          this._againstNode = Int32.Parse(data["nodeId"]["value"].ToString());
+        }
+        this.HasMinMax = false;
+        if (data.Keys.Contains("min") && data["min"].Keys.Contains("value") && data["min"]["value"] != null) {
+          this.WakeupMin = Int32.Parse(data["min"]["value"].ToString());
+          this.HasMinMax = true;
+        }
+        if (data.Keys.Contains("max") && data["max"].Keys.Contains("value") && data["max"]["value"] != null) {
+          this.WakeupMax = Int32.Parse(data["max"]["value"].ToString());
+          this.HasMinMax = true;
+        }
+        this.HasDefault = false;
+        if (data.Keys.Contains("default") && data["default"].Keys.Contains("value") && data["default"]["value"] != null) {
+          this.WakeupDefault = Int32.Parse(data["default"]["value"].ToString());
+          this.HasDefault = true;
+        }
+        if (data.Keys.Contains("lastWakeup") && data["lastWakeup"].Keys.Contains("value") && data["lastWakeup"]["value"] != null) {
+          this.LastWakeup = DateTimeOffset.FromUnixTimeSeconds(Int64.Parse(data["lastWakeup"]["value"].ToString())).DateTime.ToLocalTime();
+        }
+        if (data.Keys.Contains("lastSleep") && data["lastSleep"].Keys.Contains("value") && data["lastSleep"]["value"] != null) {
+          this.LastSleep = DateTimeOffset.FromUnixTimeSeconds(Int64.Parse(data["lastSleep"]["value"].ToString())).DateTime.ToLocalTime();
+        }
+      }
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      Boolean success = false;
+      if (match.Groups[4].Value == ".data.lastWakeup") {
+        if (json.Keys.Contains("value") && (json["value"].IsInt || json["value"].IsLong)) {
+          this.LastWakeup = DateTimeOffset.FromUnixTimeSeconds(Int64.Parse(json["value"].ToString())).DateTime.ToLocalTime();
+          success = true;
+        }
+      } else if (match.Groups[4].Value == ".data.lastSleep") {
+        if (json.Keys.Contains("value") && (json["value"].IsInt || json["value"].IsLong)) {
+          this.LastSleep = DateTimeOffset.FromUnixTimeSeconds(Int64.Parse(json["value"].ToString())).DateTime.ToLocalTime();
+          success = true;
+        }
+      } else if (match.Groups[4].Value == ".data") {
+        if (json.Keys.Contains("interval") && json["interval"].Keys.Contains("value")) {
+          this._interval = Int32.Parse(json["interval"]["value"].ToString());
+          success = true;
+        }
+        if (json.Keys.Contains("nodeId") && json["nodeId"].Keys.Contains("value")) {
+          this._againstNode = Int32.Parse(json["nodeId"]["value"].ToString());
+          success = true;
+        }
+        this.HasMinMax = false;
+        if (json.Keys.Contains("min") && json["min"].Keys.Contains("value") && json["min"]["value"] != null) {
+          this.WakeupMin = Int32.Parse(json["min"]["value"].ToString());
+          success = true;
+          this.HasMinMax = true;
+        }
+        if (json.Keys.Contains("max") && json["max"].Keys.Contains("value") && json["max"]["value"] != null) {
+          this.WakeupMax = Int32.Parse(json["max"]["value"].ToString());
+          success = true;
+          this.HasMinMax = true;
+        }
+        this.HasDefault = false;
+        if (json.Keys.Contains("default") && json["default"].Keys.Contains("value") && json["default"]["value"] != null) {
+          this.WakeupDefault = Int32.Parse(json["default"]["value"].ToString());
+          success = true;
+          this.HasDefault = true;
+        }
+        if (json.Keys.Contains("lastWakeup") && json["lastWakeup"].Keys.Contains("value") && json["lastWakeup"]["value"] != null) {
+          this.LastWakeup = DateTimeOffset.FromUnixTimeSeconds(Int64.Parse(json["lastWakeup"]["value"].ToString())).DateTime.ToLocalTime();
+          success = true;
+        }
+        if (json.Keys.Contains("lastSleep") && json["lastSleep"].Keys.Contains("value") && json["lastSleep"]["value"] != null) {
+          this.LastSleep = DateTimeOffset.FromUnixTimeSeconds(Int64.Parse(json["lastSleep"]["value"].ToString())).DateTime.ToLocalTime();
+          success = true;
+        }
+      } else {
+        Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
+      }
+      if (success && this.CheckSetUpdateTime(json)) {
+        this.Update?.Invoke(this, new DeviceUpdateEvent(0, this.LastUpdate, this));
+      }
+    }
+
+    public override String ToString() {
+      return "Wakeup " + this.Name + " [" + this.Id + "]: " + this.LastWakeup + "-" + this.LastSleep + " " + this.Interval + " [" + this.WakeupMin + "," + this.WakeupMax + "," + this.WakeupDefault + "," + this.AgainstNode + "]";
+    }
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "Interval", this.Interval },
+        { "AgainstNode", this.AgainstNode },
+        { "WakeupMin", this.WakeupMin },
+        { "WakeupMax", this.WakeupMax },
+        { "HasMinMax", this.HasMinMax },
+        { "WakeupDefault", this.WakeupDefault },
+        { "HasDefault", this.HasDefault },
+        { "LastWakeup", this.LastWakeup.ToString() },
+        { "LastSleep", this.LastSleep.ToString() }
+      };
+    }
+  }
+}

Zway/Devices/Device.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices {
+  public class Device {
+    private Boolean polling;
+
+    public delegate void UpdatedDevice(Object sender, DeviceUpdateEvent e);
+    public event UpdatedDevice Update;
+
+    public String Name { get; }
+    public Int32 Id { get; }
+    public ReadOnlyDictionary<Int32, Instance> Instances { get; private set; }
+    public DateTime LastUpdate { get; private set; }
+
+    private Device(JsonData json, Tuple<Int32> id, HttpConnection http, Boolean polling) {
+      this.Id = id.Item1;
+      this.polling = polling;
+      this.CreateInstances(json["instances"], http);
+      if (json["data"].Keys.Contains("givenName") && json["data"]["givenName"].Keys.Contains("value")) {
+        this.Name = json["data"]["givenName"]["value"].ToString();
+      } else {
+        this.Name = "Unknown";
+      }
+      foreach (KeyValuePair<Int32, Instance> item in this.Instances) {
+        item.Value.Update += this.InstanceUpdate;
+      }
+    }
+
+    protected Boolean CheckSetUpdateTime(JsonData json) {
+      if (json.Keys.Contains("updateTime") && (json["updateTime"].IsInt || json["updateTime"].IsLong)) {
+        DateTime newdate = DateTimeOffset.FromUnixTimeSeconds(Int64.Parse(json["updateTime"].ToString())).ToLocalTime().DateTime;
+        if (newdate > this.LastUpdate) {
+          this.LastUpdate = newdate;
+          return true;
+        } else {
+          return false;
+        }
+      } else {
+        return true;
+      }
+    }
+
+    private void InstanceUpdate(Object sender, DeviceUpdateEvent e) {
+      this.Update?.Invoke(this, e);
+    }
+
+    private void CreateInstances(JsonData json, HttpConnection http) {
+      Dictionary<Int32, Instance> instances = new Dictionary<Int32, Instance>();
+      foreach (String instanceid in json.Keys) {
+        Instance i = Instance.CreateInstance(json[instanceid], new Tuple<Int32, Int32>(this.Id, Int32.Parse(instanceid)), http, this.polling);
+        if (i != null) {
+          instances.Add(Int32.Parse(instanceid), i);
+        }
+      }
+      this.Instances = new ReadOnlyDictionary<Int32, Instance>(instances);
+    }
+
+    internal static Device CreateDevice(JsonData json, Tuple<Int32> id, HttpConnection http, Boolean polling) {
+      if(json.Keys.Contains("instances") && 
+        json["instances"].Count > 0 &&
+        json.Keys.Contains("data") && id.Item1 != 1) {
+        return new Device(json, id, http, polling);
+      }
+      return null;
+    }
+
+    public override String ToString() {
+      return this.Name+"_"+this.Id+" ["+this.Instances.Count+"]";
+    }
+
+    internal void SetUpdate(JsonData json, Match match) {
+      if (match.Groups[2].Value == "data.lastReceived") {
+        if (this.CheckSetUpdateTime(json)) {
+          //this.Update?.Invoke(this, new DeviceUpdateEvent(this.LastUpdate, this.LastUpdate));
+        }
+      }
+    }
+
+    internal void Poll() {
+      foreach (KeyValuePair<Int32, Instance> item in this.Instances) {
+        item.Value.Poll();
+      }
+    }
+  }
+}

Zway/Devices/Instance.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using BlubbFish.IoT.Zway.Devices.CommandClasses;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices {
+  public class Instance {
+    private DateTime nextwakeup;
+    private Boolean polling;
+
+    public delegate void UpdatedInstance(Object sender, DeviceUpdateEvent e);
+    public event UpdatedInstance Update;
+
+    public Int32 DeviceId { get; }
+    public Int32 InstanceId { get; }
+    public ReadOnlyDictionary<ACommandClass.Classes, ACommandClass> CommandClasses { get; private set; }
+
+    private Instance(JsonData json, Tuple<Int32, Int32> id, HttpConnection http, Boolean polling) {
+      this.DeviceId = id.Item1;
+      this.InstanceId = id.Item2;
+      this.polling = polling;
+      this.CreateInstances(json["commandClasses"], http);
+      foreach (KeyValuePair<ACommandClass.Classes, ACommandClass> item in this.CommandClasses) {
+        item.Value.Update += this.ClassUpdate;
+      }
+      this.MakePolltimer();
+    }
+
+    private void MakePolltimer() {
+      if(this.CommandClasses.ContainsKey(ACommandClass.Classes.Wakeup)) {
+        this.nextwakeup = ((Wakeup)this.CommandClasses[ACommandClass.Classes.Wakeup]).LastWakeup.AddSeconds(((Wakeup)this.CommandClasses[ACommandClass.Classes.Wakeup]).Interval).AddSeconds(-20);
+      } else {
+        this.nextwakeup = DateTime.Now.AddSeconds(60);
+      }
+    }
+
+    private void ClassUpdate(Object sender, DeviceUpdateEvent e) {
+      this.Update?.Invoke(this, e);
+    }
+
+    private void CreateInstances(JsonData json, HttpConnection http) {
+      Dictionary<ACommandClass.Classes, ACommandClass> commands = new Dictionary<ACommandClass.Classes, ACommandClass>();
+      foreach (String commandid in json.Keys) {
+        ACommandClass c = ACommandClass.CreateInstance(json[commandid], new Tuple<Int32, Int32, ACommandClass.Classes>(this.DeviceId, this.InstanceId, (ACommandClass.Classes)Int32.Parse(commandid)), http, this.polling);
+        if (c != null) {
+          commands.Add((ACommandClass.Classes)Int32.Parse(commandid), c);
+        }
+      }
+      this.CommandClasses = new ReadOnlyDictionary<ACommandClass.Classes, ACommandClass>(commands);
+    }
+
+    internal static Instance CreateInstance(JsonData json, Tuple<Int32, Int32> id, HttpConnection http, Boolean polling) {
+      if (json.Keys.Contains("commandClasses") &&
+        json["commandClasses"].Count > 0 &&
+        json.Keys.Contains("data")) {
+        return new Instance(json, id, http, polling);
+      }
+      return null;
+    }
+
+    public override String ToString() {
+      return "Instance: " + this.DeviceId + "-" + this.InstanceId + " [" + this.CommandClasses.Count + "]";
+    }
+
+    internal void Poll() {
+      if(DateTime.Now > this.nextwakeup) {
+        this.MakePolltimer();
+        foreach (KeyValuePair<ACommandClass.Classes, ACommandClass> item in this.CommandClasses) {
+          item.Value.Poll();
+        }
+      }
+    }
+  }
+}

Zway/Events/DeviceUpdateEvent.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BlubbFish.IoT.Zway.Events {
+  public class DeviceUpdateEvent : EventArgs {
+
+    public DeviceUpdateEvent() {
+    }
+
+    public DeviceUpdateEvent(Object value, DateTime time, Object parent) {
+      this.GetValue = value;
+      this.UpdateTime = time;
+      this.Parent = parent;
+    }
+
+    public Object GetValue { get; }
+    public DateTime UpdateTime { get;  }
+    public Object Parent { get; private set; }
+  }
+}

Zway/Exceptions/ZwayExceptions.cs

@@ -1,11 +1,8 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Runtime.Serialization;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace BlubbFish.IoT.Zway.Exceptions {
+  [Serializable]
   public class ConnectionException : Exception {
     public ConnectionException() { }
     public ConnectionException(String message) : base(message) { }

Zway/Interfaces/ACommandClass.cs

@@ -0,0 +1,247 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Text.RegularExpressions;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.lib;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Interfaces {
+  public abstract class ACommandClass {
+    protected HttpConnection http;
+
+    public delegate void UpdatedValue(Object sender, DeviceUpdateEvent e);
+    public abstract event UpdatedValue Update;
+    protected enum IgnoredClasses : Int32 {
+      Basic = 32,
+      ControllerReplication = 33,
+      ApplicationStatus = 34,
+      SwitchAll = 39,
+      SceneActivation = 43,
+      SwitchColor = 51,
+      MeterPulse = 53,
+      CRC16 = 86,
+      AssociationGroupInformation = 89,
+      DeviceResetLocally = 90,
+      ZWavePlusInfo = 94,
+      MultiChannel = 96,
+      DoorLock = 98,
+      ManufacturerSpecific = 114,
+      PowerLevel = 115,
+      Protection = 117,
+      NodeNaming = 119,
+      FirmwareUpdate = 122,
+      Association = 133,
+      Version = 134,
+      Proprietary = 136,
+      MultiChannelAssociation = 142,
+      MultiCmd = 143,
+      Security = 152,
+      AlarmSensor = 156 //
+    }
+
+    public enum Classes : Int32 {
+      SwitchBinary = 37,
+      SwitchMultilevel = 38,
+      SceneControllerConf = 45, 
+      SensorBinary = 48,
+      SensorMultilevel = 49,
+      Meter = 50,
+      ThermostatMode = 64,
+      ThermostatSetPoint = 67,
+      CentralScene = 91,
+      Configuration = 112,
+      Alarm = 113,
+      Battery = 128,
+      Wakeup = 132,
+      Indicator = 135
+    }
+
+    public Int32 DeviceId { get; }
+    public Int32 Instance { get; }
+    public Classes Commandclass { get; }
+    public String Id { get; }
+    public Int32 SensorId { get; }
+    public DateTime LastUpdate { get; protected set; }
+    public String Name { get; }
+    public Boolean Polling { get; set; }
+    public Boolean PollOnce { get; set; }
+    public ReadOnlyDictionary<Int32, ACommandClass> Sub { get; protected set; }
+    public Boolean HasSub { get; protected set; }
+    public Boolean IsSub { get; protected set; }
+    public Boolean HasReset { get; protected set; }
+
+    #region Constructor
+
+    protected ACommandClass(JsonData json, Tuple<Int32, Int32, Classes, Int32> id, HttpConnection http, Boolean polling) {
+      this.DeviceId = id.Item1;
+      this.Instance = id.Item2;
+      this.Commandclass = id.Item3;
+      this.SensorId = id.Item4;
+      this.http = http;
+      this.LastUpdate = DateTime.Now;
+      this.Polling = polling;
+      this.HasSub = false;
+      this.HasReset = false;
+      this.IsSub = false;
+      this.Id = this.DeviceId + "-" + this.Instance + "-" + (Int32)this.Commandclass + "-" + this.SensorId;
+      if (ZwayController.namelist.ContainsKey(this.Id)) {
+        this.Name = ZwayController.namelist[this.Id];
+      }
+    }
+
+    protected ACommandClass(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) {
+      this.DeviceId = id.Item1;
+      this.Instance = id.Item2;
+      this.Commandclass = id.Item3;
+      this.http = http;
+      this.LastUpdate = DateTime.Now;
+      this.Polling = polling;
+      this.HasSub = false;
+      this.HasReset = false;
+      this.IsSub = false;
+      this.Id = this.DeviceId + "-" + this.Instance + "-" + (Int32)this.Commandclass;
+      if (ZwayController.namelist.ContainsKey(this.Id)) {
+        this.Name = ZwayController.namelist[this.Id];
+      }
+    }
+
+    internal static ACommandClass CreateInstance(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) {
+      if (json.Keys.Contains("name") &&
+        json.Keys.Contains("data") &&
+        json["data"].Keys.Contains("supported") &&
+        json["data"]["supported"].Keys.Contains("value") &&
+        Boolean.Parse(json["data"]["supported"]["value"].ToString()) &&
+        !Enum.IsDefined(typeof(IgnoredClasses), (Int32)id.Item3) && Enum.IsDefined(typeof(Classes), id.Item3)) {
+        String name = id.Item3.ToString();
+        String objectName = "BlubbFish.IoT.Zway.Devices.CommandClasses." + name[0].ToString().ToUpper() + name.Substring(1).ToLower();
+        return GetInstanceConcrete(objectName, json, http, id, polling);
+      }
+      if (!Enum.IsDefined(typeof(IgnoredClasses), (Int32)id.Item3) && !Enum.IsDefined(typeof(Classes), id.Item3)) {
+        Helper.WriteError("CommandClass " + id.Item3 + " not exist.");
+      }
+      return null;
+    }
+
+    private static ACommandClass GetInstanceConcrete(String objectName, JsonData json, HttpConnection http, Tuple<Int32, Int32, Classes> id, Boolean polling) {
+      Type t = null;
+      try {
+        t = Type.GetType(objectName, true);
+      } catch (TypeLoadException) {
+        Console.Error.WriteLine("Konnte Type " + objectName + " nicht laden!");
+        return null;
+      }
+      return (ACommandClass)t.GetConstructor(new Type[] { typeof(JsonData), typeof(Tuple<Int32, Int32, Classes>), typeof(HttpConnection), typeof(Boolean) }).Invoke(new Object[] { json, id, http, polling });
+    }
+
+    #endregion
+
+    #region Polling
+
+    internal virtual void Poll() {
+      if (this.Polling || this.PollOnce) {
+        this.PollOnce = false;
+        this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + ((Int32)this.Commandclass).ToString() + "].Get()");
+      }
+    }
+
+    protected void PollNone() {
+      this.PollOnce = false;
+    }
+
+    protected void PollSub() {
+      if (this.Polling || this.PollOnce) {
+        this.PollOnce = false;
+        this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + ((Int32)this.Commandclass).ToString() + "].Get(" + this.SensorId + ")");
+      }
+    }
+
+    protected void PollPerSub() {
+      foreach (KeyValuePair<Int32, ACommandClass> item in this.Sub) {
+        item.Value.Poll();
+      }
+    }
+
+    protected void PollSubGlobal() {
+      Boolean poll = false;
+      Boolean pollonce = false;
+      foreach (KeyValuePair<Int32, ACommandClass> item in this.Sub) {
+        if (item.Value.Polling) {
+          poll = true;
+        }
+        if(item.Value.PollOnce) {
+          pollonce = true;
+        }
+      }
+      if (poll || pollonce) {
+        this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + ((Int32)this.Commandclass).ToString() + "].Get()");
+      }
+    }
+
+    #endregion
+
+    #region SetValues
+
+    protected void SetInt(Int32 value) {
+      this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + ((Int32)this.Commandclass).ToString() + "].Set(" + value + ")");
+    }
+
+    protected void SetTuple(Double value1, Double value2) {
+      this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + ((Int32)this.Commandclass).ToString() + "].Set(" + value1 + "," + value2 + ")");
+    }
+
+    protected void SetTriple(Double v1, Double v2, Double v3) {
+      this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + ((Int32)this.Commandclass).ToString() + "].Set(" + v1 + "," + v2 + "," + v3 + ")");
+    }
+
+    protected Boolean CheckSetUpdateTime(JsonData json) {
+      if (json.Keys.Contains("updateTime") && (json["updateTime"].IsInt || json["updateTime"].IsLong)) {
+        DateTime newdate = DateTimeOffset.FromUnixTimeSeconds(Int64.Parse(json["updateTime"].ToString())).ToLocalTime().DateTime;
+        if (newdate > this.LastUpdate) {
+          this.LastUpdate = newdate;
+          return true;
+        } else {
+          return false;
+        }
+      } else {
+        return true;
+      }
+    }
+
+    public virtual void Reset() {
+      if (this.HasReset) {
+        this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + ((Int32)this.Commandclass).ToString() + "].Reset()");
+      }
+    }
+
+    #endregion
+
+    #region Output
+
+    public String MqttTopic() {
+      return this.DeviceId + "/" + this.Instance + "/" + ((Int32)this.Commandclass).ToString() + (this.IsSub ? "/" + this.SensorId : "");
+    }
+
+    public String ToJson() {
+      Dictionary<String, Object> json = this.ToDictionary();
+      json.Add("LastUpdate", this.LastUpdate.ToString());
+      json.Add("Name", this.Name);
+      json.Add("Commandclass", this.Commandclass.ToString());
+      return JsonMapper.ToJson(json);
+    }
+
+    public abstract Dictionary<String, Object> ToDictionary();
+
+    protected Dictionary<String, Object> ToDictionarySub() {
+      Dictionary<String, Object> json = new Dictionary<String, Object>();
+      foreach (KeyValuePair<Int32, ACommandClass> item in this.Sub) {
+        json.Add(item.Key.ToString(), item.Value.ToDictionary());
+      }
+      return json;
+    }
+
+    #endregion
+
+    internal abstract void SetUpdate(JsonData json, Match match);
+  }
+}

Zway/Properties/AssemblyInfo.cs

@@ -10,7 +10,7 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
 [assembly: AssemblyProduct("Zway")]
-[assembly: AssemblyCopyright("Copyright ©  2017")]
+[assembly: AssemblyCopyright("Copyright ©  2017 - 23.12.2017")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 
@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // Sie können alle Werte angeben oder Standardwerte für die Build- und Revisionsnummern verwenden,
 // indem Sie "*" wie unten gezeigt eingeben:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyVersion("1.3.5.1")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.3.5.1")]

Zway/Zway.csproj

@@ -30,6 +30,9 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="LitJson, Version=0.9.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\..\IoT-Bot\packages\LitJson.0.9.0\lib\LitJson.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Xml.Linq" />
@@ -40,11 +43,39 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Devices\CommandClasses\Alarm.cs" />
+    <Compile Include="Devices\CommandClasses\Battery.cs" />
+    <Compile Include="Devices\CommandClasses\CommandClassSubs\Configurationsub.cs" />
+    <Compile Include="Devices\CommandClasses\CommandClassSubs\SceneControllerConfSub.cs" />
+    <Compile Include="Devices\CommandClasses\CommandClassSubs\SensorBinarySub.cs" />
+    <Compile Include="Devices\CommandClasses\CommandClassSubs\ThermostatSetPointSub.cs" />
+    <Compile Include="Devices\CommandClasses\Configuration.cs" />
+    <Compile Include="Devices\CommandClasses\Indicator.cs" />
+    <Compile Include="Devices\CommandClasses\Meter.cs" />
+    <Compile Include="Devices\CommandClasses\CommandClassSubs\MeterSub.cs" />
+    <Compile Include="Devices\CommandClasses\CommandClassSubs\SensorMultilevelSub.cs" />
+    <Compile Include="Devices\CommandClasses\SceneControllerConf.cs" />
+    <Compile Include="Devices\CommandClasses\SensorBinary.cs" />
+    <Compile Include="Devices\CommandClasses\Wakeup.cs" />
+    <Compile Include="Devices\Device.cs" />
+    <Compile Include="Interfaces\ACommandClass.cs" />
+    <Compile Include="Devices\Instance.cs" />
+    <Compile Include="Devices\CommandClasses\CentralScene.cs" />
+    <Compile Include="Devices\CommandClasses\SensorMultilevel.cs" />
+    <Compile Include="Devices\CommandClasses\SwitchBinary.cs" />
+    <Compile Include="Devices\CommandClasses\ThermostatMode.cs" />
+    <Compile Include="Devices\CommandClasses\SwitchMultilevel.cs" />
+    <Compile Include="Devices\CommandClasses\ThermostatSetPoint.cs" />
+    <Compile Include="Events\DeviceUpdateEvent.cs" />
     <Compile Include="Exceptions\ZwayExceptions.cs" />
+    <Compile Include="lib\Helper.cs" />
     <Compile Include="lib\HttpClient.cs" />
     <Compile Include="ZwayController.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
   <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
 </Project>

Zway/ZwayController.cs

@@ -1,24 +1,193 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
+using System.Collections.ObjectModel;
-using System.Text;
+using System.Globalization;
-using System.Threading.Tasks;
+using System.Reflection;
+using System.Text.RegularExpressions;
+using System.Threading;
+using BlubbFish.IoT.Zway.Devices;
+using BlubbFish.IoT.Zway.Events;
+using BlubbFish.IoT.Zway.Interfaces;
 using BlubbFish.IoT.Zway.lib;
+using LitJson;
 
 namespace BlubbFish.IoT.Zway {
-  public class ZwayController {
+  public class ZwayController : IDisposable {
     private HttpConnection http;
+    private Thread updatethread;
+    private Thread pollthread;
+    public static ReadOnlyDictionary<String, String> namelist;
+    private Boolean polling;
 
-    public ZwayController(String server, String user, String pass) {
+    public delegate void DataUpdate(Object sender, DeviceUpdateEvent e);
+    public event DataUpdate Update;
+
+    public ReadOnlyDictionary<Int32, Device> Devices { get; private set; }
+
+    public ZwayController(String server, String user, String pass, Dictionary<String, String> names, Boolean enablePoll = true) {
+      namelist = new ReadOnlyDictionary<String, String>(names);
+      this.polling = enablePoll;
       this.Connect(server, user, pass);
     }
 
-    public ZwayController(Dictionary<String, String> settings) {
+    public ZwayController(Dictionary<String, String> settings, Dictionary<String, String> names, Boolean enablePoll = true) {
+      namelist = new ReadOnlyDictionary<String, String>(names);
+      this.polling = enablePoll;
       this.Connect(settings["server"], settings["user"], settings["pass"]);
     }
 
     private void Connect(String server, String user, String pass) {
       this.http = new HttpConnection(server, user, pass);
+      CultureInfo info = new CultureInfo("de-DE");
+      info.NumberFormat.NumberDecimalSeparator = ".";
+      CultureInfo.DefaultThreadCurrentCulture = info;
+      CultureInfo.DefaultThreadCurrentUICulture = info;
+      Thread.CurrentThread.CurrentCulture = info;
+      Thread.CurrentThread.CurrentUICulture = info;
+      this.CreateDevices(this.http.GetJson("ZWaveAPI/Run/devices"));
+      this.updatethread = new Thread(this.Updater);
+      this.updatethread.Start();
+      this.pollthread = new Thread(this.Poll);
+      this.pollthread.Start();
+      foreach (KeyValuePair<Int32, Device> item in this.Devices) {
+        item.Value.Update += this.DeviceUpdate;
       }
     }
+
+    private void DeviceUpdate(Object sender, DeviceUpdateEvent e) {
+      this.Update?.Invoke(sender, e);
+    }
+
+    private void Poll() {
+      CultureInfo info = new CultureInfo("de-DE");
+      info.NumberFormat.NumberDecimalSeparator = ".";
+      CultureInfo.DefaultThreadCurrentCulture = info;
+      CultureInfo.DefaultThreadCurrentUICulture = info;
+      Thread.CurrentThread.CurrentCulture = info;
+      Thread.CurrentThread.CurrentUICulture = info;
+      while(true) {
+        foreach (KeyValuePair<Int32, Device> item in this.Devices) {
+          item.Value.Poll();
+        }
+        Thread.Sleep(1000);
+      }
+    }
+
+    public ACommandClass GetCommandClass(String id) {
+      String[] addr = id.Split('-');
+      if (addr.Length == 3 || addr.Length == 4) {
+        return this.GetCommandClass(Int32.Parse(addr[0]), Int32.Parse(addr[1]), (ACommandClass.Classes)Int32.Parse(addr[2]), (addr.Length == 4 ? Int32.Parse(addr[3]) : -1));
+      }
+      return null;
+    }
+
+    public ACommandClass GetCommandClass(Int32 deviceid, Int32 instanceid, ACommandClass.Classes classid, Int32 subcid = -1) {
+      if(this.Devices.ContainsKey(deviceid) && this.Devices[deviceid].Instances.ContainsKey(instanceid) && this.Devices[deviceid].Instances[instanceid].CommandClasses.ContainsKey(classid)) {
+        ACommandClass commandclass = this.Devices[deviceid].Instances[instanceid].CommandClasses[classid];
+        if(subcid == -1) {
+          return commandclass;
+        }
+        if (commandclass != null) {
+          if(commandclass.HasSub) {
+            if(commandclass.Sub.ContainsKey(subcid)) {
+              return commandclass.Sub[subcid];
+            }
+          }
+        }
+      }
+      return null;
+    }
+
+    private void Updater() {
+      CultureInfo info = new CultureInfo("de-DE");
+      info.NumberFormat.NumberDecimalSeparator = ".";
+      CultureInfo.DefaultThreadCurrentCulture = info;
+      CultureInfo.DefaultThreadCurrentUICulture = info;
+      Thread.CurrentThread.CurrentCulture = info;
+      Thread.CurrentThread.CurrentUICulture = info;
+      while (true) {
+        Int64 date = ((DateTimeOffset)DateTime.Now.AddSeconds(-2)).ToUnixTimeSeconds();
+        JsonData notifications = this.http.GetJson("ZWave.zway/Data/"+date);
+        foreach (String item in notifications.Keys) {
+          Match match = new Regex("^devices\\.([0-9]+)\\.instances\\.([0-9]+)\\.commandClasses\\.([0-9]+)(\\.data\\.([0-9]+)|\\.data\\.[a-z].*|\\.data)$", RegexOptions.IgnoreCase).Match(item);
+          if(match.Success) {
+            Int32 deviceid = Int32.Parse(match.Groups[1].Value);
+            Int32 instanceid = Int32.Parse(match.Groups[2].Value);
+            ACommandClass.Classes commandid = (ACommandClass.Classes)Int32.Parse(match.Groups[3].Value);
+            if (this.Devices.ContainsKey(deviceid) && this.Devices[deviceid].Instances.ContainsKey(instanceid) && this.Devices[deviceid].Instances[instanceid].CommandClasses.ContainsKey(commandid)) {
+              this.Devices[deviceid].Instances[instanceid].CommandClasses[commandid].SetUpdate(notifications[item], match);
+            }
+          } /*else {
+            if(item.StartsWith("controller.")) { }
+            else if(item == "updateTime") { }
+            else {
+              match = new Regex("^devices\\.([0-9]+)\\.(data.*)", RegexOptions.IgnoreCase).Match(item);
+              if(!match.Success) {
+
+              }
+            }
+          }*/
+          match = new Regex("^devices\\.([0-9]+)\\.(data.*)", RegexOptions.IgnoreCase).Match(item);
+          if(match.Success) {
+            Int32 deviceid = Int32.Parse(match.Groups[1].Value);
+            if (this.Devices.ContainsKey(deviceid)) {
+              this.Devices[deviceid].SetUpdate(notifications[item], match);
+            }
+          }
+        }
+        Thread.Sleep(1500);
+      }
+    }
+
+    private void CreateDevices(JsonData json) {
+      Dictionary<Int32, Device> devices = new Dictionary<Int32, Device>();
+      foreach (String deviceid in json.Keys) {
+        Device d = Device.CreateDevice(json[deviceid], new Tuple<Int32>(Int32.Parse(deviceid)), this.http, this.polling);
+        if (d != null) {
+          devices.Add(Int32.Parse(deviceid), d);
+        }
+      }
+      this.Devices = new ReadOnlyDictionary<Int32, Device>(devices);
+    }
+
+    public Dictionary<String, ACommandClass> GetCommandClasses(ACommandClass.Classes classes) {
+      Dictionary<String, ACommandClass> ret = new Dictionary<String, ACommandClass>();
+      foreach (KeyValuePair<Int32, Device> device in this.Devices) {
+        foreach (KeyValuePair<Int32, Instance> instance in device.Value.Instances) {
+          foreach (KeyValuePair<ACommandClass.Classes, ACommandClass> commandclass in instance.Value.CommandClasses) {
+            if (commandclass.Key == classes) {
+              ret.Add(commandclass.Value.Id, commandclass.Value);
+            }
+          }
+        }
+      }
+      return ret;
+    }
+
+    #region IDisposable Support
+    private Boolean disposedValue = false;
+
+    protected virtual void Dispose(Boolean disposing) {
+      if (!this.disposedValue) {
+        if (disposing) {
+          this.updatethread.Abort();
+          this.pollthread.Abort();
+        }
+        this.updatethread = null;
+        this.pollthread = null;
+        this.Devices = null;
+        this.disposedValue = true;
+      }
+    }
+
+    ~ZwayController() {
+       Dispose(false);
+    }
+
+    public void Dispose() {
+      Dispose(true);
+      GC.SuppressFinalize(this);
+    }
+    #endregion
+  }
 }

Zway/lib/Helper.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace BlubbFish.IoT.Zway.lib {
+  class Helper {
+    internal static void WriteError(String text) {
+      Console.ForegroundColor = ConsoleColor.Red;
+      Console.Error.WriteLine("ERROR: "+text);
+      Console.ResetColor();
+    }
+  }
+}

Zway/lib/HttpClient.cs

@@ -1,40 +1,65 @@
 using System;
-using System.Collections.Generic;
+using System.IO;
-using System.Linq;
+using System.Net;
-using System.Net.Http;
-using System.Net.Http.Headers;
 using System.Text;
-using System.Threading.Tasks;
+using LitJson;
 
 namespace BlubbFish.IoT.Zway.lib {
-  internal class HttpConnection {
+  public class HttpConnection {
-    private HttpClient http;
+    private String auth;
     private String server;
+    private Object getLock = new Object();
 
     internal HttpConnection(String server, String user, String pass) {
-      this.http = new HttpClient();
+      this.auth = "Basic " + Convert.ToBase64String(Encoding.ASCII.GetBytes(user + ":" + pass));
-      //this.http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.ASCII.GetBytes(user + ":" + pass)));
+      this.server = "http://" + server + ":8083/";
-      this.server = "http://" + server + ":8083";
       this.Init();
     }
 
-    private async void Init() {
+    private void Init() {
-      await this.GetString("/ZAutomation/api/v1/status");
+      this.GetString("ZAutomation/api/v1/status");
     }
 
-    private async Task<String> GetString(String v) {
+    internal JsonData GetJson(String v) {
+      String text = this.GetString(v);
+      if(text == null) {
+        return new JsonData();
+      }
       try {
-        HttpResponseMessage response = await this.http.GetAsync(this.server + v);
+        return JsonMapper.ToObject(text);
-        if(response.StatusCode == System.Net.HttpStatusCode.Unauthorized) {
+      } catch(Exception) {
+        return new JsonData();
+      }
+    }
+
+    internal void GetVoid(String v) {
+      this.GetString(v, false);
+    }
+
+    private String GetString(String v, Boolean withoutput = true) {
+      String ret = null;
+      lock (this.getLock) {
+        HttpWebRequest request = WebRequest.CreateHttp(this.server + v);
+        request.Timeout = 5000;
+        request.Headers.Add(HttpRequestHeader.Authorization, this.auth);
+        try {
+          using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) {
+            if (response.StatusCode == HttpStatusCode.Unauthorized) {
               Console.Error.WriteLine("Benutzer oder Passwort falsch!");
               throw new Exceptions.ConnectionException("Benutzer oder Passwort falsch!");
             }
-        HttpContent content = response.Content;
+            if (withoutput) {
-        return await content.ReadAsStringAsync();
+              StreamReader reader = new StreamReader(response.GetResponseStream());
-      } catch(HttpRequestException e) {
+              ret = reader.ReadToEnd();
-        Console.Error.WriteLine("Konnte keine Verbindung zum Razzbery Server herstellen: " + e.Message);
-        throw new Exceptions.ConnectionException("Konnte keine Verbindung zum Razzbery Server herstellen: " + e.Message);
             }
           }
+        } catch (Exception e) {
+          Helper.WriteError("Konnte keine Verbindung zum Razzbery Server herstellen. Resource: \"" + this.server + v + "\" Fehler: " + e.Message);
+          return null;
+          //throw new Exceptions.ConnectionException("Konnte keine Verbindung zum Razzbery Server herstellen: " + e.Message);
+        }
+      }
+      return ret;
+    }
   }
 }

Zway/packages.config

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="LitJson" version="0.9.0" targetFramework="net461" />
+</packages>