vs_projects/Zway
1
0
Fork 0
Code Issues Pull Requests Releases 25 Wiki Activity

[NF] Zway-Bot hinzugefügt

Browse Source 
[NF] Viele kleine Änderungen an Zwaylib zur Verbesserung der Kompatibilität
This commit is contained in:
BlubbFish 2017-11-25 11:00:48 +00:00
parent 88fa19a604
commit 99dc37d751
26 changed files with 437 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
Zway/Devices/CommandClass.cs
View File

@ -1,15 +1,18 @@
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;
using BlubbFish.IoT.Zway.Events;
using BlubbFish.IoT.Zway.Interfaces;
using BlubbFish.IoT.Zway.lib;
using LitJson;
namespace BlubbFish.IoT.Zway.Devices {
public abstract class CommandClass {
public abstract class CommandClass : ICommandClass {
protected HttpConnection http;
public abstract event UpdatedValue Update;
private enum Ignored {
Basic = 32,
Configuration = 112,
ManufacturerSpecific = 114,
PowerLevel = 115,
Protection = 117,
@ -24,17 +27,22 @@ namespace BlubbFish.IoT.Zway.Devices {
public Int32 DeviceId { get; }
public Int32 Instance { get; }
public Int32 Commandclass { get; }
public String Name { get; }
public String Id { get; }
public DateTime LastUpdate { get; private set; }
public String Name { get; }
public Boolean Polling { get; set; }
protected CommandClass(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id) {
protected CommandClass(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id, Boolean polling) {
this.DeviceId = id.Item1;
this.Instance = id.Item2;
this.Commandclass = id.Item3;
this.Name = this.DeviceId + "-" + this.Instance + "-" + this.Commandclass;
this.http = http;
this.LastUpdate = DateTime.Now;
this.Polling = polling;
this.Id = this.DeviceId + "-" + this.Instance + "-" + this.Commandclass;
if (ZwayController.namelist.ContainsKey(this.Id)) {
this.Name = ZwayController.namelist[this.Id];
}
}
protected Boolean CheckSetUpdateTime(JsonData json) {
@ -51,7 +59,7 @@ namespace BlubbFish.IoT.Zway.Devices {
}
}
internal static CommandClass CreateInstance(JsonData json, Tuple<Int32, Int32, Int32> id, HttpConnection http) {
internal static CommandClass CreateInstance(JsonData json, Tuple<Int32, Int32, Int32> id, HttpConnection http, Boolean polling) {
if (json.Keys.Contains("name") &&
json.Keys.Contains("data") &&
json["data"].Keys.Contains("supported") &&
@ -60,12 +68,12 @@ namespace BlubbFish.IoT.Zway.Devices {
!Enum.IsDefined(typeof(Ignored), id.Item3)) {
String name = json["name"].ToString();
String objectName = "BlubbFish.IoT.Zway.Devices.CommandClasses." + name[0].ToString().ToUpper() + name.Substring(1).ToLower();
return GetInstanceConcrete(objectName, json, http, id);
return GetInstanceConcrete(objectName, json, http, id, polling);
}
return null;
}
private static CommandClass GetInstanceConcrete(String objectName, JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id) {
private static CommandClass GetInstanceConcrete(String objectName, JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id, Boolean polling) {
Type t = null;
try {
t = Type.GetType(objectName, true);
@ -73,18 +81,16 @@ namespace BlubbFish.IoT.Zway.Devices {
Console.Error.WriteLine("Konnte Type " + objectName + " nicht laden!");
return null;
}
return (CommandClass)t.GetConstructor(new Type[] { typeof(JsonData), typeof(HttpConnection), typeof(Tuple<Int32, Int32, Int32>) }).Invoke(new Object[] { json, http, id });
return (CommandClass)t.GetConstructor(new Type[] { typeof(JsonData), typeof(HttpConnection), typeof(Tuple<Int32, Int32, Int32>), typeof(Boolean) }).Invoke(new Object[] { json, http, id, polling });
}
protected abstract void InitComplex(JsonData json);
internal abstract void SetUpdate(JsonData json, Match match);
public delegate void UpdatedValue(Object sender, DeviceUpdateEvent e);
public abstract event UpdatedValue Update;
internal virtual void Poll() {
if(this.Polling) {
this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + this.Commandclass + "].Get()");
}
}
protected void SetInt(Int32 value) {
this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + this.Commandclass + "].Set("+value+")");

25
Zway/Devices/CommandClassSub.cs
View File

@ -1,31 +1,35 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BlubbFish.IoT.Zway.Events;
using BlubbFish.IoT.Zway.Interfaces;
using BlubbFish.IoT.Zway.lib;
using LitJson;
namespace BlubbFish.IoT.Zway.Devices {
public abstract class CommandClassSub {
public abstract class CommandClassSub : ICommandClass {
protected HttpConnection http;
public abstract event UpdatedValue Update;
public String Id { get; }
public Int32 DeviceId { get; }
public Int32 Instance { get; }
public Int32 Commandclass { get; }
public Int32 SensorId { get; }
public String Name { get; }
public DateTime LastUpdate { get; private set; }
public Boolean Polling { get; set; }
protected CommandClassSub(JsonData json, Tuple<Int32, Int32, Int32, Int32> id, HttpConnection http) {
protected CommandClassSub(JsonData json, Tuple<Int32, Int32, Int32, Int32> id, HttpConnection http, Boolean polling) {
this.DeviceId = id.Item1;
this.Instance = id.Item2;
this.Commandclass = id.Item3;
this.SensorId = id.Item4;
this.http = http;
this.Name = this.DeviceId + "-" + this.Instance + "-" + this.Commandclass + "-" + this.SensorId;
this.LastUpdate = DateTime.Now;
this.Polling = polling;
this.Id = this.DeviceId + "-" + this.Instance + "-" + this.Commandclass + "-" + this.SensorId;
if (ZwayController.namelist.ContainsKey(this.Id)) {
this.Name = ZwayController.namelist[this.Id];
}
}
protected Boolean CheckSetUpdateTime(JsonData json) {
@ -41,11 +45,8 @@ namespace BlubbFish.IoT.Zway.Devices {
return true;
}
}
protected abstract void InitComplex(JsonData json);
internal abstract void SetUpdate(JsonData json, Match match);
public delegate void UpdatedValue(Object sender, DeviceUpdateEvent e);
public abstract event UpdatedValue Update;
internal abstract void Poll();
}
}

12
Zway/Devices/CommandClasses/Battery.cs
View File

@ -1,17 +1,21 @@
using System;
using System.Text.RegularExpressions;
using BlubbFish.IoT.Zway.Events;
using BlubbFish.IoT.Zway.Interfaces;
using BlubbFish.IoT.Zway.lib;
using LitJson;
namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
/// <summary>
/// 128 = Battery
/// </summary>
public class Battery : CommandClass {
public Single Level { get; private set; }
public override event UpdatedValue Update;
public Battery(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id) : base(json, http, id) {
public Battery(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id, Boolean polling) : base(json, http, id, polling) {
this.InitComplex(json);
}
@ -30,21 +34,21 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
} else if (match.Groups[4].Value.StartsWith(".data.history.")) {
} else if (match.Groups[4].Value == ".data.lastChange") {
} else {
throw new NotImplementedException();
Helper.WriteError("Kenne in "+this.Name+" ["+this.Id+"] "+ match.Groups[4].Value+" nicht!");
}
if (success && this.CheckSetUpdateTime(json)) {
this.Update?.Invoke(this, new DeviceUpdateEvent(this.Level, this.LastUpdate));
}
}
protected override void InitComplex(JsonData json) {
private void InitComplex(JsonData json) {
if (json.Keys.Contains("data") && json["data"].Keys.Contains("last") && json["data"]["last"].Keys.Contains("value")) {
this.Level = Single.Parse(json["data"]["last"]["value"].ToString());
}
}
public override String ToString() {
return "Battery " + this.Name + ": " + this.Level;
return "Battery " + this.Name + " [" + this.Id + "]: " + this.Level;
}
}
}

12
Zway/Devices/CommandClasses/CentralScene.cs
View File

@ -3,10 +3,14 @@ using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Text.RegularExpressions;
using BlubbFish.IoT.Zway.Events;
using BlubbFish.IoT.Zway.Interfaces;
using BlubbFish.IoT.Zway.lib;
using LitJson;
namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
/// <summary>
/// 91 = CentralScene
/// </summary>
public class Centralscene : CommandClass {
public override event UpdatedValue Update;
@ -14,7 +18,7 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
public Int32 Scene { get; private set; }
public Int32 Key { get; private set; }
public Centralscene(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id) : base(json, http, id) {
public Centralscene(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id, Boolean polling) : base(json, http, id, polling) {
this.ValidScenesModes = new ReadOnlyDictionary<Int32, ReadOnlyCollection<Int32>>(new Dictionary<Int32, ReadOnlyCollection<Int32>>());
this.InitComplex(json);
}
@ -30,11 +34,11 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
this.Update?.Invoke(this, new DeviceUpdateEvent(new Tuple<Int32, Int32>(this.Scene, this.Key), this.LastUpdate));
}
} else {
throw new NotImplementedException();
Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
}
}
protected override void InitComplex(JsonData json) {
private void InitComplex(JsonData json) {
if (json.Keys.Contains("data")) {
JsonData data = json["data"];
if(data.Keys.Contains("sceneSupportedKeyAttributesMask")) {
@ -67,7 +71,7 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
}
public override String ToString() {
return "CentralScene " + this.Name + ": "+this.Scene+"-"+this.Key;
return "CentralScene " + this.Name + " [" + this.Id + "]: " + this.Scene+"-"+this.Key;
}
internal override void Poll() {

65
Zway/Devices/CommandClasses/CommandClassSubs/Configurationsub.cs Normal file
View File

@ -0,0 +1,65 @@
using System;
using System.Text.RegularExpressions;
using BlubbFish.IoT.Zway.Events;
using BlubbFish.IoT.Zway.Interfaces;
using BlubbFish.IoT.Zway.lib;
using LitJson;
namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
class Configurationsub : CommandClassSub {
private Int64 _level;
public override event UpdatedValue Update;
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)");
} 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)");
} 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)");
}
}
}
public Int32 Size { get; private set; }
public Configurationsub(JsonData json, Tuple<Int32, Int32, Int32, Int32> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
InitComplex(json);
}
private void InitComplex(JsonData json) {
if (json.Keys.Contains("val") &&
json["val"].Keys.Contains("value") &&
json["val"]["value"] != null &&
json.Keys.Contains("size") &&
json["size"].Keys.Contains("value")) {
this._level = Int64.Parse(json["val"]["value"].ToString());
this.Size = Int32.Parse(json["size"]["value"].ToString());
}
}
internal override void Poll() {
if(this.Polling) {
this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + this.Commandclass + "].Get("+this.SensorId+")");
}
}
internal override void SetUpdate(JsonData json, Match match) {
if (json.Keys.Contains("val") && json["val"].Keys.Contains("value") && json["val"]["value"] != null &&
json.Keys.Contains("size") && json["size"].Keys.Contains("value") &&
this.CheckSetUpdateTime(json)) {
this._level = Int64.Parse(json["val"]["value"].ToString());
this.Size = Int32.Parse(json["size"]["value"].ToString());
this.Update?.Invoke(this, new DeviceUpdateEvent(new Tuple<Int64, Int32>(this.Level, this.Size), this.LastUpdate));
}
}
public override String ToString() {
return "Configuration " + this.Name + " [" + this.Id + "]: " + this.Level;
}
}
}

11
Zway/Devices/CommandClasses/CommandClassSubs/MeterSub.cs
View File

@ -1,6 +1,7 @@
using System;
using System.Text.RegularExpressions;
using BlubbFish.IoT.Zway.Events;
using BlubbFish.IoT.Zway.Interfaces;
using BlubbFish.IoT.Zway.lib;
using LitJson;
@ -11,7 +12,7 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
public String Type { get; private set; }
public Single Level { get; private set; }
public String Scale { get; private set; }
public Metersub(JsonData json, Tuple<Int32, Int32, Int32, Int32> id, HttpConnection http) : base(json, id, http) {
public Metersub(JsonData json, Tuple<Int32, Int32, Int32, Int32> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
InitComplex(json);
}
@ -19,7 +20,7 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + this.Commandclass + "].Reset()");
}
protected override void InitComplex(JsonData json) {
private void InitComplex(JsonData json) {
if (json.Keys.Contains("sensorTypeString") &&
json["sensorTypeString"].Keys.Contains("value") &&
json.Keys.Contains("val") &&
@ -45,7 +46,9 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
}
public override String ToString() {
return "Meter " + this.Name + ": " + this.Type + " " + this.Level + "" + this.Scale;
}
return "Meter " + this.Name + " [" + this.Id + "]: " + this.Type + " " + this.Level + "" + this.Scale;
}
internal override void Poll() { }
}
}

13
Zway/Devices/CommandClasses/CommandClassSubs/SensorMultilevelSub.cs
View File

@ -1,6 +1,7 @@
using System;
using System.Text.RegularExpressions;
using BlubbFish.IoT.Zway.Events;
using BlubbFish.IoT.Zway.Interfaces;
using BlubbFish.IoT.Zway.lib;
using LitJson;
@ -11,13 +12,11 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
public Single Level { get; private set; }
public String Scale { get; private set; }
public Sensormultilevelsub(JsonData json, Tuple<Int32, Int32, Int32, Int32> id, HttpConnection http) : base(json, id, http) {
public Sensormultilevelsub(JsonData json, Tuple<Int32, Int32, Int32, Int32> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
InitComplex(json);
}
protected override void InitComplex(JsonData json) {
private void InitComplex(JsonData json) {
if (json.Keys.Contains("sensorTypeString") &&
json["sensorTypeString"].Keys.Contains("value") &&
json.Keys.Contains("val") &&
@ -43,7 +42,9 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
}
public override String ToString() {
return "SensorMultilevel " + this.Name + ": " + this.Type + " " + this.Level + "" + this.Scale;
}
return "SensorMultilevel " + this.Name + " [" + this.Id + "]: " + this.Type + " " + this.Level + "" + this.Scale;
}
internal override void Poll() { }
}
}

13
Zway/Devices/CommandClasses/CommandClassSubs/ThermostatSetPointSub.cs
View File

@ -1,6 +1,7 @@
using System;
using System.Text.RegularExpressions;
using BlubbFish.IoT.Zway.Events;
using BlubbFish.IoT.Zway.Interfaces;
using BlubbFish.IoT.Zway.lib;
using LitJson;
@ -27,11 +28,11 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
public Boolean HasMinMax { get; private set; }
public String Type { get; private set; }
public Thermostatsetpointsub(JsonData json, Tuple<Int32, Int32, Int32, Int32> id, HttpConnection http) : base(json, id, http) {
public Thermostatsetpointsub(JsonData json, Tuple<Int32, Int32, Int32, Int32> id, HttpConnection http, Boolean polling) : base(json, id, http, polling) {
InitComplex(json);
}
protected override void InitComplex(JsonData json) {
private void InitComplex(JsonData json) {
if (json.Keys.Contains("modeName") && json["modeName"].Keys.Contains("value") &&
json.Keys.Contains("val") && json["val"].Keys.Contains("value") &&
json.Keys.Contains("deviceScaleString") && json["deviceScaleString"].Keys.Contains("value")) {
@ -74,7 +75,13 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs {
}
public override String ToString() {
return "ThermostatSetPoint " + this.Name + ": " + this.Type + " " + this.Level + "" + this.Scale + " [" + this.TempMin + "," + this.TempMax + "," + this.HasMinMax + "]";
return "ThermostatSetPoint " + this.Name + " [" + this.Id + "]: " + this.Type + " " + this.Level + "" + this.Scale + " [" + this.TempMin + "," + this.TempMax + "," + this.HasMinMax + "]";
}
internal override void Poll() {
if (this.Polling) {
this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + this.Commandclass + "].Get(" + this.SensorId + ")");
}
}
}
}

64
Zway/Devices/CommandClasses/Configuration.cs Normal file
View File

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

12
Zway/Devices/CommandClasses/Indicator.cs
View File

@ -1,10 +1,14 @@
using System;
using System.Text.RegularExpressions;
using BlubbFish.IoT.Zway.Events;
using BlubbFish.IoT.Zway.Interfaces;
using BlubbFish.IoT.Zway.lib;
using LitJson;
namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
/// <summary>
/// 135 = Indicator
/// </summary>
class Indicator : CommandClass {
private Boolean _level;
@ -18,11 +22,11 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
}
}
public Indicator(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id) : base(json, http, id) {
public Indicator(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id, Boolean polling) : base(json, http, id, polling) {
this.InitComplex(json);
}
protected override void InitComplex(JsonData 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;
}
@ -35,12 +39,12 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
this.Update?.Invoke(this, new DeviceUpdateEvent(this.Level, this.LastUpdate));
}
} else {
throw new NotImplementedException();
Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
}
}
public override String ToString() {
return "Indicator " + this.Name + ": " + this.Level;
return "Indicator " + this.Name + " [" + this.Id + "]: " + this.Level;
}
}
}

24
Zway/Devices/CommandClasses/Meter.cs
View File

@ -4,17 +4,21 @@ using System.Collections.ObjectModel;
using System.Text.RegularExpressions;
using BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs;
using BlubbFish.IoT.Zway.Events;
using BlubbFish.IoT.Zway.Interfaces;
using BlubbFish.IoT.Zway.lib;
using LitJson;
namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
/// <summary>
/// 50 = Meter
/// </summary>
public class Meter : CommandClass {
public override event UpdatedValue Update;
public ReadOnlyDictionary<Int32, CommandClassSub> Sub { get; private set; }
public Meter(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id) : base(json, http, id) {
public Meter(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id, Boolean polling) : base(json, http, id, polling) {
this.InitComplex(json);
foreach (KeyValuePair<Int32, CommandClassSub> item in this.Sub) {
item.Value.Update += this.DeviceUpdate;
@ -32,11 +36,11 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
this.Sub[subid].SetUpdate(json, match);
}
} else {
throw new NotImplementedException();
Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
}
}
protected override void InitComplex(JsonData json) {
private void InitComplex(JsonData json) {
if (json.Keys.Contains("data")) {
JsonData data = json["data"];
Dictionary<Int32, CommandClassSub> subs = new Dictionary<Int32, CommandClassSub>();
@ -45,11 +49,23 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
data[item].Keys.Contains("sensorTypeString") &&
data[item].Keys.Contains("val") &&
data[item].Keys.Contains("scaleString")) {
subs.Add(subid, new Metersub(data[item], new Tuple<Int32, Int32, Int32, Int32>(this.DeviceId, this.Instance, this.Commandclass, subid), this.http));
subs.Add(subid, new Metersub(data[item], new Tuple<Int32, Int32, Int32, Int32>(this.DeviceId, this.Instance, this.Commandclass, subid), this.http, this.Polling));
}
}
this.Sub = new ReadOnlyDictionary<Int32, CommandClassSub>(subs);
}
}
internal override void Poll() {
Boolean poll = false;
foreach (KeyValuePair<Int32, CommandClassSub> item in this.Sub) {
if (item.Value.Polling) {
poll = true;
}
}
if (poll) {
this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + this.Commandclass + "].Get()");
}
}
}
}

24
Zway/Devices/CommandClasses/SensorMultilevel.cs
View File

@ -4,17 +4,21 @@ using System.Collections.ObjectModel;
using System.Text.RegularExpressions;
using BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs;
using BlubbFish.IoT.Zway.Events;
using BlubbFish.IoT.Zway.Interfaces;
using BlubbFish.IoT.Zway.lib;
using LitJson;
namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
/// <summary>
/// 49 = SensorMultilevel
/// </summary>
public class Sensormultilevel : CommandClass {
public override event UpdatedValue Update;
public ReadOnlyDictionary<Int32, CommandClassSub> Sub { get; private set; }
public Sensormultilevel(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id) : base(json, http, id) {
public Sensormultilevel(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id, Boolean polling) : base(json, http, id, polling) {
this.InitComplex(json);
foreach (KeyValuePair<Int32, CommandClassSub> item in this.Sub) {
item.Value.Update += this.DeviceUpdate;
@ -32,11 +36,11 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
this.Sub[subid].SetUpdate(json, match);
}
} else {
throw new NotImplementedException();
Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
}
}
protected override void InitComplex(JsonData json) {
private void InitComplex(JsonData json) {
if (json.Keys.Contains("data")) {
JsonData data = json["data"];
Dictionary<Int32, CommandClassSub> subs = new Dictionary<Int32, CommandClassSub>();
@ -45,11 +49,23 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
data[item].Keys.Contains("sensorTypeString") &&
data[item].Keys.Contains("val") &&
data[item].Keys.Contains("scaleString")) {
subs.Add(subid, new Sensormultilevelsub(data[item], new Tuple<Int32, Int32, Int32, Int32>(this.DeviceId, this.Instance, this.Commandclass, subid), this.http));
subs.Add(subid, new Sensormultilevelsub(data[item], new Tuple<Int32, Int32, Int32, Int32>(this.DeviceId, this.Instance, this.Commandclass, subid), this.http, this.Polling));
}
}
this.Sub = new ReadOnlyDictionary<Int32, CommandClassSub>(subs);
}
}
internal override void Poll() {
Boolean poll = false;
foreach (KeyValuePair<Int32, CommandClassSub> item in this.Sub) {
if (item.Value.Polling) {
poll = true;
}
}
if (poll) {
this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + this.Commandclass + "].Get()");
}
}
}
}

12
Zway/Devices/CommandClasses/SwitchBinary.cs
View File

@ -1,10 +1,14 @@
using System;
using System.Text.RegularExpressions;
using BlubbFish.IoT.Zway.Events;
using BlubbFish.IoT.Zway.Interfaces;
using BlubbFish.IoT.Zway.lib;
using LitJson;
namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
/// <summary>
/// 37 = SwitchBinary
/// </summary>
public class Switchbinary : CommandClass {
private Boolean _level;
@ -19,7 +23,7 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
}
}
public Switchbinary(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id) : base(json, http, id) {
public Switchbinary(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id, Boolean polling) : base(json, http, id, polling) {
this.InitComplex(json);
}
@ -30,18 +34,18 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
this.Update?.Invoke(this, new DeviceUpdateEvent(this.Level, this.LastUpdate));
}
} else {
throw new NotImplementedException();
Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
}
}
protected override void InitComplex(JsonData 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._level = (Boolean)json["data"]["level"]["value"];
}
}
public override String ToString() {
return "SwitchBinary " + this.Name + ": " + this.Level;
return "SwitchBinary " + this.Name + " [" + this.Id + "]: " + this.Level;
}
}
}

12
Zway/Devices/CommandClasses/SwitchMultilevel.cs
View File

@ -1,10 +1,14 @@
using System;
using System.Text.RegularExpressions;
using BlubbFish.IoT.Zway.Events;
using BlubbFish.IoT.Zway.Interfaces;
using BlubbFish.IoT.Zway.lib;
using LitJson;
namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
/// <summary>
/// 38 = SwitchMultilevel
/// </summary>
public class Switchmultilevel : CommandClass {
private Int32 _level;
@ -21,7 +25,7 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
}
}
public Switchmultilevel(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id) : base(json, http, id) {
public Switchmultilevel(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id, Boolean polling) : base(json, http, id, polling) {
this.InitComplex(json);
}
@ -33,18 +37,18 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
}
} else if (match.Groups[4].Value == ".data.prevLevel") {
} else {
throw new NotImplementedException();
Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
}
}
protected override void InitComplex(JsonData 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());
}
}
public override String ToString() {
return "SwitchMultilevel " + this.Name + ": " + this.Level;
return "SwitchMultilevel " + this.Name + " [" + this.Id + "]: " + this.Level;
}
}
}

12
Zway/Devices/CommandClasses/ThermostatMode.cs
View File

@ -3,10 +3,14 @@ using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Text.RegularExpressions;
using BlubbFish.IoT.Zway.Events;
using BlubbFish.IoT.Zway.Interfaces;
using BlubbFish.IoT.Zway.lib;
using LitJson;
namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
/// <summary>
/// 64 = ThermostatMode
/// </summary>
public class Thermostatmode : CommandClass {
private Int32 _level;
@ -22,7 +26,7 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
}
}
public Thermostatmode(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id) : base(json, http, id) {
public Thermostatmode(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id, Boolean polling) : base(json, http, id, polling) {
this.ValidModes = new ReadOnlyDictionary<Int32, String>(new Dictionary<Int32, String>());
this.InitComplex(json);
}
@ -34,11 +38,11 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
this.Update?.Invoke(this, new DeviceUpdateEvent(this.Level, this.LastUpdate));
}
} else {
throw new NotImplementedException();
Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
}
}
protected override void InitComplex(JsonData json) {
private void InitComplex(JsonData json) {
if (json.Keys.Contains("data")) {
JsonData data = json["data"];
Dictionary<Int32, String> modes = new Dictionary<Int32, String>();
@ -58,7 +62,7 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
}
public override String ToString() {
return "ThermostatMode " + this.Name + ": " + this.ValidModes[this.Level];
return "ThermostatMode " + this.Name + " [" + this.Id + "]: " + this.ValidModes[this.Level];
}
}
}

14
Zway/Devices/CommandClasses/ThermostatSetPoint.cs
View File

@ -4,16 +4,20 @@ using System.Collections.ObjectModel;
using System.Text.RegularExpressions;
using BlubbFish.IoT.Zway.Devices.CommandClasses.CommandClassSubs;
using BlubbFish.IoT.Zway.Events;
using BlubbFish.IoT.Zway.Interfaces;
using BlubbFish.IoT.Zway.lib;
using LitJson;
namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
/// <summary>
/// 67 = ThermostatSetPoint
/// </summary>
public class Thermostatsetpoint : CommandClass {
public override event UpdatedValue Update;
public ReadOnlyDictionary<Int32, CommandClassSub> Sub { get; private set; }
public Thermostatsetpoint(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id) : base(json, http, id) {
public Thermostatsetpoint(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id, Boolean polling) : base(json, http, id, polling) {
this.InitComplex(json);
foreach (KeyValuePair<Int32, CommandClassSub> item in this.Sub) {
item.Value.Update += this.DeviceUpdate;
@ -31,11 +35,11 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
this.Sub[subid].SetUpdate(json, match);
}
} else {
throw new NotImplementedException();
Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
}
}
protected override void InitComplex(JsonData json) {
private void InitComplex(JsonData json) {
if (json.Keys.Contains("data")) {
JsonData data = json["data"];
Dictionary<Int32, CommandClassSub> subs = new Dictionary<Int32, CommandClassSub>();
@ -44,7 +48,7 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
data[item].Keys.Contains("modeName") &&
data[item].Keys.Contains("val") &&
data[item].Keys.Contains("deviceScaleString")) {
subs.Add(subid, new Thermostatsetpointsub(data[item], new Tuple<Int32, Int32, Int32, Int32>(this.DeviceId, this.Instance, this.Commandclass, subid), this.http));
subs.Add(subid, new Thermostatsetpointsub(data[item], new Tuple<Int32, Int32, Int32, Int32>(this.DeviceId, this.Instance, this.Commandclass, subid), this.http, this.Polling));
}
}
this.Sub = new ReadOnlyDictionary<Int32, CommandClassSub>(subs);
@ -53,7 +57,7 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
internal override void Poll() {
foreach (KeyValuePair<Int32, CommandClassSub> item in this.Sub) {
this.http.GetVoid("ZWave.zway/Run/devices[" + this.DeviceId + "].instances[" + this.Instance + "].commandClasses[" + this.Commandclass + "].Get(" + item.Key + ")");
item.Value.Poll();
}
}
}

16
Zway/Devices/CommandClasses/Wakeup.cs
View File

@ -1,14 +1,14 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BlubbFish.IoT.Zway.Events;
using BlubbFish.IoT.Zway.Interfaces;
using BlubbFish.IoT.Zway.lib;
using LitJson;
namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
/// <summary>
/// 132 = Wakeup
/// </summary>
class Wakeup : CommandClass {
private Int32 _interval;
private Int32 _againstNode;
@ -37,11 +37,11 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
public DateTime LastWakeup { get; private set; }
public DateTime LastSleep { get; private set; }
public Wakeup(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id) : base(json, http, id) {
public Wakeup(JsonData json, HttpConnection http, Tuple<Int32, Int32, Int32> id, Boolean polling) : base(json, http, id, polling) {
this.InitComplex(json);
}
protected override void InitComplex(JsonData json) {
private void InitComplex(JsonData json) {
if (json.Keys.Contains("data")) {
JsonData data = json["data"];
if(data.Keys.Contains("interval") && data["interval"].Keys.Contains("value")) {
@ -110,7 +110,7 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
success = true;
}
} else {
throw new NotImplementedException();
Helper.WriteError("Kenne in " + this.Name + " [" + this.Id + "] " + match.Groups[4].Value + " nicht!");
}
if (success && this.CheckSetUpdateTime(json)) {
this.Update?.Invoke(this, new DeviceUpdateEvent(0, this.LastUpdate));
@ -118,7 +118,7 @@ namespace BlubbFish.IoT.Zway.Devices.CommandClasses {
}
public override String ToString() {
return "Wakeup " + this.Name + ": " + this.LastWakeup + "-" + this.LastSleep + " " + this.Interval + " [" + this.WakeupMin + "," + this.WakeupMax + "," + this.WakeupDefault + "," + this.AgainstNode + "]";
return "Wakeup " + this.Name + " [" + this.Id + "]: " + this.LastWakeup + "-" + this.LastSleep + " " + this.Interval + " [" + this.WakeupMin + "," + this.WakeupMax + "," + this.WakeupDefault + "," + this.AgainstNode + "]";
}
}
}

35
Zway/Devices/Device.cs
View File

@ -1,30 +1,27 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections.ObjectModel;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BlubbFish.IoT.Zway.Events;
using BlubbFish.IoT.Zway.lib;
using LitJson;
namespace BlubbFish.IoT.Zway.Devices {
class Device {
private Dictionary<Int32, Instance> _instances = new Dictionary<Int32, Instance>();
public class Device {
private Boolean polling;
public delegate void UpdatedDevice(Object sender, DeviceUpdateEvent e);
public event UpdatedDevice Update;
public String Name { get; }
public Int32 Id { get; }
public Dictionary<Int32, Instance> Instances { get { return this._instances; } }
public ReadOnlyDictionary<Int32, Instance> Instances { get; private set; }
public DateTime LastUpdate { get; private set; }
private Device(JsonData json, Tuple<Int32> id, HttpConnection http) {
private Device(JsonData json, Tuple<Int32> id, HttpConnection http, Boolean polling) {
this.Id = id.Item1;
foreach (String instanceid in json["instances"].Keys) {
this.CreateInstances(Int32.Parse(instanceid), json["instances"][instanceid], http);
}
this.polling = polling;
this.CreateInstances(json["instances"], http);
if (json["data"].Keys.Contains("givenName") && json["data"]["givenName"].Keys.Contains("value")) {
this.Name = json["data"]["givenName"]["value"].ToString();
} else {
@ -53,30 +50,34 @@ namespace BlubbFish.IoT.Zway.Devices {
this.Update?.Invoke(sender, e);
}
private void CreateInstances(Int32 instanceid, JsonData json, HttpConnection http) {
Instance i = Instance.CreateInstance(json, new Tuple<Int32, Int32>(this.Id, instanceid), http);
private void CreateInstances(JsonData json, HttpConnection http) {
Dictionary<Int32, Instance> instances = new Dictionary<Int32, Instance>();
foreach (String instanceid in json.Keys) {
Instance i = Instance.CreateInstance(json[instanceid], new Tuple<Int32, Int32>(this.Id, Int32.Parse(instanceid)), http, this.polling);
if (i != null) {
this._instances.Add(instanceid, i);
instances.Add(Int32.Parse(instanceid), i);
}
}
this.Instances = new ReadOnlyDictionary<Int32, Instance>(instances);
}
internal static Device CreateDevice(JsonData json, Tuple<Int32> id, HttpConnection http) {
internal static Device CreateDevice(JsonData json, Tuple<Int32> id, HttpConnection http, Boolean polling) {
if(json.Keys.Contains("instances") &&
json["instances"].Count > 0 &&
json.Keys.Contains("data") && id.Item1 != 1) {
return new Device(json, id, http);
return new Device(json, id, http, polling);
}
return null;
}
public override String ToString() {
return this.Name+"_"+this.Id+" ["+this._instances.Count+"]";
return this.Name+"_"+this.Id+" ["+this.Instances.Count+"]";
}
internal void SetUpdate(JsonData json, Match match) {
if (match.Groups[2].Value == "data.lastReceived") {
if (this.CheckSetUpdateTime(json)) {
this.Update?.Invoke(this, new DeviceUpdateEvent(this.LastUpdate, this.LastUpdate));
//this.Update?.Invoke(this, new DeviceUpdateEvent(this.LastUpdate, this.LastUpdate));
}
}
}

39
Zway/Devices/Instance.cs
View File

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

10
Zway/Events/DeviceUpdateEvent.cs
View File

@ -15,8 +15,8 @@ namespace BlubbFish.IoT.Zway.Events {
this.UpdateTime = time;
}
public DeviceUpdateEvent(Boolean level, DateTime time) {
this.GetBoolean = level;
public DeviceUpdateEvent(Boolean value, DateTime time) {
this.GetBoolean = value;
this.UpdateTime = time;
}
@ -39,10 +39,16 @@ namespace BlubbFish.IoT.Zway.Events {
this.UpdateTime = time;
}
public DeviceUpdateEvent(Tuple<Int64, Int32> value, DateTime time) {
this.GetLongIntegerTuple = value;
this.UpdateTime = time;
}
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 Boolean GetBoolean { get; }
public Tuple<Int32,Int32> GetIntegerTuple { get; }

5
Zway/Exceptions/ZwayExceptions.cs
View File

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

14
Zway/Interfaces/ICommandClass.cs Normal file
View File

@ -0,0 +1,14 @@
using System;
using BlubbFish.IoT.Zway.Events;
namespace BlubbFish.IoT.Zway.Interfaces {
public delegate void UpdatedValue(Object sender, DeviceUpdateEvent e);
public interface ICommandClass {
String Name { get; }
String Id { get; }
DateTime LastUpdate { get; }
Boolean Polling { get; set; }
event UpdatedValue Update;
}
}

4
Zway/Zway.csproj
View File

@ -45,7 +45,9 @@
<ItemGroup>
<Compile Include="Devices\CommandClasses\Battery.cs" />
<Compile Include="Devices\CommandClass.cs" />
<Compile Include="Devices\CommandClasses\CommandClassSubs\Configurationsub.cs" />
<Compile Include="Devices\CommandClasses\CommandClassSubs\ThermostatSetPointSub.cs" />
<Compile Include="Devices\CommandClasses\Configuration.cs" />
<Compile Include="Devices\CommandClasses\Indicator.cs" />
<Compile Include="Devices\CommandClasses\Meter.cs" />
<Compile Include="Devices\CommandClasses\CommandClassSubs\MeterSub.cs" />
@ -53,6 +55,7 @@
<Compile Include="Devices\CommandClasses\Wakeup.cs" />
<Compile Include="Devices\CommandClassSub.cs" />
<Compile Include="Devices\Device.cs" />
<Compile Include="Interfaces\ICommandClass.cs" />
<Compile Include="Devices\Instance.cs" />
<Compile Include="Devices\CommandClasses\CentralScene.cs" />
<Compile Include="Devices\CommandClasses\SensorMultilevel.cs" />
@ -62,6 +65,7 @@
<Compile Include="Devices\CommandClasses\ThermostatSetPoint.cs" />
<Compile Include="Events\DeviceUpdateEvent.cs" />
<Compile Include="Exceptions\ZwayExceptions.cs" />
<Compile Include="lib\Helper.cs" />
<Compile Include="lib\HttpClient.cs" />
<Compile Include="ZwayController.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />

74
Zway/ZwayController.cs
View File

@ -1,28 +1,38 @@
using System;
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;
using BlubbFish.IoT.Zway.Events;
using BlubbFish.IoT.Zway.Interfaces;
using BlubbFish.IoT.Zway.lib;
using LitJson;
namespace BlubbFish.IoT.Zway {
public class ZwayController : IDisposable {
private HttpConnection http;
private Dictionary<Int32, Device> devices = new Dictionary<Int32, Device>();
private Thread updatethread;
private Thread pollthread;
public static ReadOnlyDictionary<String, String> namelist;
private Boolean polling;
public delegate void DataUpdate(Object sender, DeviceUpdateEvent e);
public event DataUpdate Update;
public ZwayController(String server, String user, String pass) {
public ReadOnlyDictionary<Int32, Device> Devices { get; private set; }
public ZwayController(String server, String user, String pass, Dictionary<String, String> names, Boolean enablePoll = true) {
namelist = new ReadOnlyDictionary<String, String>(names);
this.polling = enablePoll;
this.Connect(server, user, pass);
}
public ZwayController(Dictionary<String, String> settings) {
public ZwayController(Dictionary<String, String> settings, Dictionary<String, String> names, Boolean enablePoll = true) {
namelist = new ReadOnlyDictionary<String, String>(names);
this.polling = enablePoll;
this.Connect(settings["server"], settings["user"], settings["pass"]);
}
@ -34,12 +44,12 @@ namespace BlubbFish.IoT.Zway {
CultureInfo.DefaultThreadCurrentUICulture = info;
Thread.CurrentThread.CurrentCulture = info;
Thread.CurrentThread.CurrentUICulture = info;
this.ParseNamespace(this.http.GetJson("ZWaveAPI/Run/devices"));
this.CreateDevices(this.http.GetJson("ZWaveAPI/Run/devices"));
this.updatethread = new Thread(this.Updater);
this.updatethread.Start();
this.pollthread = new Thread(this.Poll);
this.pollthread.Start();
foreach (KeyValuePair<Int32, Device> item in this.devices) {
foreach (KeyValuePair<Int32, Device> item in this.Devices) {
item.Value.Update += this.DeviceUpdate;
}
}
@ -56,13 +66,37 @@ namespace BlubbFish.IoT.Zway {
Thread.CurrentThread.CurrentCulture = info;
Thread.CurrentThread.CurrentUICulture = info;
while(true) {
foreach (KeyValuePair<Int32, Device> item in this.devices) {
foreach (KeyValuePair<Int32, Device> item in this.Devices) {
item.Value.Poll();
}
Thread.Sleep(1000);
}
}
public ICommandClass GetCommandClass(Int32 deviceid, Int32 instanceid, Int32 classid) {
if(this.Devices.ContainsKey(deviceid) && this.Devices[deviceid].Instances.ContainsKey(instanceid) && this.Devices[deviceid].Instances[instanceid].CommandClasses.ContainsKey(classid)) {
return this.Devices[deviceid].Instances[instanceid].CommandClasses[classid];
}
return null;
}
public ICommandClass GetCommandClassSub(Int32 deviceid, Int32 instanceid, Int32 classid, Int32 subcid) {
ICommandClass comandclass = this.GetCommandClass(deviceid, instanceid, classid);
if (comandclass != null) {
foreach (PropertyInfo item in comandclass.GetType().GetProperties()) {
if (item.Name == "Sub") {
if (comandclass.GetType().GetProperty("Sub").PropertyType == typeof(ReadOnlyDictionary<Int32, CommandClassSub>)) {
ReadOnlyDictionary<Int32, CommandClassSub> commandclasssub = (ReadOnlyDictionary<Int32, CommandClassSub>)comandclass.GetType().GetProperty("Sub").GetValue(comandclass);
if (commandclasssub.ContainsKey(subcid)) {
return commandclasssub[subcid];
}
}
}
}
}
return null;
}
private void Updater() {
CultureInfo info = new CultureInfo("de-DE");
info.NumberFormat.NumberDecimalSeparator = ".";
@ -79,8 +113,8 @@ namespace BlubbFish.IoT.Zway {
Int32 deviceid = Int32.Parse(match.Groups[1].Value);
Int32 instanceid = Int32.Parse(match.Groups[2].Value);
Int32 commandid = Int32.Parse(match.Groups[3].Value);
if (this.devices.ContainsKey(deviceid) && this.devices[deviceid].Instances.ContainsKey(instanceid) && this.devices[deviceid].Instances[instanceid].CommandClasses.ContainsKey(commandid)) {
this.devices[deviceid].Instances[instanceid].CommandClasses[commandid].SetUpdate(notifications[item], match);
if (this.Devices.ContainsKey(deviceid) && this.Devices[deviceid].Instances.ContainsKey(instanceid) && this.Devices[deviceid].Instances[instanceid].CommandClasses.ContainsKey(commandid)) {
this.Devices[deviceid].Instances[instanceid].CommandClasses[commandid].SetUpdate(notifications[item], match);
}
} /*else {
if(item.StartsWith("controller.")) { }
@ -95,8 +129,8 @@ namespace BlubbFish.IoT.Zway {
match = new Regex("^devices\\.([0-9]+)\\.(data.*)", RegexOptions.IgnoreCase).Match(item);
if(match.Success) {
Int32 deviceid = Int32.Parse(match.Groups[1].Value);
if (this.devices.ContainsKey(deviceid)) {
this.devices[deviceid].SetUpdate(notifications[item], match);
if (this.Devices.ContainsKey(deviceid)) {
this.Devices[deviceid].SetUpdate(notifications[item], match);
}
}
}
@ -104,22 +138,20 @@ namespace BlubbFish.IoT.Zway {
}
}
private void ParseNamespace(JsonData json) {
private void CreateDevices(JsonData json) {
Dictionary<Int32, Device> devices = new Dictionary<Int32, Device>();
foreach (String deviceid in json.Keys) {
this.CreateDevices(Int32.Parse(deviceid), json[deviceid]);
}
}
private void CreateDevices(Int32 deviceid, JsonData json) {
Device d = Device.CreateDevice(json, new Tuple<Int32>(deviceid), this.http);
Device d = Device.CreateDevice(json[deviceid], new Tuple<Int32>(Int32.Parse(deviceid)), this.http, this.polling);
if (d != null) {
this.devices.Add(deviceid, d);
devices.Add(Int32.Parse(deviceid), d);
}
}
this.Devices = new ReadOnlyDictionary<Int32, Device>(devices);
}
public List<T> GetCommandClasses<T>() {
List<T> ret = new List<T>();
foreach (KeyValuePair<Int32, Device> device in this.devices) {
foreach (KeyValuePair<Int32, Device> device in this.Devices) {
foreach (KeyValuePair<Int32, Instance> instance in device.Value.Instances) {
foreach (KeyValuePair<Int32, CommandClass> commandclass in instance.Value.CommandClasses) {
if (commandclass.Value is T) {
@ -142,7 +174,7 @@ namespace BlubbFish.IoT.Zway {
}
this.updatethread = null;
this.pollthread = null;
this.devices.Clear();
this.Devices = null;
this.disposedValue = true;
}
}
@ -151,7 +183,7 @@ namespace BlubbFish.IoT.Zway {
Dispose(false);
}
void IDisposable.Dispose() {
public void Dispose() {
Dispose(true);
GC.SuppressFinalize(this);
}

15
Zway/lib/Helper.cs Normal file
View File

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

12
Zway/lib/HttpClient.cs
View File

@ -1,11 +1,7 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using LitJson;
namespace BlubbFish.IoT.Zway.lib {
@ -26,6 +22,9 @@ namespace BlubbFish.IoT.Zway.lib {
internal JsonData GetJson(String v) {
String text = this.GetString(v);
if(text == null) {
return new JsonData();
}
try {
return JsonMapper.ToObject(text);
} catch(Exception) {
@ -55,8 +54,9 @@ namespace BlubbFish.IoT.Zway.lib {
}
}
} catch (Exception e) {
Console.Error.WriteLine("Konnte keine Verbindung zum Razzbery Server herstellen: " + e.Message);
throw new Exceptions.ConnectionException("Konnte keine Verbindung zum Razzbery Server herstellen: " + e.Message);
Helper.WriteError("Konnte keine Verbindung zum Razzbery Server herstellen. Resource: \"" + this.server + v + "\" Fehler: " + e.Message);
return null;
//throw new Exceptions.ConnectionException("Konnte keine Verbindung zum Razzbery Server herstellen: " + e.Message);
}
}
return ret;