Zway [v1.5.0] Throw Exception if 3 times failed to connect to Raspberry server, add 3 new commandlcasses to IgnoredClasses

Zway-Bot [v1.7.0] rewrite to Threaded Modules, edit service file for systemd

Zway/Devices/CommandClasses/Alarm.cs

@@ -0,0 +1,78 @@
+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 BlubbFish.Utils.IoT.Interfaces.Language;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
+  /// <summary>
+  /// 135 = Indicator
+  /// </summary>
+  class Alarm : ACommandClass {
+    public override event UpdatedValue Update;
+
+    #region Properties
+    /// <summary>
+    /// Unklar
+    /// </summary>
+    public Int32 Level { get; private set; }
+    /// <summary>
+    /// unklar
+    /// </summary>
+    public Int32 AlarmType { get; private set; }
+    #endregion
+
+    #region Constructor
+    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());
+      }
+    }
+    #endregion
+
+    #region ACommandClass
+    public override String ToString() {
+      return "Alarm " + this.Name + " [" + this.Id + "]: " + this.AlarmType + " " + this.Level;
+    }
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "AlarmType", this.AlarmType },
+        { "Level", this.Level },
+      };
+    }
+
+    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!");
+      }
+    }
+
+    internal override void Poll() => this.PollNone();
+    #endregion
+
+    #region ISenml
+    protected override List<Senml> ToSenmlList() {
+      return new List<Senml>() { };
+    }
+    #endregion
+  }
+}

Zway/Devices/CommandClasses/AlarmSensor.cs

@@ -0,0 +1,71 @@
+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 BlubbFish.Utils.IoT.Interfaces.Language;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
+  /// <summary>
+  /// 50 = Meter
+  /// </summary>
+  public class Alarmsensor : ACommandClass {
+    public override event UpdatedValue Update;
+
+    #region Constructor
+    public Alarmsensor(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 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("srcId") &&
+            data[item].Keys.Contains("sensorState") &&
+            data[item].Keys.Contains("sensorTime") &&
+            data[item].Keys.Contains("typeString")) {
+            subs.Add(subid, new Alarmsensorsub(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);
+      }
+    }
+
+    private void DeviceUpdate(Object sender, DeviceUpdateEvent e) {
+      this.Update?.Invoke(this, e);
+    }
+    #endregion
+
+    #region ACommandClass
+    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!");
+      }
+    }
+
+    public override Dictionary<String, Object> ToDictionary() => this.ToDictionarySub();
+
+    internal override void Poll() => this.PollSubGlobal();
+    #endregion
+
+    #region ISenml
+    protected override List<Senml> ToSenmlList() => this.ToSenmlListSub();
+    #endregion
+  }
+}

Zway/Devices/CommandClasses/Battery.cs

@@ -4,6 +4,7 @@ using System.Text.RegularExpressions;
 using BlubbFish.IoT.Zway.Events;
 using BlubbFish.IoT.Zway.Interfaces;
 using BlubbFish.IoT.Zway.lib;
+using BlubbFish.Utils.IoT.Interfaces.Language;
 using LitJson;
 
 namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
@@ -11,25 +12,47 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
   /// 128 = Battery
   /// </summary>
   public class Battery : ACommandClass {
-
-    public Single Level { get; private set; }
-
     public override event UpdatedValue Update;
 
+    #region Properties
+    /// <summary>
+    /// Batterylevel in Percent
+    /// </summary>
+    public Double Level { get; private set; }
+    #endregion
+
+    #region Constructor
     public Battery(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("last") && json["data"]["last"].Keys.Contains("value")) {
+        this.Level = Double.Parse(json["data"]["last"]["value"].ToString());
+      }
+    }
+    #endregion
+
+    #region ACommandClass
+    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 },
+      };
+    }
     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 = Single.Parse(json["last"]["value"].ToString());
+          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 = Single.Parse(json["value"].ToString());
+          this.Level = Double.Parse(json["value"].ToString());
           success = true;
         }
       } else if (match.Groups[4].Value.StartsWith(".data.history.")) {
@@ -41,21 +64,13 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
         this.Update?.Invoke(this, new DeviceUpdateEvent(this.Level, this.LastUpdate, this));
       }
     }
+    #endregion
 
-    private void InitComplex(JsonData json) {
+    #region ISenml
-      if (json.Keys.Contains("data") && json["data"].Keys.Contains("last") && json["data"]["last"].Keys.Contains("value")) {
+    protected override List<Senml> ToSenmlList() {
-        this.Level = Single.Parse(json["data"]["last"]["value"].ToString());
+      return new List<Senml>() { new SenmlDouble("chargelevel", Senml.Units.Percent, this.Level) };
-      }
     }
+    #endregion
 
-    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.ToString() },
-      };
-    }
   }
 }

Zway/Devices/CommandClasses/CentralScene.cs

@@ -5,6 +5,7 @@ using System.Text.RegularExpressions;
 using BlubbFish.IoT.Zway.Events;
 using BlubbFish.IoT.Zway.Interfaces;
 using BlubbFish.IoT.Zway.lib;
+using BlubbFish.Utils.IoT.Interfaces.Language;
 using LitJson;
 
 namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
@@ -14,34 +15,31 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
   public class Centralscene : ACommandClass {
     public override event UpdatedValue Update;
 
+    #region Properties
+    /// <summary>
+    /// Combination of Scenes and Modes
+    /// </summary>
     public ReadOnlyDictionary<Int32, ReadOnlyCollection<Int32>> ValidScenesModes { get; private set; }
+    /// <summary>
+    /// Current active Senes
+    /// </summary>
     public Int32 Scene { get; private set; }
+    /// <summary>
+    /// Current active mode
+    /// </summary>
     public Int32 Key { get; private set; }
+    #endregion
 
+    #region Constructor
     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")) {
+        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) &&
@@ -69,18 +67,42 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
         }
       }
     }
+    #endregion
 
+    #region ACommandClass
     public override String ToString() {
-      return "CentralScene " + this.Name + " [" + this.Id + "]: " + this.Scene+"-"+this.Key;
+      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.ToString() },
+        { "Scene", this.Scene },
-        { "key", this.Key.ToString() },
+        { "Key", this.Key },
       };
     }
+
+    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!");
+      }
+    }
+
+    internal override void Poll() => this.PollNone();
+    #endregion
+
+    #region ISenml
+    protected override List<Senml> ToSenmlList() {
+      return new List<Senml>() { new SenmlDouble("scene", Senml.Units.CounterValue, this.Scene), new SenmlDouble("key", Senml.Units.CounterValue, this.Key) };
+    }
+    #endregion
   }
 }

Zway/Devices/CommandClasses/CommandClassSubs/Alarmsensorsub.cs

@@ -0,0 +1,89 @@
+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 BlubbFish.Utils.IoT.Interfaces.Language;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
+  public class Alarmsensorsub : ACommandClass {
+    public override event UpdatedValue Update;
+
+    #region Properties
+    /// <summary>
+    /// 
+    /// </summary>
+    public Int32 Source { get; private set; }
+    /// <summary>
+    /// 
+    /// </summary>
+    public Int32 Level { get; private set; }
+    /// <summary>
+    /// 
+    /// </summary>
+    public Int32 Time { get; private set; }
+    /// <summary>
+    /// 
+    /// </summary>
+    public String Type { get; private set; }
+    #endregion
+
+    #region Constructor
+    public Alarmsensorsub(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("srcId") && json["srcId"].Keys.Contains("value") &&
+        json.Keys.Contains("sensorState") && json["sensorState"].Keys.Contains("value") &&
+        json.Keys.Contains("sensorTime") && json["sensorTime"].Keys.Contains("value") &&
+        json.Keys.Contains("typeString") && json["typeString"].Keys.Contains("value")) {
+        this.Source = Int32.Parse(json["srcId"]["value"].ToString());
+        this.Level = Int32.Parse(json["sensorState"]["value"].ToString());
+        this.Time = Int32.Parse(json["sensorTime"]["value"].ToString());
+        this.Type = json["typeString"]["value"].ToString();
+      }
+    }
+    #endregion
+
+    #region ACommandClass
+    public override String ToString() {
+      return "AlarmSensor " + this.Name + " [" + this.Id + "]: " + this.Type + " " + this.Source + " " + this.Level + " " + this.Time + " " + this.Type;
+    }
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "Source", this.Source },
+        { "Level", this.Level },
+        { "Time", this.Time },
+        { "Type", this.Type }
+      };
+    }
+
+    internal override void SetUpdate(JsonData json, Match match) {
+      if (json.Keys.Contains("srcId") && json["srcId"].Keys.Contains("value") &&
+        json.Keys.Contains("sensorState") && json["sensorState"].Keys.Contains("value") &&
+        json.Keys.Contains("sensorTime") && json["sensorTime"].Keys.Contains("value") &&
+        json.Keys.Contains("typeString") && json["typeString"].Keys.Contains("value") && 
+        this.CheckSetUpdateTime(json)) {
+        this.Source = Int32.Parse(json["srcId"]["value"].ToString());
+        this.Level = Int32.Parse(json["sensorState"]["value"].ToString());
+        this.Time = Int32.Parse(json["sensorTime"]["value"].ToString());
+        this.Type = json["typeString"]["value"].ToString();
+        this.Update?.Invoke(this, new DeviceUpdateEvent(new Tuple<Int32, Int32, Int32, String>(this.Source, this.Level, this.Time, this.Type), this.LastUpdate, this));
+      }
+    }
+
+    internal override void Poll() => this.PollNone();
+    #endregion
+
+    #region ISenml
+    protected override List<Senml> ToSenmlList() {
+      return new List<Senml>() { };
+    }
+    #endregion
+  }
+}

Zway/Devices/CommandClasses/CommandClassSubs/Configurationsub.cs

@@ -4,29 +4,39 @@ using System.Text.RegularExpressions;
 using BlubbFish.IoT.Zway.Events;
 using BlubbFish.IoT.Zway.Interfaces;
 using BlubbFish.IoT.Zway.lib;
+using BlubbFish.Utils.IoT.Interfaces.Language;
 using LitJson;
 
 namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
   class Configurationsub : ACommandClass {
     public override event UpdatedValue Update;
-    private Int64 _level;
 
+    #region Properties
+    private Int64 _level;
+    /// <summary>
+    /// Value of the Configuration Item
+    /// </summary>
     public Int64 Level {
       get {
         return this._level;
       }
       set {
         if (this.Size == 1 && Int16.TryParse(value.ToString(), out Int16 value16)) {
-          this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + this.Commandclass + "].Set(" + this.SensorId + "," + value16 + ",1)");
+          this.SetTriple(this.SensorId, value16, 1);
         } else if(this.Size == 2 && Int32.TryParse(value.ToString(), out Int32 value32)) {
-          this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + this.Commandclass + "].Set(" + this.SensorId + "," + value32 + ",2)");
+          this.SetTriple(this.SensorId, value32, 2);
         } else if(this.Size == 4) {
-          this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + this.Commandclass + "].Set(" + this.SensorId + "," + value + ",4)");
+          this.SetTriple(this.SensorId, value, 4);
         }
       }
     }
+    /// <summary>
+    /// Size of the Configuration slot
+    /// </summary>
     public Int32 Size { get; private set; }
+    #endregion
 
+    #region Constructor
     public Configurationsub(JsonData json, Tuple<Int32, Int32, Classes, Int32> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
       this.IsSub = true;
       InitComplex(json);
@@ -42,8 +52,19 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
         this.Size = Int32.Parse(json["size"]["value"].ToString());
       }
     }
+    #endregion
 
-    internal override void Poll() => this.PollSub();
+    #region ACommandClass
+    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 },
+      };
+    }
 
     internal override void SetUpdate(JsonData json, Match match) {
       if (json.Keys.Contains("val") && json["val"].Keys.Contains("value") && json["val"]["value"] != null &&
@@ -55,15 +76,13 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
       }
     }
 
-    public override String ToString() {
+    internal override void Poll() => this.PollSub();
-      return "Configuration " + this.Name + " [" + this.Id + "]: " + this.Level;
+    #endregion
-    }
 
-    public override Dictionary<String, Object> ToDictionary() {
+    #region ISenml
-      return new Dictionary<String, Object> {
+    protected override List<Senml> ToSenmlList() {
-        { "level", this.Level.ToString() },
+      return new List<Senml>() { };
-        { "size", this.Size.ToString() },
-      };
     }
+    #endregion
   }
 }

Zway/Devices/CommandClasses/CommandClassSubs/MeterSub.cs

@@ -4,15 +4,29 @@ using System.Text.RegularExpressions;
 using BlubbFish.IoT.Zway.Events;
 using BlubbFish.IoT.Zway.Interfaces;
 using BlubbFish.IoT.Zway.lib;
+using BlubbFish.Utils.IoT.Interfaces.Language;
 using LitJson;
 
 namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
   public class Metersub : ACommandClass {
     public override event UpdatedValue Update;
 
+    #region Properties
+    /// <summary>
+    /// Type of the Sensor
+    /// </summary>
     public String Type { get; private set; }
-    public Single Level { get; private set; }
+    /// <summary>
+    /// Actual value of the Sensor
+    /// </summary>
+    public Double Level { get; private set; }
+    /// <summary>
+    /// Scale of the Sensor
+    /// </summary>
     public String Scale { get; private set; }
+    #endregion
+
+    #region Constructor
     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;
@@ -27,35 +41,49 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
         json.Keys.Contains("scaleString") &&
         json["scaleString"].Keys.Contains("value")) {
         this.Type = json["sensorTypeString"]["value"].ToString();
-        this.Level = Single.Parse(json["val"]["value"].ToString());
+        this.Level = Double.Parse(json["val"]["value"].ToString());
         this.Scale = json["scaleString"]["value"].ToString();
       }
     }
+    #endregion
+
+    #region ACommandClass
+    public override String ToString() {
+      return "Meter " + this.Name + " [" + this.Id + "]: " + this.Type + " " + this.Level + "" + this.Scale;
+    }
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "Level", this.Level },
+        { "Type", this.Type },
+        { "Scale", this.Scale },
+      };
+    }
 
     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 = Single.Parse(json["val"]["value"].ToString());
+        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, Single>(this.Type, this.Scale, this.Level), this.LastUpdate, this));
+        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();
+    #endregion
 
-    public override Dictionary<String, Object> ToDictionary() {
+    #region ISenml
-      return new Dictionary<String, Object> {
+    protected override List<Senml> ToSenmlList() {
-        { "level", this.Level.ToString() },
+      if (this.Scale == "W") {
-        { "type", this.Type },
+        return new List<Senml>() { new SenmlDouble("power", Senml.Units.Watt, this.Level) };
-        { "scale", this.Scale },
+      } else if(this.Scale == "kWh") {
-      };
+        return new List<Senml>() { new SenmlDouble("consumption", Senml.Units.Joule, this.Level * 1000 * 3.6 * 1000) };
       }
+      return new List<Senml>() {};
+    }
+    #endregion
   }
 }

Zway/Devices/CommandClasses/CommandClassSubs/SceneControllerConfSub.cs

@@ -0,0 +1,71 @@
+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 BlubbFish.Utils.IoT.Interfaces.Language;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
+  public class Scenecontrollerconfsub : ACommandClass {
+    public override event UpdatedValue Update;
+
+    #region Properties
+    /// <summary>
+    /// 
+    /// </summary>
+    public Int32 Scene { get; private set; }
+    /// <summary>
+    /// 
+    /// </summary>
+    public Int32 Duration { get; private set; }
+    #endregion
+
+    #region Constructor
+    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());
+      }
+    }
+    #endregion
+
+    #region ACommandClass
+    public override String ToString() {
+      return "SceneControllerConf " + this.Name + " [" + this.Id + "]: " + this.Scene + " " + this.Duration;
+    }
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "Scene", this.Scene },
+        { "Duration", this.Duration }
+      };
+    }
+
+    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));
+      }
+    }
+
+    internal override void Poll() => this.PollSub();
+    #endregion
+
+    #region ISenml
+    protected override List<Senml> ToSenmlList() {
+      return new List<Senml>() { };
+    }
+    #endregion
+  }
+}

Zway/Devices/CommandClasses/CommandClassSubs/SensorBinarySub.cs

@@ -0,0 +1,82 @@
+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 BlubbFish.Utils.IoT.Interfaces.Language;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
+  public class Sensorbinarysub : ACommandClass {
+    public override event UpdatedValue Update;
+
+    #region Properties
+    /// <summary>
+    /// 
+    /// </summary>
+    public String Type { get; private set; }
+    /// <summary>
+    /// 
+    /// </summary>
+    public Boolean State { get; private set; }
+    /// <summary>
+    /// 
+    /// </summary>
+    public Int32 Level {
+      get {
+        return (this.State) ? 1 : 0;
+      }
+    }
+    #endregion
+
+    #region Constructor
+    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.State = (Boolean)json["level"]["value"];
+      }
+    }
+    #endregion
+
+    #region ACommandClass
+    public override String ToString() {
+      return "SensorBinary " + this.Name + " [" + this.Id + "]: " + this.Type + " " + this.State.ToString();
+    }
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "State", this.State },
+        { "Type", this.Type },
+        { "Level", this.Level }
+      };
+    }
+
+    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.State = (Boolean)json["level"]["value"];
+        this.Type = json["sensorTypeString"]["value"].ToString();
+        this.Update?.Invoke(this, new DeviceUpdateEvent(new Tuple<String, Boolean>(this.Type, this.State), this.LastUpdate, this));
+      }
+    }
+
+    internal override void Poll() => this.PollNone();
+    #endregion
+
+    #region ISenml
+    protected override List<Senml> ToSenmlList() {
+      return new List<Senml>() { };
+    }
+    #endregion
+  }
+}

Zway/Devices/CommandClasses/CommandClassSubs/SensorMultilevelSub.cs

@@ -4,16 +4,29 @@ using System.Text.RegularExpressions;
 using BlubbFish.IoT.Zway.Events;
 using BlubbFish.IoT.Zway.Interfaces;
 using BlubbFish.IoT.Zway.lib;
+using BlubbFish.Utils.IoT.Interfaces.Language;
 using LitJson;
 
 namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
   public class Sensormultilevelsub : ACommandClass {
     public override event UpdatedValue Update;
 
+    #region Properties
+    /// <summary>
+    /// Type of the Sensor
+    /// </summary>
     public String Type { get; private set; }
-    public Single Level { get; private set; }
+    /// <summary>
+    /// Level of the sensor
+    /// </summary>
+    public Double Level { get; private set; }
+    /// <summary>
+    /// Scale of the sensor
+    /// </summary>
     public String Scale { get; private set; }
+    #endregion
 
+    #region Constructor
     public Sensormultilevelsub(JsonData json, Tuple<Int32, Int32, Classes, Int32> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
       this.IsSub = true;
       InitComplex(json);
@@ -27,35 +40,60 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
         json.Keys.Contains("scaleString") &&
         json["scaleString"].Keys.Contains("value")) {
         this.Type = json["sensorTypeString"]["value"].ToString();
-        this.Level = Single.Parse(json["val"]["value"].ToString());
+        this.Level = Double.Parse(json["val"]["value"].ToString());
         this.Scale = json["scaleString"]["value"].ToString();
       }
     }
+    #endregion
 
-    internal override void SetUpdate(JsonData json, Match match) {
+    #region ACommandClass
-      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 = Single.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, Single>(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.ToString() },
+        { "Level", this.Level },
-        { "type", this.Type },
+        { "Type", this.Type },
-        { "scale", this.Scale },
+        { "Scale", this.Scale },
       };
     }
+
+    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")) {
+        String t = json["sensorTypeString"]["value"].ToString();
+        Double l = Double.Parse(json["val"]["value"].ToString());
+        if (t == "Power" && (l > 3660 || l < 0) ||
+          t == "Temperature" && (l > 65 || l < -25) ||
+          (t == "Temperature" && this.Level >= 4 && Math.Abs(l) <= 0.1)) {
+          return;
+        }
+      }
+      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));
+      }
+    }
+
+    internal override void Poll() => this.PollNone();
+    #endregion
+
+    #region ISenml
+    protected override List<Senml> ToSenmlList() {
+      if(this.Scale == "W") {
+        return new List<Senml>() { new SenmlDouble("power", Senml.Units.Watt, this.Level) };
+      } else if(this.Scale == "°C") {
+        return new List<Senml>() { new SenmlDouble("temperatur", Senml.Units.Celsius, this.Level) };
+      } else if(this.Scale == "Lux") {
+        return new List<Senml>() { new SenmlDouble("luminiscence", Senml.Units.Lux, this.Level) };
+      }
+      return new List<Senml>() { };
+    }
+    #endregion
   }
 }

Zway/Devices/CommandClasses/CommandClassSubs/ThermostatSetPointSub.cs

@@ -4,29 +4,51 @@ using System.Text.RegularExpressions;
 using BlubbFish.IoT.Zway.Events;
 using BlubbFish.IoT.Zway.Interfaces;
 using BlubbFish.IoT.Zway.lib;
+using BlubbFish.Utils.IoT.Interfaces.Language;
 using LitJson;
 
 namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
   class Thermostatsetpointsub : ACommandClass {
     public override event UpdatedValue Update;
 
-    private Single _level;
+    #region Properties
-    public Single Level {
+    private Double _level;
+    /// <summary>
+    /// Target-Temperatur
+    /// </summary>
+    public Double Level {
       get {
         return this._level;
       }
       set {
         if (!this.HasMinMax || (this.HasMinMax && value >= this.TempMin && value <= this.TempMax)) {
-          this.SetTuple(this.SensorId, (Single)Math.Round(value * 2, MidpointRounding.AwayFromZero) / 2);
+          this.SetTuple(this.SensorId, (Double)Math.Round(value * 2, MidpointRounding.AwayFromZero) / 2);
         }
       }
     }
+    /// <summary>
+    /// Scale of the actor
+    /// </summary>
     public String Scale { get; private set; }
-    public Single TempMax { get; private set; }
+    /// <summary>
-    public Single TempMin { get; private set; }
+    /// Maximum Temperatur of the actor
+    /// </summary>
+    public Double TempMax { get; private set; }
+    /// <summary>
+    /// Minimum Temperatur of the actor
+    /// </summary>
+    public Double TempMin { get; private set; }
+    /// <summary>
+    /// Has Maximum and Minimum
+    /// </summary>
     public Boolean HasMinMax { get; private set; }
+    /// <summary>
+    /// Type of the actor
+    /// </summary>
     public String Type { get; private set; }
+    #endregion
 
+    #region Constructor
     public Thermostatsetpointsub(JsonData json, Tuple<Int32, Int32, Classes, Int32> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
       this.IsSub = true;
       InitComplex(json);
@@ -37,58 +59,70 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
         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 = Single.Parse(json["val"]["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 = Single.Parse(json["min"]["value"].ToString());
+        this.TempMin = Double.Parse(json["min"]["value"].ToString());
-        this.TempMax = Single.Parse(json["max"]["value"].ToString());
+        this.TempMax = Double.Parse(json["max"]["value"].ToString());
         this.HasMinMax = true;
       } else {
         this.HasMinMax = false;
       }
     }
+    #endregion
+
+    #region ACommandClass
+    public override String ToString() {
+      return "ThermostatSetPoint " + this.Name + " [" + this.Id + "]: " + this.Type + " " + this.Level + "" + this.Scale + " [" + this.TempMin + "," + this.TempMax + "," + this.HasMinMax + "]";
+    }
+
+    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 },
+      };
+    }
 
     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 = Single.Parse(json["val"]["value"].ToString());
+        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 = Single.Parse(json["min"]["value"].ToString());
+        this.TempMin = Double.Parse(json["min"]["value"].ToString());
-        this.TempMax = Single.Parse(json["max"]["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, Single, Single, Single, Boolean>(this.Type, this.Scale, this.Level, this.TempMin, this.TempMax, this.HasMinMax), this.LastUpdate, this));
+        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();
+    #endregion
 
-    public override Dictionary<String, Object> ToDictionary() {
+    #region ISenml
-      return new Dictionary<String, Object> {
+    protected override List<Senml> ToSenmlList() {
-        { "level", this.Level.ToString() },
+      if(this.Scale == "°C") {
-        { "type", this.Type },
+        return new List<Senml>() { new SenmlDouble("temperatur", Senml.Units.Celsius, this.Level) };
-        { "scale", this.Scale },
-        { "tempmax", this.TempMax.ToString() },
-        { "tempmin", this.TempMin.ToString() },
-        { "hasminmax", this.HasMinMax.ToString() },
-      };
       }
+      return new List<Senml>() { };
+    }
+    #endregion
   }
 }

Zway/Devices/CommandClasses/Configuration.cs

@@ -6,6 +6,7 @@ using BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs;
 using BlubbFish.IoT.Zway.Events;
 using BlubbFish.IoT.Zway.Interfaces;
 using BlubbFish.IoT.Zway.lib;
+using BlubbFish.Utils.IoT.Interfaces.Language;
 using LitJson;
 
 namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
@@ -15,6 +16,7 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
   class Configuration : ACommandClass {
     public override event UpdatedValue Update;
 
+    #region Constructor
     public Configuration(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
       this.HasSub = true;
       this.InitComplex(json);
@@ -23,10 +25,6 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
       }
     }
 
-    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"];
@@ -44,6 +42,12 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
       }
     }
 
+    private void DeviceUpdate(Object sender, DeviceUpdateEvent e) {
+      this.Update?.Invoke(this, e);
+    }
+    #endregion
+
+    #region ACommandClass
     internal override void SetUpdate(JsonData json, Match match) {
       if (match.Groups[4].Value.StartsWith(".data.")) {
         Int32 subid = Int32.Parse(match.Groups[5].Value);
@@ -58,5 +62,10 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
     internal override void Poll() => this.PollPerSub();
 
     public override Dictionary<String, Object> ToDictionary() => this.ToDictionarySub();
+    #endregion
+
+    #region ISenml
+    protected override List<Senml> ToSenmlList() => this.ToSenmlListSub();
+    #endregion
   }
 }

Zway/Devices/CommandClasses/Indicator.cs

@@ -4,6 +4,7 @@ using System.Text.RegularExpressions;
 using BlubbFish.IoT.Zway.Events;
 using BlubbFish.IoT.Zway.Interfaces;
 using BlubbFish.IoT.Zway.lib;
+using BlubbFish.Utils.IoT.Interfaces.Language;
 using LitJson;
 
 namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
@@ -11,47 +12,75 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
   /// 135 = Indicator
   /// </summary>
   class Indicator : ACommandClass {
-    private Boolean _level;
-
     public override event UpdatedValue Update;
-    public Boolean Level {
+
+    #region Properties
+    private Boolean _state;
+    /// <summary>
+    /// Status of the Indicator
+    /// </summary>
+    public Boolean State {
       get {
-        return this._level;
+        return this._state;
       }
       set {
         this.SetInt(value ? 255 : 0);
       }
     }
+    /// <summary>
+    /// Int-Representation of the Indicator
+    /// </summary>
+    public Int32 Level {
+      get {
+        return (this.State) ? 1 : 0;
+      }
+      set {
+        this.State = (value == 1);
+      }
+    }
+    #endregion
 
+    #region Constructor
     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;
+        this._state = Int32.Parse(json["data"]["stat"]["value"].ToString()) == 255;
       }
     }
+    #endregion
+
+    #region ACommandClass
+    public override String ToString() {
+      return "Indicator " + this.Name + " [" + this.Id + "]: " + this.State;
+    }
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "State", this.State },
+        { "Level", this.Level }
+      };
+    }
 
     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._state = Int32.Parse(json["value"].ToString()) == 255;
-          this.Update?.Invoke(this, new DeviceUpdateEvent(this.Level, this.LastUpdate, this));
+          this.Update?.Invoke(this, new DeviceUpdateEvent(this.State, this.LastUpdate, this));
         }
       } else {
         Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
       }
     }
+    #endregion
 
-    public override String ToString() {
+    #region ISenml
-      return "Indicator " + this.Name + " [" + this.Id + "]: " + this.Level;
+    protected override List<Senml> ToSenmlList() {
+      return new List<Senml>() { new SenmlBool("status", Senml.Units.CounterValue, this.State) };
     }
+    #endregion
 
-    public override Dictionary<String, Object> ToDictionary() {
-      return new Dictionary<String, Object> {
-        { "level", this.Level.ToString() },
-      };
-    }
   }
 }

Zway/Devices/CommandClasses/Meter.cs

@@ -6,6 +6,7 @@ using BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs;
 using BlubbFish.IoT.Zway.Events;
 using BlubbFish.IoT.Zway.Interfaces;
 using BlubbFish.IoT.Zway.lib;
+using BlubbFish.Utils.IoT.Interfaces.Language;
 using LitJson;
 
 namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
@@ -15,6 +16,7 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
   public class Meter : ACommandClass {
     public override event UpdatedValue Update;
 
+    #region Constructor
     public Meter(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
       this.HasSub = true;
       this.InitComplex(json);
@@ -23,21 +25,6 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
       }
     }
 
-    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"];
@@ -54,8 +41,30 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
       }
     }
 
+    private void DeviceUpdate(Object sender, DeviceUpdateEvent e) {
+      this.Update?.Invoke(this, e);
+    }
+    #endregion
+
+    #region ACommandClass
+    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.PollSubGlobal();
 
     public override Dictionary<String, Object> ToDictionary() => this.ToDictionarySub();
+    #endregion
+
+    #region ISenml
+    protected override List<Senml> ToSenmlList() => this.ToSenmlListSub();
+    #endregion
   }
 }

Zway/Devices/CommandClasses/SceneControllerConf.cs

@@ -0,0 +1,69 @@
+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 BlubbFish.Utils.IoT.Interfaces.Language;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
+  /// <summary>
+  /// 50 = Meter
+  /// </summary>
+  public class Scenecontrollerconf : ACommandClass {
+    public override event UpdatedValue Update;
+
+    #region Constructor
+    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 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);
+      }
+    }
+
+    private void DeviceUpdate(Object sender, DeviceUpdateEvent e) {
+      this.Update?.Invoke(this, e);
+    }
+    #endregion
+
+    #region ACommandClass
+    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();
+    #endregion
+
+    #region ISenml
+    protected override List<Senml> ToSenmlList() => this.ToSenmlListSub();
+    #endregion
+  }
+}

Zway/Devices/CommandClasses/SensorBinary.cs

@@ -0,0 +1,69 @@
+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 BlubbFish.Utils.IoT.Interfaces.Language;
+using LitJson;
+
+namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
+  /// <summary>
+  /// 48 = SensorBinary
+  /// </summary>
+  public class Sensorbinary : ACommandClass {
+    public override event UpdatedValue Update;
+
+    #region Constructor
+    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 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);
+      }
+    }
+
+    private void DeviceUpdate(Object sender, DeviceUpdateEvent e) {
+      this.Update?.Invoke(this, e);
+    }
+    #endregion
+
+    #region ACommandClass
+    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.PollSubGlobal();
+
+    public override Dictionary<String, Object> ToDictionary() => this.ToDictionarySub();
+    #endregion
+
+    #region ISenml
+    protected override List<Senml> ToSenmlList() => this.ToSenmlListSub();
+    #endregion
+  }
+}

Zway/Devices/CommandClasses/SensorMultilevel.cs

@@ -6,6 +6,7 @@ using BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs;
 using BlubbFish.IoT.Zway.Events;
 using BlubbFish.IoT.Zway.Interfaces;
 using BlubbFish.IoT.Zway.lib;
+using BlubbFish.Utils.IoT.Interfaces.Language;
 using LitJson;
 
 namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
@@ -15,6 +16,7 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
   public class Sensormultilevel : ACommandClass {
     public override event UpdatedValue Update;
 
+    #region Constructor
     public Sensormultilevel(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
       this.HasSub = true;
       this.InitComplex(json);
@@ -23,21 +25,6 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
       }
     }
 
-    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"];
@@ -54,8 +41,30 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
       }
     }
 
+    private void DeviceUpdate(Object sender, DeviceUpdateEvent e) {
+      this.Update?.Invoke(this, e);
+    }
+    #endregion
+
+    #region ACommandClass
+    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.PollSubGlobal();
 
     public override Dictionary<String, Object> ToDictionary() => this.ToDictionarySub();
+    #endregion
+
+    #region ISenml
+    protected override List<Senml> ToSenmlList() => this.ToSenmlListSub();
+    #endregion
   }
 }

Zway/Devices/CommandClasses/SwitchBinary.cs

@@ -4,6 +4,7 @@ using System.Text.RegularExpressions;
 using BlubbFish.IoT.Zway.Events;
 using BlubbFish.IoT.Zway.Interfaces;
 using BlubbFish.IoT.Zway.lib;
+using BlubbFish.Utils.IoT.Interfaces.Language;
 using LitJson;
 
 namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
@@ -11,48 +12,74 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
   /// 37 = SwitchBinary
   /// </summary>
   public class Switchbinary : ACommandClass {
-    private Boolean _level;
-
     public override event UpdatedValue Update;
 
-    public Boolean Level {
+    #region Properties
+    /// <summary>
+    /// Int representation of Boolean
+    /// </summary>
+    public Int32 Level {
       get {
-        return this._level;
+        return (this.State) ? 1 : 0;
+      }
+      set {
+        this.State = (value == 1);
+      }
+    }
+    private Boolean _state;
+    /// <summary>
+    /// State if Switch is activated
+    /// </summary>
+    public Boolean State {
+      get {
+        return this._state;
       }
       set {
         this.SetInt(value ? 255 : 0);
       }
     }
+    #endregion
 
+    #region Constructor
     public Switchbinary(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("level") && json["data"]["level"].Keys.Contains("value") && json["data"]["level"]["value"].IsBoolean) {
+        this._state = (Boolean)json["data"]["level"]["value"];
+      }
+    }
+    #endregion
+
+    #region ACommandClass
+    public override String ToString() {
+      return "SwitchBinary " + this.Name + " [" + this.Id + "]: " + this.State;
+    }
+
+    public override Dictionary<String, Object> ToDictionary() {
+      return new Dictionary<String, Object> {
+        { "State", this.State },
+        { "Level", this.Level }
+      };
+    }
+
     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._state = (Boolean)json["value"];
-          this.Update?.Invoke(this, new DeviceUpdateEvent(this.Level, this.LastUpdate, this));
+          this.Update?.Invoke(this, new DeviceUpdateEvent(this.State, this.LastUpdate, this));
         }
       }  else {
         Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
       }
     }
+    #endregion
 
-    private void InitComplex(JsonData json) {
+    #region ISenml
-      if (json.Keys.Contains("data") && json["data"].Keys.Contains("level") && json["data"]["level"].Keys.Contains("value") && json["data"]["level"]["value"].IsBoolean) {
+    protected override List<Senml> ToSenmlList() {
-        this._level = (Boolean)json["data"]["level"]["value"];
+      return new List<Senml>() { new SenmlBool("state", Senml.Units.CounterValue, this.State) };
-      }
-    }
-
-    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.ToString() }
-      };
     }
+    #endregion
   }
 }

Zway/Devices/CommandClasses/SwitchMultilevel.cs

@@ -4,6 +4,7 @@ using System.Text.RegularExpressions;
 using BlubbFish.IoT.Zway.Events;
 using BlubbFish.IoT.Zway.Interfaces;
 using BlubbFish.IoT.Zway.lib;
+using BlubbFish.Utils.IoT.Interfaces.Language;
 using LitJson;
 
 namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
@@ -11,10 +12,13 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
   /// 38 = SwitchMultilevel
   /// </summary>
   public class Switchmultilevel : ACommandClass {
-    private Int32 _level;
-
     public override event UpdatedValue Update;
 
+    #region Properties
+    private Int32 _level;
+    /// <summary>
+    /// Level of thw Switch
+    /// </summary>
     public Int32 Level {
       get {
         return this._level;
@@ -25,11 +29,31 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
         }
       }
     }
+    #endregion
 
+    #region Constructor
     public Switchmultilevel(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("level") && json["data"]["level"].Keys.Contains("value")) {
+        this._level = Int32.Parse(json["data"]["level"]["value"].ToString());
+      }
+    }
+    #endregion
+
+    #region ACommandClass
+    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 }
+      };
+    }
+
     internal override void SetUpdate(JsonData json, Match match) {
       if(match.Groups[4].Value == ".data.level") {
         if(json.Keys.Contains("value") && this.CheckSetUpdateTime(json)) {
@@ -41,21 +65,12 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
         Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
       }
     }
+    #endregion
 
-    private void InitComplex(JsonData json) {
+    #region ISenml
-      if (json.Keys.Contains("data") && json["data"].Keys.Contains("level") && json["data"]["level"].Keys.Contains("value")) {
+    protected override List<Senml> ToSenmlList() {
-        this._level = Int32.Parse(json["data"]["level"]["value"].ToString());
+      return new List<Senml>() { new SenmlDouble("state", Senml.Units.Percent, (Double)this.Level/255) };
-      }
-    }
-
-    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.ToString() }
-      };
     }
+    #endregion
   }
 }

Zway/Devices/CommandClasses/ThermostatMode.cs

@@ -5,6 +5,7 @@ using System.Text.RegularExpressions;
 using BlubbFish.IoT.Zway.Events;
 using BlubbFish.IoT.Zway.Interfaces;
 using BlubbFish.IoT.Zway.lib;
+using BlubbFish.Utils.IoT.Interfaces.Language;
 using LitJson;
 
 namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
@@ -12,11 +13,17 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
   /// 64 = ThermostatMode
   /// </summary>
   public class Thermostatmode : ACommandClass {
-    private Int32 _level;
-
     public override event UpdatedValue Update;
 
+    #region Properties
+    /// <summary>
+    /// Allowd Modes
+    /// </summary>
     public ReadOnlyDictionary<Int32, String> ValidModes { get; private set; }
+    private Int32 _level;
+    /// <summary>
+    /// Actual mode
+    /// </summary>
     public Int32 Level {
       get { return this._level; }
       set {
@@ -25,23 +32,14 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
         }
       }
     }
+    #endregion
 
+    #region Constructor
     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"];
@@ -60,7 +58,9 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
         }
       }
     }
+    #endregion
 
+    #region ACommandClass
     public override String ToString() {
       return "ThermostatMode " + this.Name + " [" + this.Id + "]: " + this.ValidModes[this.Level];
     }
@@ -71,10 +71,28 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
         modes.Add(item.Key.ToString(), item.Value);
       }
       Dictionary<String, Object> json = new Dictionary<String, Object> {
-        { "level", this.Level.ToString() },
+        { "Level", this.Level },
-        { "modes", modes }
+        { "ValidModes", modes }
       };
       return 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!");
+      }
+    }
+    #endregion
+
+    #region ISenml
+    protected override List<Senml> ToSenmlList() {
+      return new List<Senml>() { new SenmlDouble("mode", Senml.Units.CounterValue, this.Level) };
+    }
+    #endregion
   }
 }

Zway/Devices/CommandClasses/ThermostatSetPoint.cs

@@ -6,6 +6,7 @@ using BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs;
 using BlubbFish.IoT.Zway.Events;
 using BlubbFish.IoT.Zway.Interfaces;
 using BlubbFish.IoT.Zway.lib;
+using BlubbFish.Utils.IoT.Interfaces.Language;
 using LitJson;
 
 namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
@@ -15,6 +16,7 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
   public class Thermostatsetpoint : ACommandClass {
     public override event UpdatedValue Update;
 
+    #region Constructor
     public Thermostatsetpoint(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
       this.HasSub = true;
       this.InitComplex(json);
@@ -23,21 +25,6 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
       }
     }
 
-    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"];
@@ -54,8 +41,30 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
       }
     }
 
+    private void DeviceUpdate(Object sender, DeviceUpdateEvent e) {
+      this.Update?.Invoke(this, e);
+    }
+    #endregion
+
+    #region ACommandClass
+    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();
+    #endregion
+
+    #region ISenml
+    protected override List<Senml> ToSenmlList() => this.ToSenmlListSub();
+    #endregion
   }
 }

Zway/Devices/CommandClasses/Wakeup.cs

@@ -4,6 +4,7 @@ using System.Text.RegularExpressions;
 using BlubbFish.IoT.Zway.Events;
 using BlubbFish.IoT.Zway.Interfaces;
 using BlubbFish.IoT.Zway.lib;
+using BlubbFish.Utils.IoT.Interfaces.Language;
 using LitJson;
 
 namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
@@ -11,10 +12,10 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
   /// 132 = Wakeup
   /// </summary>
   class Wakeup : ACommandClass {
-    private Int32 _interval;
-    private Int32 _againstNode;
-
     public override event UpdatedValue Update;
+
+    #region Properties
+    private Int32 _interval;
     public Int32 Interval {
       get {
         return this._interval;
@@ -25,6 +26,7 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
         }
       }
     }
+    private Int32 _againstNode;
     public Int32 AgainstNode { get {
         return this._againstNode;
       }
@@ -34,10 +36,16 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
     }
     public Int32 WakeupMin { get; private set; }
     public Int32 WakeupMax { get; private set; }
+    public Boolean HasMinMaxState { get; private set; }
+    public Int32 HasMinMaxLevel { get { return (this.HasMinMaxState) ? 1 : 0; } }
     public Int32 WakeupDefault { get; private set; }
+    public Boolean HasDefaultState { get; private set; }
+    public Int32 HasDefaultLevel { get { return (this.HasDefaultState) ? 1 : 0; } }
     public DateTime LastWakeup { get; private set; }
     public DateTime LastSleep { get; private set; }
+    #endregion
 
+    #region Constructor
     public Wakeup(JsonData json, Tuple<Int32, Int32, Classes> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
       this.InitComplex(json);
     }
@@ -51,23 +59,50 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
         if (data.Keys.Contains("nodeId") && data["nodeId"].Keys.Contains("value")) {
           this._againstNode = Int32.Parse(data["nodeId"]["value"].ToString());
         }
-        if (data.Keys.Contains("min") && data["min"].Keys.Contains("value")) {
+        this.HasMinMaxState = false;
+        if (data.Keys.Contains("min") && data["min"].Keys.Contains("value") && data["min"]["value"] != null) {
           this.WakeupMin = Int32.Parse(data["min"]["value"].ToString());
+          this.HasMinMaxState = true;
         }
-        if (data.Keys.Contains("max") && data["max"].Keys.Contains("value")) {
+        if (data.Keys.Contains("max") && data["max"].Keys.Contains("value") && data["max"]["value"] != null) {
           this.WakeupMax = Int32.Parse(data["max"]["value"].ToString());
+          this.HasMinMaxState = true;
         }
-        if (data.Keys.Contains("default") && data["default"].Keys.Contains("value")) {
+        this.HasDefaultState = false;
+        if (data.Keys.Contains("default") && data["default"].Keys.Contains("value") && data["default"]["value"] != null) {
           this.WakeupDefault = Int32.Parse(data["default"]["value"].ToString());
+          this.HasDefaultState = true;
         }
-        if (data.Keys.Contains("lastWakeup") && data["lastWakeup"].Keys.Contains("value")) {
+        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")) {
+        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();
         }
       }
     }
+    #endregion
+
+    #region ACommandClass
+    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 },
+        { "HasMinMaxState", this.HasMinMaxState },
+        { "HasMinMaxLevel", this.HasMinMaxLevel },
+        { "WakeupDefault", this.WakeupDefault },
+        { "HasDefaultState", this.HasDefaultState },
+        { "HasDefaultLevel", this.HasDefaultLevel },
+        { "LastWakeup", this.LastWakeup.ToString() },
+        { "LastSleep", this.LastSleep.ToString() }
+      };
+    }
 
     internal override void SetUpdate(JsonData json, Match match) {
       Boolean success = false;
@@ -90,23 +125,28 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
           this._againstNode = Int32.Parse(json["nodeId"]["value"].ToString());
           success = true;
         }
-        if (json.Keys.Contains("min") && json["min"].Keys.Contains("value")) {
+        this.HasMinMaxState = 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.HasMinMaxState = true;
         }
-        if (json.Keys.Contains("max") && json["max"].Keys.Contains("value")) {
+        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.HasMinMaxState = true;
         }
-        if (json.Keys.Contains("default") && json["default"].Keys.Contains("value")) {
+        this.HasDefaultState = 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.HasDefaultState = true;
         }
-        if (json.Keys.Contains("lastWakeup") && json["lastWakeup"].Keys.Contains("value")) {
+        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")) {
+        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;
         }
@@ -117,19 +157,12 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
         this.Update?.Invoke(this, new DeviceUpdateEvent(0, this.LastUpdate, this));
       }
     }
+    #endregion
 
-    public override String ToString() {
+    #region ISenml
-      return "Wakeup " + this.Name + " [" + this.Id + "]: " + this.LastWakeup + "-" + this.LastSleep + " " + this.Interval + " [" + this.WakeupMin + "," + this.WakeupMax + "," + this.WakeupDefault + "," + this.AgainstNode + "]";
+    protected override List<Senml> ToSenmlList() {
-    }
+      return new List<Senml>() { };
-
-    public override Dictionary<String, Object> ToDictionary() {
-      return new Dictionary<String, Object> {
-        { "wakeupmin", this.WakeupMin.ToString() },
-        { "wakeupmax", this.WakeupMax.ToString() },
-        { "wakeupdefault", this.WakeupDefault.ToString() },
-        { "lastwakeup", this.LastWakeup.ToString() },
-        { "lastsleep", this.LastSleep.ToString() }
-      };
     }
+    #endregion
   }
 }

Zway/Devices/Device.cs

@@ -8,7 +8,7 @@ using LitJson;
 
 namespace BlubbFish.IoT.Zway.Devices {
   public class Device {
-    private Boolean polling;
+    private readonly Boolean polling;
 
     public delegate void UpdatedDevice(Object sender, DeviceUpdateEvent e);
     public event UpdatedDevice Update;

Zway/Devices/Instance.cs

@@ -10,7 +10,7 @@ using LitJson;
 namespace BlubbFish.IoT.Zway.Devices {
   public class Instance {
     private DateTime nextwakeup;
-    private Boolean polling;
+    private readonly Boolean polling;
 
     public delegate void UpdatedInstance(Object sender, DeviceUpdateEvent e);
     public event UpdatedInstance Update;

Zway/Events/DeviceUpdateEvent.cs

@@ -10,55 +10,14 @@ namespace BlubbFish.IoT.Zway.Events {
     public DeviceUpdateEvent() {
     }
 
-    public DeviceUpdateEvent(Single value, DateTime time, Object parent) {
+    public DeviceUpdateEvent(Object value, DateTime time, Object parent) {
-      this.GetSingle = value;
+      this.GetValue = value;
       this.UpdateTime = time;
       this.Parent = parent;
     }
 
-    public DeviceUpdateEvent(Boolean value, DateTime time, Object parent) {
+    public Object GetValue { get; }
-      this.GetBoolean = value;
-      this.UpdateTime = time;
-      this.Parent = parent;
-    }
-
-    public DeviceUpdateEvent(DateTime value, DateTime time, Object parent) {
-      this.GetDate = value;
-      this.UpdateTime = time;
-      this.Parent = parent;
-    }
-
-    public DeviceUpdateEvent(Tuple<String, String, Single> value, DateTime time, Object parent) {
-      this.GetStringStringSingleTuple = value;
-      this.UpdateTime = time;
-      this.Parent = parent;
-    }
-    public DeviceUpdateEvent(Tuple<String, String, Single, Single, Single, Boolean> value, DateTime time, Object parent) {
-      this.GetStringStringSingleSingleSingleSingleBooleanTuple = value;
-      this.UpdateTime = time;
-      this.Parent = parent;
-    }
-
-    public DeviceUpdateEvent(Tuple<Int32, Int32> value, DateTime time, Object parent) {
-      this.GetIntegerTuple = value;
-      this.UpdateTime = time;
-      this.Parent = parent;
-    }
-
-    public DeviceUpdateEvent(Tuple<Int64, Int32> value, DateTime time, Object parent) {
-      this.GetLongIntegerTuple = value;
-      this.UpdateTime = time;
-      this.Parent = parent;
-    }
-
-    public Single GetSingle { get; }
-    public DateTime GetDate { get; }
-    public Tuple<String, String, Single> GetStringStringSingleTuple { get; }
-    public Tuple<String, String, Single, Single, Single, Boolean> GetStringStringSingleSingleSingleSingleBooleanTuple { get; }
-    public Tuple<Int64, Int32> GetLongIntegerTuple { get; }
     public DateTime UpdateTime { get;  }
     public Object Parent { get; private set; }
-    public Boolean GetBoolean { get; }
-    public Tuple<Int32,Int32> GetIntegerTuple { get; }
   }
 }

Zway/Interfaces/ACommandClass.cs

@@ -4,10 +4,12 @@ using System.Collections.ObjectModel;
 using System.Text.RegularExpressions;
 using BlubbFish.IoT.Zway.Events;
 using BlubbFish.IoT.Zway.lib;
+using BlubbFish.Utils.IoT.Interfaces;
+using BlubbFish.Utils.IoT.Interfaces.Language;
 using LitJson;
 
 namespace BlubbFish.IoT.Zway.Interfaces {
-  public abstract class ACommandClass {
+  public abstract class ACommandClass : IMqtt, ISenml {
     protected HttpConnection http;
 
     public delegate void UpdatedValue(Object sender, DeviceUpdateEvent e);
@@ -16,36 +18,56 @@ namespace BlubbFish.IoT.Zway.Interfaces {
       Basic = 32,
       ControllerReplication = 33,
       ApplicationStatus = 34,
-      SensorBinary = 48,
+      SwitchAll = 39,
+      SceneActivation = 43,
       SwitchColor = 51,
       MeterPulse = 53,
+      MeterTableMonitor = 61,
+      ThermostatOperatingState = 66,
+      ClimateControlSchedule = 70,
+      CRC16 = 86,
+      AssociationGroupInformation = 89,
+      DeviceResetLocally = 90,
+      ZWavePlusInfo = 94,
       MultiChannel = 96,
-      Alarm = 113,
+      DoorLock = 98,
+      BarrierOperator = 102,
       ManufacturerSpecific = 114,
       PowerLevel = 115,
+      InclusionController = 116,
       Protection = 117,
       NodeNaming = 119,
       FirmwareUpdate = 122,
+      Clock = 129,
       Association = 133,
       Version = 134,
+      Proprietary = 136,
+      TimeParameters = 139,
       MultiChannelAssociation = 142,
-      MultiCmd = 143
+      MultiCmd = 143,
+      SimpleAVControl = 148,
+      Security = 152
     }
 
     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
+      Indicator = 135,
+      AlarmSensor = 156
     }
 
+    #region Properties
     public Int32 DeviceId { get; }
     public Int32 Instance { get; }
     public Classes Commandclass { get; }
@@ -59,9 +81,9 @@ namespace BlubbFish.IoT.Zway.Interfaces {
     public Boolean HasSub { get; protected set; }
     public Boolean IsSub { get; protected set; }
     public Boolean HasReset { get; protected set; }
+    #endregion
 
     #region Constructor
-
     protected ACommandClass(JsonData json, Tuple<Int32, Int32, Classes, Int32> id, HttpConnection http, Boolean polling) {
       this.DeviceId = id.Item1;
       this.Instance = id.Item2;
@@ -107,7 +129,7 @@ namespace BlubbFish.IoT.Zway.Interfaces {
         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.");
+        Helper.WriteError("CommandClass " + id.Item3 + " not exist. (" + id.Item1 + ", " + id.Item2 + ")");
       }
       return null;
     }
@@ -153,13 +175,16 @@ namespace BlubbFish.IoT.Zway.Interfaces {
 
     protected void PollSubGlobal() {
       Boolean poll = false;
+      Boolean pollonce = false;
       foreach (KeyValuePair<Int32, ACommandClass> item in this.Sub) {
         if (item.Value.Polling) {
           poll = true;
-          break;
+        }
+        if(item.Value.PollOnce) {
+          pollonce = true;
         }
       }
-      if (poll) {
+      if (poll || pollonce) {
         this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + ((Int32)this.Commandclass).ToString() + "].Get()");
       }
     }
@@ -167,16 +192,17 @@ namespace BlubbFish.IoT.Zway.Interfaces {
     #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(Single value1, Single value2) {
+    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 SetTuple(Int32 v1, Int32 v2) => this.SetTuple(v1, (Single)v2);
+    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)) {
@@ -200,22 +226,7 @@ namespace BlubbFish.IoT.Zway.Interfaces {
 
     #endregion
 
-    #region Output
+    #region InternalHelper
-
-    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("date", this.LastUpdate.ToString());
-      json.Add("name", this.Name);
-      json.Add("class", 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) {
@@ -224,8 +235,52 @@ namespace BlubbFish.IoT.Zway.Interfaces {
       return json;
     }
 
+    protected List<Senml> ToSenmlListSub() {
+      List<Senml> list = new List<Senml>();
+      foreach (KeyValuePair<Int32, ACommandClass> item in this.Sub) {
+        list.AddRange(item.Value.ToSenmlList());
+      }
+      return list;
+    }
     #endregion
 
+    #region IMqtt
+    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);
+    }
+    #endregion
+
+    #region ISenml
+    public String ToSenml() {
+      List<Senml> l = this.ToSenmlList();
+      if(l.Count == 0) {
+        return null;
+      }
+      Dictionary<String, Object> json = new Dictionary<String, Object> {
+        { "e", l },
+        { "bn", this.DeviceId + "/" + this.Instance + "/" + ((Int32)this.Commandclass).ToString() + (this.IsSub ? "/" + this.SensorId : "") + "/" },
+        { "bt", ((DateTimeOffset)this.LastUpdate).ToUnixTimeSeconds() }
+      };
+      return JsonMapper.ToJson(json);
+    }
+
+    public String SenmlTopic() {
+      return "LS/v2/ZGW/";
+    }
+    #endregion
+
+    #region Abstract
+    protected abstract List<Senml> ToSenmlList();
+    public abstract Dictionary<String, Object> ToDictionary();
     internal abstract void SetUpdate(JsonData json, Match match);
+    #endregion
   }
 }

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 - 29.09.2018")]
 [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.3.0.0")]
+[assembly: AssemblyVersion("1.5.0")]
-[assembly: AssemblyFileVersion("1.3.0.0")]
+[assembly: AssemblyFileVersion("1.5.0")]

Zway/Zway.csproj

@@ -9,8 +9,9 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>BlubbFish.IoT.Zway</RootNamespace>
     <AssemblyName>Zway</AssemblyName>
-    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.7.1</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -30,9 +31,6 @@
     <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" />
@@ -43,14 +41,21 @@
     <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\Alarmsensorsub.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\AlarmSensor.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" />
@@ -69,8 +74,14 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="packages.config" />
+    <ProjectReference Include="..\..\Librarys\litjson\litjson\litjson_4.7.1.csproj">
+      <Project>{91a14cd2-2940-4500-8193-56d37edddbaa}</Project>
+      <Name>litjson_4.7.1</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\Utils\IoT\Interfaces\Iot-Interfaces.csproj">
+      <Project>{4daada29-c600-4cf3-8ad3-9c97c8d7f632}</Project>
+      <Name>Iot-Interfaces</Name>
+    </ProjectReference>
   </ItemGroup>
-  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
 </Project>

Zway/ZwayController.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Globalization;
-using System.Reflection;
 using System.Text.RegularExpressions;
 using System.Threading;
 using BlubbFish.IoT.Zway.Devices;
@@ -17,7 +16,7 @@ namespace BlubbFish.IoT.Zway {
     private Thread updatethread;
     private Thread pollthread;
     public static ReadOnlyDictionary<String, String> namelist;
-    private Boolean polling;
+    private readonly Boolean polling;
 
     public delegate void DataUpdate(Object sender, DeviceUpdateEvent e);
     public event DataUpdate Update;
@@ -105,9 +104,11 @@ namespace BlubbFish.IoT.Zway {
       CultureInfo.DefaultThreadCurrentUICulture = info;
       Thread.CurrentThread.CurrentCulture = info;
       Thread.CurrentThread.CurrentUICulture = info;
+      DateTime lastRequest = DateTime.Now.AddSeconds(-2);
       while (true) {
-        Int64 date = ((DateTimeOffset)DateTime.Now.AddSeconds(-2)).ToUnixTimeSeconds();
+        Int64 date = ((DateTimeOffset)lastRequest).ToUnixTimeSeconds();
-        JsonData notifications = this.http.GetJson("ZWave.zway/Data/"+date);
+        lastRequest = DateTime.Now;
+        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) {

Zway/lib/HttpClient.cs

@@ -6,9 +6,9 @@ using LitJson;
 
 namespace BlubbFish.IoT.Zway.lib {
   public class HttpConnection {
-    private String auth;
+    private readonly String auth;
-    private String server;
+    private readonly String server;
-    private Object getLock = new Object();
+    private static readonly Object getLock = new Object();
 
     internal HttpConnection(String server, String user, String pass) {
       this.auth = "Basic " + Convert.ToBase64String(Encoding.ASCII.GetBytes(user + ":" + pass));
@@ -17,11 +17,23 @@ namespace BlubbFish.IoT.Zway.lib {
     }
 
     private void Init() {
-      this.GetString("ZAutomation/api/v1/status");
+      this.GetVoid("ZAutomation/api/v1/status");
     }
 
     internal JsonData GetJson(String v) {
-      String text = this.GetString(v);
+      String text = null;
+      for (Int32 i = 0; i < 3; i++) {
+        try {
+          text = this.GetString(v);
+          break;
+        } catch (Exception e) {
+          Helper.WriteError(e.Message);
+          if(i==2) {
+            throw;
+          }
+          System.Threading.Thread.Sleep(30000);
+        }
+      }
       if(text == null) {
         return new JsonData();
       }
@@ -33,14 +45,25 @@ namespace BlubbFish.IoT.Zway.lib {
     }
 
     internal void GetVoid(String v) {
+      for (Int32 i = 0; i < 3; i++) {
+        try {
           this.GetString(v, false);
+          break;
+        } catch (Exception e) {
+          Helper.WriteError(e.Message);
+          if (i == 2) {
+            throw;
+          }
+          System.Threading.Thread.Sleep(30000);
+        }
+      }
     }
 
     private String GetString(String v, Boolean withoutput = true) {
       String ret = null;
-      lock (this.getLock) {
+      lock (getLock) {
         HttpWebRequest request = WebRequest.CreateHttp(this.server + v);
-        request.Timeout = 5000;
+        request.Timeout = 10000;
         request.Headers.Add(HttpRequestHeader.Authorization, this.auth);
         try {
           using (HttpWebResponse response = (HttpWebResponse)request.GetResponse()) {
@@ -54,9 +77,9 @@ namespace BlubbFish.IoT.Zway.lib {
             }
           }
         } catch (Exception e) {
-          Helper.WriteError("Konnte keine Verbindung zum Razzbery Server herstellen. Resource: \"" + this.server + v + "\" Fehler: " + e.Message);
+          //Helper.WriteError("Konnte keine Verbindung zum Razzbery Server herstellen. Resource: \"" + this.server + v + "\" Fehler: " + e.Message);
-          return null;
+          //return null;
-          //throw new Exceptions.ConnectionException("Konnte keine Verbindung zum Razzbery Server herstellen: " + e.Message);
+          throw new Exceptions.ConnectionException("Konnte keine Verbindung zum Razzbery Server herstellen: " + e.Message);
         }
       }
       return ret;

Zway/packages.config

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