// this is the ELV MAX! Cube monitoring script
public void Run()
{
while(running)
{
TcpClient client;
NetworkStream stream;
Dictionary<String, IMAXDevice> currentHouse = new Dictionary<string,IMAXDevice>();
#region Update House
try
{
// now fill that with the initial handshake data...
#region Initial connect and retrieving everything we get from the cube
// network connect and first initialization
client = new TcpClient();
client.Connect(Hostname,Port);
stream = client.GetStream();
// the read buffer (chosen quite big)
byte[] myReadBuffer = new byte[4096*8];
List<String> Messages = new List<string>();
// to build the complete message
StringBuilder myCompleteMessage = new StringBuilder();
int numberOfBytesRead = 0;
MAXEncodeDecode DecoderEncoder = new MAXEncodeDecode();
keepRunning = true;
// Incoming message may be larger than the buffer size.
do
{
myCompleteMessage = new StringBuilder();
stream.ReadTimeout = 1000;
try
{
numberOfBytesRead = stream.Read(myReadBuffer, 0, myReadBuffer.Length);
myCompleteMessage.AppendFormat("{0}", Encoding.ASCII.GetString(myReadBuffer, 0, numberOfBytesRead));
Messages.Add(myCompleteMessage.ToString());
}
catch(Exception)
{
previousHouse = null;
// everything to start
theHouse = new House();
keepRunning = false;
}
}
while(keepRunning);
#endregion
ConsoleOutputLogger.WriteLine("ELV MAX Cube connected...");
#region preprocess
List<String> PreProcessedMessages = new List<string>();
foreach(String _Message in Messages)
{
if (_Message.Remove(_Message.Length-2).Contains("\r\n"))
{
String[] PMessages = _Message.Remove(_Message.Length-2).Split(new char[1] { '\n' },StringSplitOptions.RemoveEmptyEntries);
foreach(String pmessage in PMessages)
{
PreProcessedMessages.Add(pmessage.Replace("\r","")+"\r\n");
}
}
else
PreProcessedMessages.Add(_Message);
}
#endregion
#region process
// Analyze and Output Messages, feed them to the decoder
foreach(String _Message in PreProcessedMessages)
{
//IMAXMessage Message = DecoderEncoder.ProcessMessage(_Message.ToString(), theHouse);
// if (Message != null)
// {
// ConsoleOutputLogger.WriteLine(_Message.ToString());
// ConsoleOutputLogger.WriteLine(Message.ToString());
// ConsoleOutputLogger.WriteLine("");
// }
DecoderEncoder.ProcessMessage(_Message.ToString(), theHouse);
}
#endregion
while(running)
{
// when we are here, we got a filled "theHouse" which does contain first hand L message information
previousHouse = theHouse.GetAllDevicesInADictionary();
#region send L: request and get all the feedback
System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
byte[] args_data_buffer = enc.GetBytes("l:\r\n");
Messages = new List<string>();
keepRunning = true;
// Incoming message may be larger than the buffer size.
stream.Write(args_data_buffer, 0, args_data_buffer.Length);
do
{
myCompleteMessage = new StringBuilder();
stream.ReadTimeout = 1000;
try
{
numberOfBytesRead = stream.Read(myReadBuffer, 0, myReadBuffer.Length);
myCompleteMessage.AppendFormat("{0}", Encoding.ASCII.GetString(myReadBuffer, 0, numberOfBytesRead));
Messages.Add(myCompleteMessage.ToString());
}
catch(Exception)
{
keepRunning = false;
}
}
while(keepRunning);
#endregion
#region preprocess
PreProcessedMessages = new List<string>();
foreach(String _Message in Messages)
{
if (_Message.Remove(_Message.Length-2).Contains("\r\n"))
{
String[] PMessages = _Message.Remove(_Message.Length-2).Split(new char[1] { '\n' },StringSplitOptions.RemoveEmptyEntries);
foreach(String pmessage in PMessages)
{
PreProcessedMessages.Add(pmessage.Replace("\r","")+"\r\n");
}
}
else
PreProcessedMessages.Add(_Message);
}
#endregion
#region process
// Analyze and Output Messages, feed them to the decoder
foreach(String _Message in PreProcessedMessages)
{
//IMAXMessage Message = DecoderEncoder.ProcessMessage(_Message.ToString(), theHouse);
// if (Message != null)
// {
// ConsoleOutputLogger.WriteLine(_Message.ToString());
// ConsoleOutputLogger.WriteLine(Message.ToString());
// ConsoleOutputLogger.WriteLine("");
// }
currentHouse = new Dictionary<string, IMAXDevice>();
DecoderEncoder.ProcessLMessage(_Message.ToString(), theHouse, currentHouse);
}
#endregion
#region Diff the house
if (previousHouse != null)
{
// only if we already got two houses in here...
List<IDeviceDiffSet> differences = DiffHouse.CalculateDifferences(previousHouse,currentHouse);
if (differences.Count != 0)
{
#region enqueue the difference-sets into the data queue
foreach(IDeviceDiffSet _difference in differences)
{
iQueue.Enqueue(_difference);
}
#endregion
}
}
#endregion
theHouse.UpdateDevices(currentHouse);
// update appropriate devices and in given intervals output non updated
TimeSpan _lastUpdate = DateTime.Now-LastReStoring;
// auto-update every n ... minutes
if (_lastUpdate.TotalSeconds > Properties.Settings.Default.ELVMAXSensorReStoringSec)
{
LastReStoring = DateTime.Now;
foreach(IMAXDevice _device in currentHouse.Values)
{
#region Heating Thermostat
if (_device.Type == DeviceTypes.HeatingThermostat)
{
HeatingThermostat _heating = (HeatingThermostat)_device;
HeatingThermostatDiff _queueable = new HeatingThermostatDiff(_device.Name,_device.AssociatedRoom.RoomID,_device.AssociatedRoom.RoomName);
if (_heating.LowBattery)
_queueable.LowBattery = BatteryStatus.lowbattery;
else
_queueable.LowBattery = BatteryStatus.ok;
_queueable.Mode = _heating.Mode;
_queueable.Temperature = _heating.Temperature;
if (_queueable.Temperature != 0)
iQueue.Enqueue(_queueable);
}
#endregion
#region ShutterContact
if (_device.Type == DeviceTypes.ShutterContact)
{
ShutterContact _shutter = (ShutterContact)_device;
ShutterContactDiff _queueable = new ShutterContactDiff(_device.Name,_device.AssociatedRoom.RoomID,_device.AssociatedRoom.RoomName);
if (_shutter.LowBattery)
_queueable.LowBattery = BatteryStatus.lowbattery;
else
_queueable.LowBattery = BatteryStatus.ok;
_queueable.ShutterState = _shutter.ShutterState;
iQueue.Enqueue(_queueable);
}
#endregion
}
}
Thread.Sleep (MAXUpdateTime);
}
}
catch(Exception e)
{
ConsoleOutputLogger.WriteLine(e.Message);
Thread.Sleep(Properties.Settings.Default.ELVMAXReconnectTimeMsec);
ConsoleOutputLogger.WriteLine("ELV MAX Cube reconnect...");
//stream.Close();
//client.Close();
}
#endregion
}
}
/// <summary>
/// This method calculates the difference between house1 and house2 - whereas house1 is the old house2 the new one
/// </summary>
public static List<IDeviceDiffSet> CalculateDifferences(Dictionary<String,IMAXDevice> DevicesHouse1, Dictionary<String,IMAXDevice> DevicesHouse2)
{
List<IDeviceDiffSet> Differences = new List<IDeviceDiffSet>();
foreach(KeyValuePair<String,IMAXDevice> House1KVPair in DevicesHouse1)
{
// now we have a device from house 1 - we need to get that same device in house 2
if (DevicesHouse2.ContainsKey(House1KVPair.Key))
{
// we got it
IMAXDevice House2Device = DevicesHouse2[House1KVPair.Key];
if (House1KVPair.Value.Type == DeviceTypes.HeatingThermostat)
{
// HeatingThermostat
HeatingThermostatDiff Diff = null;
HeatingThermostat Device1 = (HeatingThermostat)House1KVPair.Value;
HeatingThermostat Device2 = (HeatingThermostat)House2Device;
if (Device1.LowBattery != Device2.LowBattery)
{
if (Diff == null)
Diff = new HeatingThermostatDiff(Device2.Name,Device2.AssociatedRoom.RoomID,Device2.AssociatedRoom.RoomName);
if (Device2.LowBattery)
Diff.LowBattery = BatteryStatus.lowbattery;
else
Diff.LowBattery = BatteryStatus.ok;
}
if (Device1.Mode != Device2.Mode)
{
if (Diff == null)
Diff = new HeatingThermostatDiff(Device2.Name,Device2.AssociatedRoom.RoomID,Device2.AssociatedRoom.RoomName);
Diff.Mode = Device2.Mode;
}
if (Device1.Temperature != Device2.Temperature)
{
if (Diff == null)
Diff = new HeatingThermostatDiff(Device2.Name,Device2.AssociatedRoom.RoomID,Device2.AssociatedRoom.RoomName);
Diff.Temperature = Device2.Temperature;
}
if (Diff != null)
{
if (Diff.Temperature != 0)
Differences.Add(Diff);
}
}
else
if (House1KVPair.Value.Type == DeviceTypes.ShutterContact)
{
// ShutterContact
ShutterContactDiff Diff = null;
ShutterContact Device1 = (ShutterContact)House1KVPair.Value;
ShutterContact Device2 = (ShutterContact)House2Device;
if (Device1.LowBattery != Device2.LowBattery)
{
if (Diff == null)
Diff = new ShutterContactDiff(Device2.Name,Device2.AssociatedRoom.RoomID,Device2.AssociatedRoom.RoomName);
if (Device2.LowBattery)
Diff.LowBattery = BatteryStatus.lowbattery;
else
Diff.LowBattery = BatteryStatus.ok;
}
if (Device1.ShutterState != Device2.ShutterState)
{
if (Diff == null)
Diff = new ShutterContactDiff(Device2.Name,Device2.AssociatedRoom.RoomID,Device2.AssociatedRoom.RoomName);
Diff.ShutterState = Device2.ShutterState;
}
if (Diff != null)
{
Differences.Add(Diff);
}
}
}
}
return Differences;
}
public void Run()
{
// initialize XS1 Configuration
XS1_Configuration = new XS1Configuration(ConfigurationCacheMinutes);
MAXMonitoringThread ELVMax = null;
SolarLogMonitoringThread SolarLog = null;
// Start Sensor-Check Thread
SensorCheck Sensorcheck = new SensorCheck(ConsoleOutputLogger);
Thread SensorCheckThread = new Thread(new ThreadStart(Sensorcheck.Run));
SensorCheckThread.Start();
// Start Actor Re-Switching Thread
ActorReswitching ActorReSwitch_ = new ActorReswitching(XS1_Configuration, ConsoleOutputLogger, TemporaryBlacklist, OnWaitOffLIst);
Thread ActorReswitchThread = new Thread(new ThreadStart(ActorReSwitch_.Run));
ActorReswitchThread.Start();
// Start the SolarLog Thread (if enabled)
// TODO: make it switchable / configurable
if (Properties.Settings.Default.SolarLogEnabled)
{
SolarLog = new SolarLogMonitoringThread(Properties.Settings.Default.SolarLogURLDomain, ConsoleOutputLogger, SolarLog_DataQueue, Properties.Settings.Default.SolarLogUpdateIntervalMsec);
Thread SolarLogThread = new Thread(new ThreadStart(SolarLog.Run));
SolarLogThread.Start();
}
// Start the ELVMax Thread
if (Properties.Settings.Default.ELVMAXEnabled)
{
ELVMax = new MAXMonitoringThread(Properties.Settings.Default.ELVMAXIP, Properties.Settings.Default.ELVMAXPort, ConsoleOutputLogger, MAX_DataQueue, Properties.Settings.Default.ELVMAXUpdateIntervalMsec);
Thread ELVMaxThread = new Thread(new ThreadStart(ELVMax.Run));
ELVMaxThread.Start();
}
XS1MonitoringThread XS1 = new XS1MonitoringThread(ServerName, ConsoleOutputLogger, UserName, Password, XS1_DataQueue);
Thread XS1Thread = new Thread(new ThreadStart(XS1.Run));
XS1Thread.Start();
// Start integrated HTTP Server
HttpServer httpServer = new HttpServer(Properties.Settings.Default.HTTPPort, Properties.Settings.Default.HTTPIP, Properties.Settings.Default.HTTPDocumentRoot, sensor_data_store, miataru_data_store, XS1_Configuration, ConsoleOutputLogger, ELVMax, Properties.Settings.Default.HTTPAuthEnabled, Properties.Settings.Default.HTTPAuthUsername, Properties.Settings.Default.HTTPAuthPassword, Properties.Settings.Default.HTTPAuthDisabledAdressStartsWith);
Thread http_server_thread = new Thread(new ThreadStart(httpServer.listen));
http_server_thread.Start();
// Start Service Monitorng thread
if (Properties.Settings.Default.NetworkMonitorEnabled)
{
NetworkMonitoring monitor = new NetworkMonitoring(ConsoleOutputLogger, NetworkMonitor_Queue, Properties.Settings.Default.NetworkMonitorUpdateIntervalMsec);
Thread monitorThread = new Thread(new ThreadStart(monitor.Run));
monitorThread.Start();
}
// Start Alarming thread
if (Properties.Settings.Default.AlarmingEnabled)
{
AlarmingThread alarmThread = new AlarmingThread(ConsoleOutputLogger, Alarming_Queue, sensor_data_store, actor_data_store, miataru_data_store);
Thread alarming_thread = new Thread(new ThreadStart(alarmThread.Run));
alarming_thread.Start();
}
// Start Miataru Thread
if (Properties.Settings.Default.MiataruEnabled)
{
MiataruThread miataruThread = new MiataruThread(ConsoleOutputLogger, miataru_data_store, Properties.Settings.Default.MiataruUpdateTime);
Thread miataru_Thread = new Thread(new ThreadStart(miataruThread.Run));
miataru_Thread.Start();
}
// Start MQTT Thread
if (Properties.Settings.Default.MQTTBindingEnabled)
{
MQTT_Binding = new MQTT_Handling(ConsoleOutputLogger);
Thread mqtt_Thread = new Thread(new ThreadStart(MQTT_Binding.Run));
mqtt_Thread.Start();
}
while (!Shutdown)
{
try
{
#region Handle XS1 events
XS1_DataObject dataobject = null;
if (XS1_DataQueue.TryDequeue(out dataobject))
{
if (dataobject.Type == ObjectTypes.Actor)
{
// Write to Disk
lock (actor_data_store)
{
actor_data_store.Write(dataobject.Serialize());
}
lock (KnownActorStates.KnownActorStatuses)
{
bool usethisactor = true;
// check if this actor is on temporary blacklist (like when it was handled)
lock (TemporaryBlacklist)
{
if (TemporaryBlacklist.Contains(dataobject.Name))
{
usethisactor = false;
}
TemporaryBlacklist.Remove(dataobject.Name);
}
if (usethisactor)
{
// if Alarming is enabled, queue this XS1 Event up for alarming...
if (Properties.Settings.Default.AlarmingEnabled)
{
Alarming_Queue.Enqueue(dataobject);
}
// this actor action did not result in any action hacs made - so we try to make the best out of it
#region Scripting Handling
// check if this sensor is something we should act uppon
foreach (ScriptingActorElement Element in ScriptingActorConfiguration.ScriptingActorActions)
{
if (dataobject.Name == Element.SensorToWatchName)
{
if (dataobject.Value == Element.SensorValue)
{
// obviously there is a ScriptingActorConfiguration entry
// so we execute the actor preset
set_state_actuator.set_state_actuator ssa = new set_state_actuator.set_state_actuator();
ConsoleOutputLogger.WriteLineToScreenOnly("detected actor scripting action on actor " + Element.SensorToWatchName + " - " + Element.ActorToSwitchName + " to " + Element.ActionToRunName);
if (Element.isCurrentlyWithinStartEndHours())
{
#region Scripting Actor Actions
if (Element.ActionToRunName == actor_status.URL)
{
ConsoleOutputLogger.WriteLine("Scripting Actor URL");
// handle URLs -> the ActorToSwitch Name will be the URL to trigger
try
{
WebClient client = new WebClient();
client.Encoding = System.Text.Encoding.UTF8;
String JSONInput = client.DownloadString(Element.ActorToSwitchName);
ConsoleOutputLogger.WriteLine("Doing HTTP GET on: " + Element.ActorToSwitchName);
}
catch (Exception e)
{
ConsoleOutputLogger.WriteLine("Exception on URL Actor Scripting: " + e.Message);
}
}
// check what action is going to happen now...
if (Element.ActionToRunName == actor_status.On)
{
ssa.SetStateActuatorPreset(hacs.Properties.Settings.Default.XS1, hacs.Properties.Settings.Default.Username, hacs.Properties.Settings.Default.Password, Element.ActorToSwitchName, "ON", XS1_Configuration);
}
if (Element.ActionToRunName == actor_status.Off)
{
ssa.SetStateActuatorPreset(hacs.Properties.Settings.Default.XS1, hacs.Properties.Settings.Default.Username, hacs.Properties.Settings.Default.Password, Element.ActorToSwitchName, "OFF", XS1_Configuration);
// remove from OnWaitOffList
lock (OnWaitOffLIst)
{
if (OnWaitOffLIst.Contains(Element.ActorToSwitchName))
{
OnWaitOffLIst.Remove(Element.ActorToSwitchName);
}
}
}
if (Element.ActionToRunName == actor_status.OnOff)
{
// look for the current status in the known actors table
lock (KnownActorStates.KnownActorStatuses)
{
if (KnownActorStates.KnownActorStatuses.ContainsKey(Element.ActorToSwitchName))
{
current_actor_status Status = KnownActorStates.KnownActorStatuses[Element.ActorToSwitchName];
if (Status.Status == actor_status.On)
{
ssa.SetStateActuatorPreset(hacs.Properties.Settings.Default.XS1, hacs.Properties.Settings.Default.Username, hacs.Properties.Settings.Default.Password, Element.ActorToSwitchName, "OFF", XS1_Configuration);
}
else
if (Status.Status == actor_status.Off)
{
ssa.SetStateActuatorPreset(hacs.Properties.Settings.Default.XS1, hacs.Properties.Settings.Default.Username, hacs.Properties.Settings.Default.Password, Element.ActorToSwitchName, "ON", XS1_Configuration);
}
}
else
{
ssa.SetStateActuatorPreset(hacs.Properties.Settings.Default.XS1, hacs.Properties.Settings.Default.Username, hacs.Properties.Settings.Default.Password, Element.ActorToSwitchName, "ON", XS1_Configuration);
}
}
}
if (Element.ActionToRunName == actor_status.OnWaitOff)
{
lock (OnWaitOffLIst)
{
ConsoleOutputLogger.WriteLine("Adding " + Element.ActorToSwitchName + " to ActorReSwitching OnWaitOff List");
OnWaitOffLIst.Add(Element.ActorToSwitchName);
}
ssa.SetStateActuatorPreset(hacs.Properties.Settings.Default.XS1, hacs.Properties.Settings.Default.Username, hacs.Properties.Settings.Default.Password, Element.ActorToSwitchName, "ON_WAIT_OFF", XS1_Configuration);
}
#endregion
}
}
}
}
#endregion
#region MQTT Handling Actor
if (Properties.Settings.Default.MQTTBindingEnabled)
{
MQTT_Binding.MQTT_Handle_Actor(dataobject);
}
#endregion
if (KnownActorStates.KnownActorStatuses.ContainsKey(dataobject.Name))
{
// is contained
if (dataobject.Value == 100)
{
KnownActorStates.KnownActorStatuses[dataobject.Name] = new current_actor_status(dataobject.Name, actor_status.On);
}
else
{
KnownActorStates.KnownActorStatuses[dataobject.Name] = new current_actor_status(dataobject.Name, actor_status.Off);
}
}
else
{
if (dataobject.Value == 100)
{
KnownActorStates.KnownActorStatuses.Add(dataobject.Name, new current_actor_status(dataobject.Name, actor_status.On));
}
else
{
KnownActorStates.KnownActorStatuses.Add(dataobject.Name, new current_actor_status(dataobject.Name, actor_status.Off));
}
}
}
else
{
ConsoleOutputLogger.WriteLine("Actor " + dataobject.Name + " is on the blacklist (ActorReSwitching) and therefore is ignored this time.");
}
}
}
else
if (dataobject.Type == ObjectTypes.Sensor)
{
lock (sensor_data_store)
{
sensor_data_store.Write(dataobject.Serialize());
}
// update the sensor in the sensor check
Sensorcheck.UpdateSensor(dataobject.Name);
// if Alarming is enabled, queue this XS1 Event up for alarming...
if (Properties.Settings.Default.AlarmingEnabled)
{
if (!dataobject.IgnoreForAlarming) // this if for those events which get re-queued as xs1 events despite being for example elvmax events
{
Alarming_Queue.Enqueue(dataobject);
}
}
#region Scripting
// check if this sensor is something we should act uppon
foreach (ScriptingActorElement Element in ScriptingActorConfiguration.ScriptingActorActions)
{
if (dataobject.Name == Element.SensorToWatchName)
{
if (dataobject.Value == Element.SensorValue)
{
// obviously there is a ScriptingActorConfiguration entry
// so we execute the actor preset
set_state_actuator.set_state_actuator ssa = new set_state_actuator.set_state_actuator();
ConsoleOutputLogger.WriteLineToScreenOnly("detected actor scripting action on sensor " + Element.SensorToWatchName + " - " + Element.ActorToSwitchName + " to " + Element.ActionToRunName);
if (Element.isCurrentlyWithinStartEndHours())
{
#region Scripting Actor actions
if (Element.ActionToRunName == actor_status.URL)
{
ConsoleOutputLogger.WriteLine("Scripting Actor URL");
// handle URLs -> the ActorToSwitch Name will be the URL to trigger
try
{
WebClient client = new WebClient();
client.Encoding = System.Text.Encoding.UTF8;
String JSONInput = client.DownloadString(Element.ActorToSwitchName);
ConsoleOutputLogger.WriteLine("Doing HTTP GET on: " + Element.ActorToSwitchName);
}
catch (Exception e)
{
ConsoleOutputLogger.WriteLine("Exception on URL Actor Scripting: " + e.Message);
}
}
// check what action is going to happen now...
if (Element.ActionToRunName == actor_status.On)
{
ssa.SetStateActuatorPreset(hacs.Properties.Settings.Default.XS1, hacs.Properties.Settings.Default.Username, hacs.Properties.Settings.Default.Password, Element.ActorToSwitchName, "ON", XS1_Configuration);
}
if (Element.ActionToRunName == actor_status.Off)
{
ssa.SetStateActuatorPreset(hacs.Properties.Settings.Default.XS1, hacs.Properties.Settings.Default.Username, hacs.Properties.Settings.Default.Password, Element.ActorToSwitchName, "OFF", XS1_Configuration);
// remove from OnWaitOffList
lock (OnWaitOffLIst)
{
if (OnWaitOffLIst.Contains(Element.ActorToSwitchName))
{
OnWaitOffLIst.Remove(Element.ActorToSwitchName);
}
}
}
if (Element.ActionToRunName == actor_status.OnOff)
{
// look for the current status in the known actors table
lock (KnownActorStates.KnownActorStatuses)
{
if (KnownActorStates.KnownActorStatuses.ContainsKey(Element.ActorToSwitchName))
{
current_actor_status Status = KnownActorStates.KnownActorStatuses[Element.ActorToSwitchName];
if (Status.Status == actor_status.On)
{
ssa.SetStateActuatorPreset(hacs.Properties.Settings.Default.XS1, hacs.Properties.Settings.Default.Username, hacs.Properties.Settings.Default.Password, Element.ActorToSwitchName, "OFF", XS1_Configuration);
}
else
if (Status.Status == actor_status.Off)
{
ssa.SetStateActuatorPreset(hacs.Properties.Settings.Default.XS1, hacs.Properties.Settings.Default.Username, hacs.Properties.Settings.Default.Password, Element.ActorToSwitchName, "ON", XS1_Configuration);
}
}
else
{
ssa.SetStateActuatorPreset(hacs.Properties.Settings.Default.XS1, hacs.Properties.Settings.Default.Username, hacs.Properties.Settings.Default.Password, Element.ActorToSwitchName, "ON", XS1_Configuration);
}
}
}
if (Element.ActionToRunName == actor_status.OnWaitOff)
{
lock (OnWaitOffLIst)
{
ConsoleOutputLogger.WriteLine("Adding " + Element.ActorToSwitchName + " to ActorReSwitching OnWaitOff List");
OnWaitOffLIst.Add(Element.ActorToSwitchName);
}
ssa.SetStateActuatorPreset(hacs.Properties.Settings.Default.XS1, hacs.Properties.Settings.Default.Username, hacs.Properties.Settings.Default.Password, Element.ActorToSwitchName, "ON_WAIT_OFF", XS1_Configuration);
}
#endregion
}
else
{
ConsoleOutputLogger.WriteLine("Actorswitching Action not triggered since it's out of timespan. (" + Element.StartHour + "-" + Element.EndHour + ")");
}
}
}
}
#endregion
#region MQTT Handling Sensor
if (Properties.Settings.Default.MQTTBindingEnabled)
{
MQTT_Binding.MQTT_Handle_Sensor(dataobject);
}
#endregion
}
else
if (dataobject.Type == ObjectTypes.Unknown)
{
unknown_data_store.Write(dataobject.Serialize());
}
ConsoleOutputLogger.WriteLine(ServerName + " - " + dataobject.OriginalXS1Statement);
}
#endregion
#region Handle MAX events
// the strategy for MAX events is quite easy: emulate XS1 events and stuff the XS1 queue with those faked events
// that takes care of the storage and the
if (Properties.Settings.Default.ELVMAXEnabled)
{
IDeviceDiffSet max_dataobject = null;
if (MAX_DataQueue.TryDequeue(out max_dataobject))
{
// if Alarming is enabled, queue this ELV MAX up for alarming...
if (Properties.Settings.Default.AlarmingEnabled)
{
Alarming_Queue.Enqueue(max_dataobject);
}
StringBuilder sb = new StringBuilder();
sb.Append("S\t" + max_dataobject.DeviceName + "\t" + max_dataobject.DeviceType);
if (max_dataobject.DeviceType == DeviceTypes.HeatingThermostat)
{
HeatingThermostatDiff _heating = (HeatingThermostatDiff)max_dataobject;
// this is what is different on the heating thermostats
//ConsoleOutputLogger.WriteLine(_heating.ToString());
// first the temperature data
XS1_DataObject maxdataobject = new XS1_DataObject(Properties.Settings.Default.ELVMAXIP, _heating.RoomName + "-" + _heating.DeviceName, ObjectTypes.Sensor, "heating_thermostat", DateTime.Now, _heating.RoomID, _heating.Temperature, _heating.ToString(), true);
SensorCheckIgnoreConfiguration.AddToIgnoreList(maxdataobject.Name);
XS1_DataQueue.Enqueue(maxdataobject);
// then the low battery if exists
if (_heating.LowBattery == BatteryStatus.lowbattery)
{
XS1_DataObject lowbatteryobject = new XS1_DataObject(Properties.Settings.Default.ELVMAXIP, _heating.RoomName + "-" + _heating.DeviceName, ObjectTypes.Sensor, "low_battery", DateTime.Now, _heating.RoomID, _heating.Temperature, _heating.ToString() + ", LowBattery", true);
SensorCheckIgnoreConfiguration.AddToIgnoreList(lowbatteryobject.Name);
XS1_DataQueue.Enqueue(lowbatteryobject);
}
if (_heating.Mode == ThermostatModes.boost)
{
XS1_DataObject boostmodeobject = new XS1_DataObject(Properties.Settings.Default.ELVMAXIP, _heating.RoomName + "-" + _heating.DeviceName, ObjectTypes.Sensor, "boost", DateTime.Now, _heating.RoomID, _heating.Temperature, _heating.ToString() + ", Boost", true);
SensorCheckIgnoreConfiguration.AddToIgnoreList(boostmodeobject.Name);
XS1_DataQueue.Enqueue(boostmodeobject);
}
}
if (max_dataobject.DeviceType == DeviceTypes.ShutterContact)
{
ShutterContactDiff _shutter = (ShutterContactDiff)max_dataobject;
// this is what is different on the ShutterContacts
//ConsoleOutputLogger.WriteLine(_shutter.ToString());
// first the open/close status
if (_shutter.ShutterState == ShutterContactModes.open)
{
XS1_DataObject maxdataobject = new XS1_DataObject(Properties.Settings.Default.ELVMAXIP, _shutter.RoomName + "-" + _shutter.DeviceName, ObjectTypes.Sensor, "shutter_contact", DateTime.Now, _shutter.RoomID, 1.0, _shutter.ToString(), true);
SensorCheckIgnoreConfiguration.AddToIgnoreList(maxdataobject.Name);
XS1_DataQueue.Enqueue(maxdataobject);
}
else
{
XS1_DataObject maxdataobject = new XS1_DataObject(Properties.Settings.Default.ELVMAXIP, _shutter.RoomName + "-" + _shutter.DeviceName, ObjectTypes.Sensor, "shutter_contact", DateTime.Now, _shutter.RoomID, 0.0, _shutter.ToString(), true);
SensorCheckIgnoreConfiguration.AddToIgnoreList(maxdataobject.Name);
XS1_DataQueue.Enqueue(maxdataobject);
}
// then the low battery if exists
if (_shutter.LowBattery == BatteryStatus.lowbattery)
{
if (_shutter.ShutterState == ShutterContactModes.open)
{
XS1_DataObject lowbatteryobject = new XS1_DataObject(Properties.Settings.Default.ELVMAXIP, _shutter.RoomName + "-" + _shutter.DeviceName, ObjectTypes.Sensor, "low_battery", DateTime.Now, _shutter.RoomID, 1.0, _shutter.ToString() + ",LowBattery", true);
SensorCheckIgnoreConfiguration.AddToIgnoreList(lowbatteryobject.Name);
XS1_DataQueue.Enqueue(lowbatteryobject);
}
else
{
XS1_DataObject lowbatteryobject = new XS1_DataObject(Properties.Settings.Default.ELVMAXIP, _shutter.RoomName + "-" + _shutter.DeviceName, ObjectTypes.Sensor, "low_battery", DateTime.Now, _shutter.RoomID, 0.0, _shutter.ToString() + ",LowBattery", true);
SensorCheckIgnoreConfiguration.AddToIgnoreList(lowbatteryobject.Name);
XS1_DataQueue.Enqueue(lowbatteryobject);
}
}
}
}
}
#endregion
#region Handle SolarLog events
if (Properties.Settings.Default.SolarLogEnabled)
{
SolarLogDataSet solarlog_dataobject = null;
if (SolarLog_DataQueue.TryDequeue(out solarlog_dataobject))
{
// Pac
XS1_DataQueue.Enqueue(new XS1_DataObject(Properties.Settings.Default.SolarLogURLDomain, "Pac", ObjectTypes.Sensor, "Pac", solarlog_dataobject.DateAndTime, 1, solarlog_dataobject.Pac, "solarlog," + Properties.Settings.Default.SolarLogURLDomain + ",Pac," + solarlog_dataobject.Pac + "," + solarlog_dataobject.DateAndTime.Ticks, true));
// aPdc
XS1_DataQueue.Enqueue(new XS1_DataObject(Properties.Settings.Default.SolarLogURLDomain, "aPdc", ObjectTypes.Sensor, "aPdc", solarlog_dataobject.DateAndTime, 1, solarlog_dataobject.aPdc, "solarlog," + Properties.Settings.Default.SolarLogURLDomain + ",aPdc," + solarlog_dataobject.aPdc + "," + solarlog_dataobject.DateAndTime.Ticks, true));
// if Alarming is enabled, queue this SolarLog Event up for alarming...
if (Properties.Settings.Default.AlarmingEnabled)
{
Alarming_Queue.Enqueue(solarlog_dataobject);
}
}
}
#endregion
#region Handle Network Monitor events
if (Properties.Settings.Default.NetworkMonitorEnabled)
{
NetworkMonitoringDataSet networkmonitor_dataobject = null;
if (NetworkMonitor_Queue.TryDequeue(out networkmonitor_dataobject))
{
if (networkmonitor_dataobject.Status == Org.Mentalis.Network.ICMP_Status.Success)
{
XS1_DataQueue.Enqueue(new XS1_DataObject(networkmonitor_dataobject.Descriptor, networkmonitor_dataobject.HostnameIP, ObjectTypes.Sensor, "Ping", networkmonitor_dataobject.TimeOfMeasurement, 2, 1, "OnlineCheck," + networkmonitor_dataobject.HostnameIP + "," + networkmonitor_dataobject.Descriptor + ",Online", true));
}
else
{
XS1_DataQueue.Enqueue(new XS1_DataObject(networkmonitor_dataobject.Descriptor, networkmonitor_dataobject.HostnameIP, ObjectTypes.Sensor, "Ping", networkmonitor_dataobject.TimeOfMeasurement, 2, 0, "OnlineCheck," + networkmonitor_dataobject.HostnameIP + "," + networkmonitor_dataobject.Descriptor + ",Offline", true));
}
// if Alarming is enabled, queue this Network Monitor Event up for alarming...
if (Properties.Settings.Default.AlarmingEnabled)
{
Alarming_Queue.Enqueue(networkmonitor_dataobject);
}
}
}
#endregion
}
catch (Exception)
{
AcceptingCommands = false;
//Thread.Sleep(1);
}
Thread.Sleep(1);
}
if (ELVMax != null)
{
ELVMax.running = false;
}
XS1.running = false;
Thread.Sleep(200); // ... msecs period to wait for new input...
}
public void Run()
{
ConsoleOutputLogger.WriteLine("Alarming Thread started");
while (!Shutdown)
{
try
{
IAlarmingEvent dataobject = null;
if (Alarming_Queue.TryDequeue(out dataobject))
{
// we should get events from all sorts of devices here - let's take them and check if they
// are eventually matching the activators - if they do we check against the other
// data storages to follow up with the alarms...
// check if we find this in the alarms...
foreach (Alarm _alarm in AlarmingConfiguration.Alarms.Alarms)
{
foreach (Activator _activator in _alarm.activators)
{
// activator names are case sensitive!!!
if (dataobject.AlarmingName() == _activator.name)
{
// we got a positive activator match here!
// now check further circumstances...
#region XS1 Events
if ((_activator.device.ToUpper() == "XS1") && (dataobject.AlarmingType() == AlarmingEventType.XS1Event))
{
// now we got an alarm triggering this activator and device...
// check if the type matches...
XS1_DataObject xs1_data = (XS1_DataObject)dataobject;
if (_activator.type.ToUpper() == xs1_data.TypeName.ToUpper())
{
// for the value comparison convert the given value to a double...
double comp_value = Convert.ToDouble(_activator.value);
// it's the right typename...
// now we gotta check for the right value there...
Boolean alarm_activated = false;
#region Activator Value Comparison
switch (_activator.comparison)
{
case "==":
if (comp_value == xs1_data.Value)
{
// hurray, everything matches! Activate this event!!!
alarm_activated = true;
}
break;
case "<=":
if (comp_value <= xs1_data.Value)
{
// hurray, everything matches! Activate this event!!!
alarm_activated = true;
}
break;
case ">=":
if (comp_value >= xs1_data.Value)
{
// hurray, everything matches! Activate this event!!!
alarm_activated = true;
}
break;
}
#endregion
#region do the sensor and actor checks...
// TODO: this is very rough - needs to be worked out more later on...
// for the moment it is just a actor check - MORE HERE !!!!!!!!
if (alarm_activated)
{
foreach (Actorcheck _actor in _alarm.actorchecks)
{
#region XS1 actors...
if (_actor.device.ToUpper() == "XS1")
{
if (KnownActorStates.KnownActorStatuses.ContainsKey(_actor.name))
{
// there's an actor...
current_actor_status status = (current_actor_status)KnownActorStates.KnownActorStatuses[_actor.name];
// TODO: what about actor types!?
if (_actor.value.ToUpper() == "ON")
{
// so it should be on...
if (status.Status != actor_status.On)
{
alarm_activated = false;
}
}
if (_actor.value.ToUpper() == "OFF")
{
// so it should be off...
if (status.Status != actor_status.Off)
{
alarm_activated = false;
}
}
}
}
#endregion
}
}
#endregion
if (alarm_activated)
{
ConsoleOutputLogger.WriteLine("!!!! ALARM - " + _alarm.name + " - ALARM !!!!");
// authenticate Telekom
if (Properties.Settings.Default.UseTelekomSMSInsteadofSMS77)
{
TelekomSMSGateway = new TelekomSendSMSGateway(Properties.Settings.Default.TelekomSMSClientID, Properties.Settings.Default.TelekomSMSClientSecret);
}
// send out the SMS...
foreach (Smsrecipient recipient in _alarm.smsrecipients)
{
ConsoleOutputLogger.WriteLine("Sending Alarm SMS to " + recipient.number + " for alarm " + _alarm.name);
try
{
if (!Properties.Settings.Default.UseTelekomSMSInsteadofSMS77)
{
SMSGateway.SendSMS(recipient.number, _alarm.message, Properties.Settings.Default.AlarmingSMS77SenderNumber, false, false, SMSType.quality);
}
else
{
TelekomSMSGateway.Send(recipient.number, _alarm.message, Properties.Settings.Default.AlarmingSMS77SenderNumber);
}
}
catch (Exception e)
{
ConsoleOutputLogger.WriteLine("SMS Sending Exception: " + e.Message);
}
}
}
}
}
#endregion
#region ELVMAX Events
if ((_activator.device.ToUpper() == "ELVMAX") && (dataobject.AlarmingType() == AlarmingEventType.ELVMAXEvent))
{
//ConsoleOutputLogger.WriteLine("ELVMAX: " + _activator.device);
// now we got an alarm triggering this activator and device...
// check if the type matches...
IDeviceDiffSet diffset = (IDeviceDiffSet)dataobject;
//ConsoleOutputLogger.WriteLine("ELVMAX: " + diffset.DeviceName);
//ConsoleOutputLogger.WriteLine("ELVMAX: " + diffset.RoomName);
//ConsoleOutputLogger.WriteLine("ELVMAX: " + _activator.type);
//ConsoleOutputLogger.WriteLine("ELVMAX: " + _activator.name);
// for now only shuttercontacts are interesting
if ((_activator.type.ToUpper() == "SHUTTERCONTACT") && (diffset.DeviceType == DeviceTypes.ShutterContact) &&
(_activator.name == diffset.DeviceName))
{
//ConsoleOutputLogger.WriteLine("ELVMAX Shuttercontact");
ShutterContactDiff shutterdiff = (ShutterContactDiff)diffset;
//ConsoleOutputLogger.WriteLine("ELVMAX: "+shutterdiff.ToString());
ShutterContactModes activatorstate = ShutterContactModes.unchanged;
Boolean alarm_activated = false;
if (_activator.value.ToUpper() == "OPEN")
{
activatorstate = ShutterContactModes.open;
}
if (_activator.value.ToUpper() == "CLOSED")
{
activatorstate = ShutterContactModes.closed;
}
if (activatorstate == shutterdiff.ShutterState)
{
alarm_activated = true;
}
#region do the sensor and actor checks...
// TODO: this is very rough - needs to be worked out more later on...
// for the moment it is just a actor check - MORE HERE !!!!!!!!
if (alarm_activated)
{
foreach (Actorcheck _actor in _alarm.actorchecks)
{
#region XS1 actors...
if (_actor.device.ToUpper() == "XS1")
{
if (KnownActorStates.KnownActorStatuses.ContainsKey(_actor.name))
{
// there's an actor...
current_actor_status status = (current_actor_status)KnownActorStates.KnownActorStatuses[_actor.name];
// TODO: what about actor types!?
if (_actor.value.ToUpper() == "ON")
{
// so it should be on...
if (status.Status != actor_status.On)
{
alarm_activated = false;
}
}
if (_actor.value.ToUpper() == "OFF")
{
// so it should be off...
if (status.Status != actor_status.Off)
{
alarm_activated = false;
}
}
}
}
#endregion
}
}
#endregion
if (alarm_activated)
{
ConsoleOutputLogger.WriteLine("!!!! ALARM - " + _alarm.name + " - ALARM !!!!");
// authenticate Telekom
if (Properties.Settings.Default.UseTelekomSMSInsteadofSMS77)
{
TelekomSMSGateway = new TelekomSendSMSGateway(Properties.Settings.Default.TelekomSMSClientID, Properties.Settings.Default.TelekomSMSClientSecret);
}
// send out the SMS...
foreach (Smsrecipient recipient in _alarm.smsrecipients)
{
ConsoleOutputLogger.WriteLine("Sending Alarm SMS to " + recipient.number + " for alarm " + _alarm.name);
try
{
if (!Properties.Settings.Default.UseTelekomSMSInsteadofSMS77)
{
SMSGateway.SendSMS(recipient.number, _alarm.message, Properties.Settings.Default.AlarmingSMS77SenderNumber, false, false, SMSType.quality);
}
else
{
TelekomSMSGateway.Send(recipient.number, _alarm.message, Properties.Settings.Default.AlarmingSMS77SenderNumber);
}
}
catch (Exception e)
{
ConsoleOutputLogger.WriteLine("SMS Sending Exception: " + e.Message);
}
}
}
}
}
#endregion
// TODO: ------------------------------
#region SolarLog Events
if ((_activator.device.ToUpper() == "SOLARLOG") && (dataobject.AlarmingType() == AlarmingEventType.SolarLogEvent))
{
// now we got an alarm triggering this activator and device...
}
#endregion
#region Network Monitor Events
if ((_activator.device.ToUpper() == "NETWORKMONITOR") && (dataobject.AlarmingType() == AlarmingEventType.NetworkingEvent))
{
// now we got an alarm triggering this activator and device...
}
#endregion
#region Google Latitude Events
if ((_activator.device.ToUpper() == "GOOGLELATITUDE") && (dataobject.AlarmingType() == AlarmingEventType.GoogleLatitudeEvent))
{
// now we got an alarm triggering this activator and device...
}
#endregion
}
}
}
}
}
catch (Exception e)
{
//Shutdown = true;
ConsoleOutputLogger.WriteLine("Alarming Exception: " + e.Message);
ConsoleOutputLogger.WriteLine("Stopping Alarming Execution!");
Thread.Sleep(100);
}
Thread.Sleep(10);
}
}
// this is the ELV MAX! Cube monitoring script
public void Run()
{
while (running)
{
TcpClient client;
NetworkStream stream;
Dictionary <String, IMAXDevice> currentHouse = new Dictionary <string, IMAXDevice>();
#region Update House
try
{
// now fill that with the initial handshake data...
#region Initial connect and retrieving everything we get from the cube
// network connect and first initialization
client = new TcpClient();
client.Connect(Hostname, Port);
stream = client.GetStream();
// the read buffer (chosen quite big)
byte[] myReadBuffer = new byte[4096 * 8];
List <String> Messages = new List <string>();
// to build the complete message
StringBuilder myCompleteMessage = new StringBuilder();
int numberOfBytesRead = 0;
MAXEncodeDecode DecoderEncoder = new MAXEncodeDecode();
keepRunning = true;
// Incoming message may be larger than the buffer size.
do
{
myCompleteMessage = new StringBuilder();
stream.ReadTimeout = 1000;
try
{
numberOfBytesRead = stream.Read(myReadBuffer, 0, myReadBuffer.Length);
myCompleteMessage.AppendFormat("{0}", Encoding.ASCII.GetString(myReadBuffer, 0, numberOfBytesRead));
Messages.Add(myCompleteMessage.ToString());
}
catch (Exception)
{
previousHouse = null;
// everything to start
theHouse = new House();
keepRunning = false;
}
}while(keepRunning);
#endregion
ConsoleOutputLogger.WriteLine("ELV MAX Cube connected...");
#region preprocess
List <String> PreProcessedMessages = new List <string>();
foreach (String _Message in Messages)
{
if (_Message.Remove(_Message.Length - 2).Contains("\r\n"))
{
String[] PMessages = _Message.Remove(_Message.Length - 2).Split(new char[1] {
'\n'
}, StringSplitOptions.RemoveEmptyEntries);
foreach (String pmessage in PMessages)
{
PreProcessedMessages.Add(pmessage.Replace("\r", "") + "\r\n");
}
}
else
{
PreProcessedMessages.Add(_Message);
}
}
#endregion
#region process
// Analyze and Output Messages, feed them to the decoder
foreach (String _Message in PreProcessedMessages)
{
//IMAXMessage Message = DecoderEncoder.ProcessMessage(_Message.ToString(), theHouse);
// if (Message != null)
// {
// ConsoleOutputLogger.WriteLine(_Message.ToString());
// ConsoleOutputLogger.WriteLine(Message.ToString());
// ConsoleOutputLogger.WriteLine("");
// }
DecoderEncoder.ProcessMessage(_Message.ToString(), theHouse);
}
#endregion
while (running)
{
// when we are here, we got a filled "theHouse" which does contain first hand L message information
previousHouse = theHouse.GetAllDevicesInADictionary();
#region send L: request and get all the feedback
System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
byte[] args_data_buffer = enc.GetBytes("l:\r\n");
Messages = new List <string>();
keepRunning = true;
// Incoming message may be larger than the buffer size.
stream.Write(args_data_buffer, 0, args_data_buffer.Length);
do
{
myCompleteMessage = new StringBuilder();
stream.ReadTimeout = 1000;
try
{
numberOfBytesRead = stream.Read(myReadBuffer, 0, myReadBuffer.Length);
myCompleteMessage.AppendFormat("{0}", Encoding.ASCII.GetString(myReadBuffer, 0, numberOfBytesRead));
Messages.Add(myCompleteMessage.ToString());
}
catch (Exception)
{
keepRunning = false;
}
}while(keepRunning);
#endregion
#region preprocess
PreProcessedMessages = new List <string>();
foreach (String _Message in Messages)
{
if (_Message.Remove(_Message.Length - 2).Contains("\r\n"))
{
String[] PMessages = _Message.Remove(_Message.Length - 2).Split(new char[1] {
'\n'
}, StringSplitOptions.RemoveEmptyEntries);
foreach (String pmessage in PMessages)
{
PreProcessedMessages.Add(pmessage.Replace("\r", "") + "\r\n");
}
}
else
{
PreProcessedMessages.Add(_Message);
}
}
#endregion
#region process
// Analyze and Output Messages, feed them to the decoder
foreach (String _Message in PreProcessedMessages)
{
//IMAXMessage Message = DecoderEncoder.ProcessMessage(_Message.ToString(), theHouse);
// if (Message != null)
// {
// ConsoleOutputLogger.WriteLine(_Message.ToString());
// ConsoleOutputLogger.WriteLine(Message.ToString());
// ConsoleOutputLogger.WriteLine("");
// }
currentHouse = new Dictionary <string, IMAXDevice>();
DecoderEncoder.ProcessLMessage(_Message.ToString(), theHouse, currentHouse);
}
#endregion
#region Diff the house
if (previousHouse != null)
{
// only if we already got two houses in here...
List <IDeviceDiffSet> differences = DiffHouse.CalculateDifferences(previousHouse, currentHouse);
if (differences.Count != 0)
{
#region enqueue the difference-sets into the data queue
foreach (IDeviceDiffSet _difference in differences)
{
iQueue.Enqueue(_difference);
}
#endregion
}
}
#endregion
theHouse.UpdateDevices(currentHouse);
// update appropriate devices and in given intervals output non updated
TimeSpan _lastUpdate = DateTime.Now - LastReStoring;
// auto-update every n ... minutes
if (_lastUpdate.TotalSeconds > Properties.Settings.Default.ELVMAXSensorReStoringSec)
{
LastReStoring = DateTime.Now;
foreach (IMAXDevice _device in currentHouse.Values)
{
#region Heating Thermostat
if (_device.Type == DeviceTypes.HeatingThermostat)
{
HeatingThermostat _heating = (HeatingThermostat)_device;
HeatingThermostatDiff _queueable = new HeatingThermostatDiff(_device.Name, _device.AssociatedRoom.RoomID, _device.AssociatedRoom.RoomName);
if (_heating.LowBattery)
{
_queueable.LowBattery = BatteryStatus.lowbattery;
}
else
{
_queueable.LowBattery = BatteryStatus.ok;
}
_queueable.Mode = _heating.Mode;
_queueable.Temperature = _heating.Temperature;
if (_queueable.Temperature != 0)
{
iQueue.Enqueue(_queueable);
}
}
#endregion
#region ShutterContact
if (_device.Type == DeviceTypes.ShutterContact)
{
ShutterContact _shutter = (ShutterContact)_device;
ShutterContactDiff _queueable = new ShutterContactDiff(_device.Name, _device.AssociatedRoom.RoomID, _device.AssociatedRoom.RoomName);
if (_shutter.LowBattery)
{
_queueable.LowBattery = BatteryStatus.lowbattery;
}
else
{
_queueable.LowBattery = BatteryStatus.ok;
}
_queueable.ShutterState = _shutter.ShutterState;
iQueue.Enqueue(_queueable);
}
#endregion
}
}
Thread.Sleep(MAXUpdateTime);
}
}
catch (Exception e)
{
ConsoleOutputLogger.WriteLine(e.Message);
Thread.Sleep(Properties.Settings.Default.ELVMAXReconnectTimeMsec);
ConsoleOutputLogger.WriteLine("ELV MAX Cube reconnect...");
//stream.Close();
//client.Close();
}
#endregion
}
}
/// <summary>
/// This method calculates the difference between house1 and house2 - whereas house1 is the old house2 the new one
/// </summary>
public static List <IDeviceDiffSet> CalculateDifferences(Dictionary <String, IMAXDevice> DevicesHouse1, Dictionary <String, IMAXDevice> DevicesHouse2)
{
List <IDeviceDiffSet> Differences = new List <IDeviceDiffSet>();
foreach (KeyValuePair <String, IMAXDevice> House1KVPair in DevicesHouse1)
{
// now we have a device from house 1 - we need to get that same device in house 2
if (DevicesHouse2.ContainsKey(House1KVPair.Key))
{
// we got it
IMAXDevice House2Device = DevicesHouse2[House1KVPair.Key];
if (House1KVPair.Value.Type == DeviceTypes.HeatingThermostat)
{
// HeatingThermostat
HeatingThermostatDiff Diff = null;
HeatingThermostat Device1 = (HeatingThermostat)House1KVPair.Value;
HeatingThermostat Device2 = (HeatingThermostat)House2Device;
if (Device1.LowBattery != Device2.LowBattery)
{
if (Diff == null)
{
Diff = new HeatingThermostatDiff(Device2.Name, Device2.AssociatedRoom.RoomID, Device2.AssociatedRoom.RoomName);
}
if (Device2.LowBattery)
{
Diff.LowBattery = BatteryStatus.lowbattery;
}
else
{
Diff.LowBattery = BatteryStatus.ok;
}
}
if (Device1.Mode != Device2.Mode)
{
if (Diff == null)
{
Diff = new HeatingThermostatDiff(Device2.Name, Device2.AssociatedRoom.RoomID, Device2.AssociatedRoom.RoomName);
}
Diff.Mode = Device2.Mode;
}
if (Device1.Temperature != Device2.Temperature)
{
if (Diff == null)
{
Diff = new HeatingThermostatDiff(Device2.Name, Device2.AssociatedRoom.RoomID, Device2.AssociatedRoom.RoomName);
}
Diff.Temperature = Device2.Temperature;
}
if (Diff != null)
{
if (Diff.Temperature != 0)
{
Differences.Add(Diff);
}
}
}
else
if (House1KVPair.Value.Type == DeviceTypes.ShutterContact)
{
// ShutterContact
ShutterContactDiff Diff = null;
ShutterContact Device1 = (ShutterContact)House1KVPair.Value;
ShutterContact Device2 = (ShutterContact)House2Device;
if (Device1.LowBattery != Device2.LowBattery)
{
if (Diff == null)
{
Diff = new ShutterContactDiff(Device2.Name, Device2.AssociatedRoom.RoomID, Device2.AssociatedRoom.RoomName);
}
if (Device2.LowBattery)
{
Diff.LowBattery = BatteryStatus.lowbattery;
}
else
{
Diff.LowBattery = BatteryStatus.ok;
}
}
if (Device1.ShutterState != Device2.ShutterState)
{
if (Diff == null)
{
Diff = new ShutterContactDiff(Device2.Name, Device2.AssociatedRoom.RoomID, Device2.AssociatedRoom.RoomName);
}
Diff.ShutterState = Device2.ShutterState;
}
if (Diff != null)
{
Differences.Add(Diff);
}
}
}
}
return(Differences);
}