Example #1
0
		// 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

			}
		}
Example #2
0
		/// <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;
		}
Example #3
0
        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...
        }
Example #4
0
        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);
            }
        }
Example #5
0
        // 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
            }
        }
Example #6
0
        /// <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);
        }