public static async void CheckLightStatuses() { DateTime dateTime = METHOD.DateTimeTZ().DateTime; while (true) { DateTime CurrentDateTime = METHOD.DateTimeTZ().DateTime; bool isLightsTime = IsDarkTime() && !IsSleepTime(); //following is checking if one has pushed the button from the PowerApp, then lights are on for 10 minutes var durationToForceLights = LightsManuallyOnOff ? (CurrentDateTime - dateTime).TotalMinutes : CONSTANT.OUTSIDE_LIGHTS_MANUAL_DURATION; var isLightNotForced = durationToForceLights >= CONSTANT.OUTSIDE_LIGHTS_MANUAL_DURATION; if (isLightNotForced) { LightsManuallyOnOff = false; dateTime = CurrentDateTime; //execute shelly lights only if needed, not in every minute :-) if ((isLightsTime && !TelemetryDataClass.isOutsideLightsOn) || (!isLightsTime && TelemetryDataClass.isOutsideLightsOn)) { TelemetryDataClass.isOutsideLightsOn = await Shelly.SetShellySwitch(isLightsTime, Shelly.OutsideLight, nameof(Shelly.OutsideLight)); } } //it's a good place to check also garage light statuses in every minute if (TelemetryDataClass.isGarageLightsOn) { TelemetryDataClass.isGarageLightsOn = await Shelly.GetShellyState(Shelly.GarageLight); } await Task.Delay(TimeSpan.FromMinutes(1)); //check statuses every 1 minutes } }
public Request(string url) { this.Url = new UriBuilder(url); this.Method = METHOD.GET; this.Body = new Dictionary <string, string>(); this.Headers = new Dictionary <string, string>(); }
async Task SendMacAddressToCosmos(List <WiFiDevice> wiFiDevices) { _sendListData = new SendDataAzure(); double timeOffset = METHOD.DateTimeTZ().Offset.TotalHours; //prepare the list to send into CosmosDB var AllWiFiDevices = new List <Localdevice>(); wiFiDevices.ForEach(x => AllWiFiDevices.Add(new Localdevice() { ActiveDuration = x.ActiveDuration, DeviceName = x.DeviceName, DeviceOwner = x.DeviceOwner, DeviceType = x.DeviceType, MacAddress = x.MacAddress, StatusFrom = METHOD.UnixTimeStampToDateTime(x.StatusUnixTime).AddHours(timeOffset), IsPresent = x.IsPresent, SignalType = x.SignalType, AccessPoint = x.AccessPoint, IsChanged = x.IsChanged })); TelemetryDataClass.SourceInfo = $"WiFi Devices"; //send data to CosmosDB var monitorData = new { DeviceID = "HomeController", status = TelemetryDataClass.SourceInfo, DateAndTime = METHOD.DateTimeTZ().DateTime, AllWiFiDevices }; await _sendListData.PipeMessage(monitorData, Program.IoTHubModuleClient, TelemetryDataClass.SourceInfo, "output"); }
public Request(string url) { this.Url = new UriBuilder(url); this.Method = METHOD.GET; this.Body = new Dictionary<string, string>(); this.Headers = new Dictionary<string, string>(); }
public static bool IsSleepTime() { TimeSpan SleepTimeStart = TimeSpan.Parse(CONSTANT.SLEEP_TIME); TimeSpan SleepTimeEnd = TimeSpan.Parse(CONSTANT.WAKEUP_TIME); bool isSleepTime = METHOD.TimeBetween(METHOD.DateTimeTZ(), SleepTimeStart, SleepTimeEnd); return(isSleepTime); }
private static bool IsDarkTime() { var coordinate = new Coordinate(Lat, Lon, DateTime.Now); var sunset = (DateTime)coordinate.CelestialInfo.SunSet; var sunrise = (DateTime)coordinate.CelestialInfo.SunRise; bool isDarkTime = METHOD.TimeBetween(METHOD.DateTimeTZ().ToUniversalTime(), sunset.TimeOfDay, sunrise.TimeOfDay); return(isDarkTime); }
public void Init(Hashtable hash, hglTags_body hgltags) { try { m_method = (METHOD)System.Enum.Parse(typeof(METHOD), (string)hash["method"]); } catch { } m_hglTags = hgltags; }
private static void Pin_HeatingRisingAsync() //winter and summer { if (!IsWaterHeatPinOn) { dateTimeRoomHeat = METHOD.DateTimeTZ().DateTime; //start roomheat } if (IsWaterHeatPinOn) { dateTimeWaterHeat = METHOD.DateTimeTZ().DateTime; //start waterheat } }
public async void ReduceHeatingSchedulerAsync() { var _receiveData = new ReceiveData(); var _receiveEnergyPrice = new ReceiveEnergyPrice(); List <EnergyPriceClass> _realTimeEnergyPrices = await _receiveEnergyPrice.QueryEnergyPriceAsync(); //run on app startup while (true) { DateTimeOffset CurrentDateTime = METHOD.DateTimeTZ(); if (CurrentDateTime.DateTime.Hour == 00 || !_realTimeEnergyPrices.Any()) //run once every day at 00:00 to get energy prices and heating schedule { _realTimeEnergyPrices = await _receiveEnergyPrice.QueryEnergyPriceAsync(); Console.WriteLine($"Energy price query {CurrentDateTime.DateTime}"); } int HeatingMode = CONSTANT.NORMAL_HEATING; bool isHotWaterTime = true; //get the current state of heating and hot water foreach (var item in _realTimeEnergyPrices) { if (item.date.DateTime.Hour == CurrentDateTime.DateTime.Hour) { HeatingMode = item.heat; isHotWaterTime = item.isHotWaterTime; break; } } //lets control the heating system according to the heating schedule string cmdHeat = null; if (HeatingMode == CONSTANT.NORMAL_HEATING) { cmdHeat = CommandNames.NORMAL_TEMP_COMMAND; } if (HeatingMode == CONSTANT.REDUCED_HEATING) { cmdHeat = CommandNames.REDUCE_TEMP_COMMAND; } if (HeatingMode == CONSTANT.EVU_STOP) { cmdHeat = CommandNames.TURN_OFF_HEATING; } _receiveData.ProcessCommand(cmdHeat); //lets control hot water based on activity time and weekend string cmd = isHotWaterTime ? CommandNames.TURN_ON_HOTWATERPUMP : CommandNames.TURN_OFF_HOTWATERPUMP; _receiveData.ProcessCommand(cmd); int secondsToNextHour = 3600 - (int)CurrentDateTime.DateTime.TimeOfDay.TotalSeconds % 3600; await Task.Delay(TimeSpan.FromSeconds(secondsToNextHour)); } }
List <WiFiDevice> AddRemoveChangeDevices(List <Localdevice> devicesFromPowerApps, List <WiFiDevice> localWiFiDevices) { var tempAddList = new List <WiFiDevice>(); var tempDeleteList = new List <WiFiDevice>(); bool isNewItem = true; //CRUD operations, data is coming from PowerApps foreach (var item in devicesFromPowerApps) { foreach (var device in localWiFiDevices) { if (device.MacAddress == item.MacAddress) { //DELETE item (special type=100) if (item.DeviceType == 100) { tempDeleteList.Add(device); break; } //UPDATE item device.DeviceName = item.DeviceName; device.DeviceOwner = item.DeviceOwner; device.DeviceType = item.DeviceType; device.ActiveDuration = item.ActiveDuration; device.StatusUnixTime = METHOD.DateTimeToUnixTimestamp(item.StatusFrom); device.SignalType = item.SignalType; isNewItem = false; break; } else { isNewItem = true; } } if (isNewItem) { //ADD item tempAddList.Add(new WiFiDevice ( item.MacAddress, item.DeviceName, item.DeviceOwner, item.DeviceType, item.ActiveDuration, METHOD.DateTimeToUnixTimestamp(item.StatusFrom) )); } } localWiFiDevices.AddRange(tempAddList.ToArray()); localWiFiDevices.RemoveAll(i => tempDeleteList.Any(x => x.MacAddress == i.MacAddress)); return(localWiFiDevices); }
protected string GetResponse(string url, METHOD method, Dictionary<string, string> headers, Dictionary<string, string> bodyParams = null) { string responseAsString = ""; HttpWebRequest request = SetHeader(url, method, headers); if (bodyParams != null) { SendBody(request, MakeRequestBody(bodyParams)); // CIIN: asynchronous response. } HttpWebResponse response = (HttpWebResponse)request.GetResponse(); //CIIN: may cause timeout (perhaps) responseAsString = ConvertResponseToString(response); return responseAsString; }
public bool Insert(METHOD obj) { try { DataContext.Instance.METHODS.AddObject(obj); DataContext.Instance.SaveChanges(); return true; } catch { return false; } }
/// <summary> /// The CryptoRandom constructor. /// </summary> /// <param name="method">Specifies the random number generation method (default = CRYPTO1).</param> /// <param name="nSeed">Specifies the seed used to initialize the random number generator, only used when <i>bUseCrypto</i> = <i>false</i> (default = 0, which is ignored).</param> public CryptoRandom(METHOD method = METHOD.DEFAULT, int nSeed = 0) { m_method = method; if (nSeed != 0) { if (m_method == METHOD.CRYPTO) { m_method = METHOD.SYSTEM; } m_rand1 = new Random(nSeed); } }
//below is a bunch of logic which you probaly wont understand later //this piece of code is working based on ground-heating system LED-s events private static async void Pin_WaterRisingAsync() //winter only { var _sendData = new Pins(); if (IsRoomHeatPinOn) //if roomheating LED was on, stop roomheating { TelemetryDataClass.RoomHeatingInMinutes = (int)(METHOD.DateTimeTZ().DateTime - dateTimeRoomHeat).TotalMinutes; TelemetryDataClass.SourceInfo = $"5. Roomheating {TelemetryDataClass.RoomHeatingInMinutes} min, Start Waterheating"; await _sendData.SendData(); TelemetryDataClass.RoomHeatingInMinutes = 0; dateTimeWaterHeat = METHOD.DateTimeTZ().DateTime; //start waterheating } }
public static void SomeoneAtHomeChanged() { ReceiveData _receiveData = new ReceiveData(); DateTimeOffset CurrentDateTime = METHOD.DateTimeTZ(); //if security button is pushed from PowerApps then no automatic security change //if vacation mode is pushed from PowerApps, then security is back in automatic mode //if automatic mode, then secure home if nobody is at home and unsecure if some known mobile is at home if (!IsSecurityManuallyOn) { string cmd = WiFiProbes.IsAnyMobileAtHome ? CommandNames.TURN_OFF_SECURITY : CommandNames.TURN_ON_SECURITY; _receiveData.ProcessCommand(cmd); } TelemetryDataClass.isSomeoneAtHome = IsSomeoneAtHome; Console.WriteLine($"{(IsSecurityManuallyOn ? "Manual security mode." : "Automatic security mode.")} {(IsSomeoneAtHome ? "Someone at home" : "Nobody is home")} {CurrentDateTime.DateTime:G}"); }
public void add(METHOD M,int Number) { count++; ParsTableNode temp =first; if(first == null) { first = new ParsTableNode(M,Number); } else { while(temp.next != null) { temp =temp.next; } temp.next= new ParsTableNode(M,Number); } }
public async Task SendData() { _sendListData = new SendDataAzure(); var monitorData = new { DeviceID = "HomeController", status = TelemetryDataClass.SourceInfo, TelemetryDataClass.RoomHeatingInMinutes, TelemetryDataClass.WaterHeatingInMinutes, TelemetryDataClass.VentilationInMinutes, UtcOffset = METHOD.DateTimeTZ().Offset.Hours, DateAndTime = METHOD.DateTimeTZ(), }; await _sendListData.PipeMessage(monitorData, Program.IoTHubModuleClient, TelemetryDataClass.SourceInfo, "outputStream"); return; }
protected override HttpWebRequest SetHeader(string url, METHOD method, Dictionary<string, string> headers) { HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url); request.ContentType = "application/x-www-form-urlencoded"; request.Accept = "application/json"; request.Method = method.ToString(); request.Timeout = 5000; System.Net.ServicePointManager.Expect100Continue = false; //to prevent from adding ExpectContinue: 100 to Header if (headers != null && headers.Count > 0) { foreach (KeyValuePair<string, string> pair in headers) request.Headers.Add(pair.Key, pair.Value); } return request; }
private string GetTeamLabResponse(string url, EXTENSION ext, METHOD method, Dictionary<string, string> headers, Dictionary<string, string> bodyParams) { try { return GetResponse(url + "." + ext.ToString(), method, headers, bodyParams); } catch (WebException ex) { if (ex.Message == "The remote server returned an error: (401) Unauthorized.") { throw new UnauthorizedException(); } string msgFromServer = null; try { var resp = new StreamReader(ex.Response.GetResponseStream()).ReadToEnd(); dynamic obj = Newtonsoft.Json.JsonConvert.DeserializeObject(resp); msgFromServer = obj.error.message; } catch (NullReferenceException) { throw new ConnectionFailedException(); } switch (msgFromServer) { case "Invalid username or password.": throw new WrongCredentialsException(); case "Could not resolve current tenant :-(.": throw new WrongPortalException(); case "Not found": //Task was not found on the server throw new TaskNotFoundException(); case "Object reference not set to an instance of an object.": throw new ObjectReferenceException(); default: throw ex; } } }
private static async void Pin_WaterFallingAsync() //winter only { IsWaterJustFinished = true; var _sendData = new Pins(); TelemetryDataClass.WaterHeatingInMinutes = (int)(METHOD.DateTimeTZ().DateTime - dateTimeWaterHeat).TotalMinutes; TelemetryDataClass.SourceInfo = $"7. Waterheating {TelemetryDataClass.WaterHeatingInMinutes} min"; await _sendData.SendData(); TelemetryDataClass.WaterHeatingInMinutes = 0; await Task.Delay(TimeSpan.FromSeconds(3)); //wait for a 3 seconds for the roomheat LED, is it turning on or off? IsWaterJustFinished = false; //waterheating just finished and roomheating will continue nonstop if (IsRoomHeatPinOn) { dateTimeRoomHeat = METHOD.DateTimeTZ().DateTime; //start roomheat } }
private DNA <T> ChooseParent(METHOD method) { if (method == METHOD.ABOVEMEDIANONLY || method == METHOD.ABOVEMEDIANSANDBEST) { int index = UnityEngine.Random.Range((int)(Population.Count / 2) - 1, (Population.Count) - 1); return(Population[index]); } if (method == METHOD.ROULETTEWHEEL) { float rouletteSlice = UnityEngine.Random.Range(0f, fitnessSum); int index = 0; // need to decrement because high fitness is "bad" in this implementation float currentTotal = fitnessSum; for (int i = 0; i < Population.Count; i++) { currentTotal -= Population[i].Fitness; if (currentTotal < rouletteSlice) { index = i; break; } } return(Population[index]); } else { double randomNumber = random.NextDouble() * fitnessSum; for (int i = 0; i < Population.Count; i++) { if (randomNumber < Population[i].Fitness) { return(Population[i]); } randomNumber -= Population[i].Fitness; } return(Population[random.Next(0, Population.Count)]); } }
public async Task SendTelemetryAsync() { _sendListData = new SendDataAzure(); var monitorData = new { DeviceID = "HomeController", NetatmoDataClass.Co2, NetatmoDataClass.Humidity, NetatmoDataClass.OutsideHumidity, NetatmoDataClass.Temperature, NetatmoDataClass.TemperatureOut, NetatmoDataClass.Noise, NetatmoDataClass.BatteryPercent, UtcOffset = METHOD.DateTimeTZ().Offset.Hours, DateAndTime = METHOD.DateTimeTZ(), TelemetryDataClass.SourceInfo }; await _sendListData.PipeMessage(monitorData, Program.IoTHubModuleClient, TelemetryDataClass.SourceInfo, "outputStream"); }
public async Task <List <EnergyPriceClass> > QueryEnergyPriceAsync() { Methods = new METHOD(); string fileToday = $"CurrentEnergyPrice{METHOD.DateTimeTZ():dd-MM-yyyy}"; string fileYesterday = $"CurrentEnergyPrice{METHOD.DateTimeTZ().AddDays(-1):dd-MM-yyyy}"; fileToday = Methods.GetFilePath(fileToday); //delete yesterday file, we dont need to collect them fileYesterday = Methods.GetFilePath(fileYesterday); if (File.Exists(fileYesterday)) { File.Delete(fileYesterday); } if (File.Exists(fileToday)) //is there already file with today energy prices { var dataFromFile = await Methods.OpenExistingFile(fileToday); energyPriceToday = JsonSerializer.Deserialize <List <EnergyPriceClass> >(dataFromFile.ToString()); } if (!File.Exists(fileToday)) //file with today energy price is missing { try { string MarketPriceToday = METHOD.DateTimeTZ().ToString("dd.MM.yyyy"); energyPriceToday = await GetMarketPrice(MarketPriceToday); var jsonString = JsonSerializer.Serialize(energyPriceToday); await Methods.SaveStringToLocalFile(fileToday, jsonString); } catch (Exception e) { Console.WriteLine("Receive energy price from Cosmos exception: " + e.Message); } } return(energyPriceToday); }
private static async void Pin_HeatingFallingAsync() //winter and summer { var _sendData = new Pins(); if (!IsWaterJustFinished && !IsWaterHeatPinOn) //if waterheating LED is off AND the waterheating counter isnt started then stop roomheating { TelemetryDataClass.RoomHeatingInMinutes = (int)(METHOD.DateTimeTZ().DateTime - dateTimeRoomHeat).TotalMinutes; TelemetryDataClass.SourceInfo = $"3. Roomheating {TelemetryDataClass.RoomHeatingInMinutes} min"; await _sendData.SendData(); TelemetryDataClass.RoomHeatingInMinutes = 0; } await Task.Delay(TimeSpan.FromSeconds(3)); //wait for a 3 seconds, maybe the waterheating just finished and it is already off? if (IsWaterHeatPinOn) //heating system in WATERHEATING mode, waterheating LED always on, this is for summer time { TelemetryDataClass.WaterHeatingInMinutes = (int)(METHOD.DateTimeTZ().DateTime - dateTimeWaterHeat).TotalMinutes; TelemetryDataClass.SourceInfo = $"4. Waterheating {TelemetryDataClass.WaterHeatingInMinutes} min"; await _sendData.SendData(); TelemetryDataClass.WaterHeatingInMinutes = 0; } }
/// <summary> /// 构造函数 /// </summary> /// <param name="AMethod">解析方法类型</param> /// <param name="AstrTag">报文标记</param> public DatagramResolver(METHOD AMethod, string AstrTag) { if (startTag == null) { throw (new ArgumentNullException("报文标记不能为null")); } if (startTag == "") { throw (new ArgumentException("报文标记不能为空字符串")); } switch (AMethod) { case METHOD.START_TAG: this.startTag = AstrTag; break; case METHOD.END_TAG: this.endTag = AstrTag; break; default: break; } }
public async void CheckHeatingTime() { while (true) { if (TelemetryDataClass.SaunaStartedTime == DateTime.MinValue) { var filename = Methods.GetFilePath(CONSTANT.FILENAME_SAUNA_TIME); if (File.Exists(filename)) //this mean that sauna has been started and system has suddenly restarted/updated { var result = await Methods.OpenExistingFile(filename); if (DateTime.TryParseExact(result, "dd.MM.yyyy HH:mm", CultureInfo.InvariantCulture, DateTimeStyles.None, out var SaunaStartedTime)) { TelemetryDataClass.SaunaStartedTime = SaunaStartedTime; } } } if (TelemetryDataClass.SaunaStartedTime != DateTime.MinValue) { int TotalTimeSaunaHeatedInMinutes = (int)(METHOD.DateTimeTZ().DateTime - TelemetryDataClass.SaunaStartedTime).TotalMinutes; string cmd = CommandNames.NO_COMMAND; //turn saun on if it has heating time but not turned on if (TotalTimeSaunaHeatedInMinutes < CONSTANT.MAX_SAUNA_HEATING_TIME && !TelemetryDataClass.isSaunaOn) { cmd = CommandNames.TURN_ON_SAUNA; } //turn sauna off if the time is over if (TotalTimeSaunaHeatedInMinutes > CONSTANT.MAX_SAUNA_HEATING_TIME) { cmd = CommandNames.TURN_OFF_SAUNA; } _receiveData.ProcessCommand(cmd); } await Task.Delay(TimeSpan.FromMinutes(1)); //check every minute } }
/// <summary> /// This method sets header of HTTP request and returns HttpWebRequest /// </summary> /// <param name="url">Full (host + resource) URL address</param> /// <param name="method">REST method</param> /// <param name="headers">Additional HTTP headers</param> /// <returns>HttpWebRequest</returns> protected abstract HttpWebRequest SetHeader(string url, METHOD method, Dictionary<string, string> headers);
private bool DeleteMethod(METHOD method) { try { DeleteRequire(method.ID); DeleteEnsure(method.ID); DataContext.Instance.METHODS.DeleteObject(method); return true; } catch { return false; } }
public METHODAttribute(METHOD method) { Method = method; }
public async void ProcessCommand(string command) { if (command == CommandNames.NO_COMMAND) { //_startStopLogic.testing(Pins.redLedPin); } else if (command == CommandNames.TURN_ON_SAUNA && !Pins.IsSaunaDoorOpen) { Pins.PinWrite(Pins.saunaHeatOutPin, PinValue.Low); TelemetryDataClass.isSaunaOn = true; var filename = Methods.GetFilePath(CONSTANT.FILENAME_SAUNA_TIME); if (TelemetryDataClass.SaunaStartedTime == DateTime.MinValue) //if sauna hasnt been started before { DateTime SaunaStartedTime = METHOD.DateTimeTZ().DateTime; await Methods.SaveStringToLocalFile(filename, SaunaStartedTime.ToString("dd.MM.yyyy HH:mm")); TelemetryDataClass.SaunaStartedTime = SaunaStartedTime; } } else if (command == CommandNames.TURN_OFF_SAUNA) { var filename = Methods.GetFilePath(CONSTANT.FILENAME_SAUNA_TIME); File.Delete(filename); Pins.PinWrite(Pins.saunaHeatOutPin, PinValue.High); TelemetryDataClass.isSaunaOn = false; TelemetryDataClass.SaunaStartedTime = new DateTime(); } else if (command == CommandNames.TURN_ON_VACATION) { TelemetryDataClass.isHomeInVacation = true; TelemetryDataClass.VacationTime = METHOD.DateTimeTZ().DateTime; ProcessCommand(CommandNames.TURN_OFF_HEATING); ProcessCommand(CommandNames.TURN_OFF_SAUNA); ProcessCommand(CommandNames.CLOSE_VENT); Console.WriteLine($"{(SomeoneAtHome.IsSecurityManuallyOn ? "Manual security mode." : "Automatic security mode.")} Vacation mode on at {TelemetryDataClass.VacationTime:G}"); } else if (command == CommandNames.TURN_OFF_VACATION) { TelemetryDataClass.isHomeInVacation = false; TelemetryDataClass.VacationTime = new DateTime(); Console.WriteLine($"{(SomeoneAtHome.IsSecurityManuallyOn ? "Manual security mode." : "Automatic security mode.")} Vacation mode off at {METHOD.DateTimeTZ().DateTime:G}"); } else if (command == CommandNames.TURN_ON_SECURITY) { TelemetryDataClass.isHomeSecured = true; TelemetryDataClass.HomeSecuredTime = METHOD.DateTimeTZ().DateTime; Console.WriteLine($"{(SomeoneAtHome.IsSecurityManuallyOn ? "Manual security mode." : "Automatic security mode.")} Home is secured at: {TelemetryDataClass.HomeSecuredTime:G}"); } else if (command == CommandNames.TURN_OFF_SECURITY) { TelemetryDataClass.isHomeSecured = false; TelemetryDataClass.HomeSecuredTime = new DateTime(); Console.WriteLine($"{(SomeoneAtHome.IsSecurityManuallyOn ? "Manual security mode." : "Automatic security mode.")} Home is at normal state at: {METHOD.DateTimeTZ().DateTime:G}"); } else if (command == CommandNames.OPEN_VENT) { Pins.PinWrite(Pins.ventOutPin, PinValue.High); ManualVentLogic.VENT_ON = true; //to enable 30min ventilation, same behavior as Co2 over 900 TelemetryDataClass.isVentilationOn = true; dateTimeVentilation = METHOD.DateTimeTZ().DateTime; } else if (command == CommandNames.CLOSE_VENT) { Pins.PinWrite(Pins.ventOutPin, PinValue.Low); ManualVentLogic.VENT_ON = false; TelemetryDataClass.VentilationInMinutes = (int)(METHOD.DateTimeTZ().DateTime - dateTimeVentilation).TotalMinutes; TelemetryDataClass.SourceInfo = "Ventilation turned off"; var _sendData = new Pins(); await _sendData.SendData(); TelemetryDataClass.VentilationInMinutes = 0; TelemetryDataClass.isVentilationOn = false; } else if (command == CommandNames.NORMAL_TEMP_COMMAND) { if (!TelemetryDataClass.isHomeInVacation) { ProcessCommand(CommandNames.TURN_ON_HEATING); Pins.PinWrite(Pins.normalTempOutPin, PinValue.High); Pins.PinWrite(Pins.floorPumpOutPin, PinValue.High); TelemetryDataClass.isNormalHeating = true; } else { ProcessCommand(CommandNames.REDUCE_TEMP_COMMAND); ProcessCommand(CommandNames.TURN_ON_HEATING); } } else if (command == CommandNames.REDUCE_TEMP_COMMAND) { while (Pins.IsRoomHeatingOn || Pins.IsWaterHeatingOn) { ; } Pins.PinWrite(Pins.normalTempOutPin, PinValue.Low); Pins.PinWrite(Pins.floorPumpOutPin, PinValue.Low); TelemetryDataClass.isNormalHeating = false; } else if (command == CommandNames.TURN_ON_HOTWATERPUMP && !TelemetryDataClass.isHomeInVacation) { Pins.PinWrite(Pins.waterOutPin, PinValue.High); ProcessCommand(CommandNames.TURN_ON_HEATING); TelemetryDataClass.isWaterHeatingOn = true; } else if (command == CommandNames.TURN_OFF_HOTWATERPUMP) { Pins.PinWrite(Pins.waterOutPin, PinValue.Low); TelemetryDataClass.isWaterHeatingOn = false; } else if (command == CommandNames.TURN_ON_HEATING && !TelemetryDataClass.isHomeInVacation) { Pins.PinWrite(Pins.heatOnOutPin, PinValue.High); TelemetryDataClass.isHeatingOn = true; } else if (command == CommandNames.TURN_OFF_HEATING) { while (Pins.IsRoomHeatingOn || Pins.IsWaterHeatingOn) { ; } Pins.PinWrite(Pins.heatOnOutPin, PinValue.Low); Pins.PinWrite(Pins.floorPumpOutPin, PinValue.Low); ProcessCommand(CommandNames.REDUCE_TEMP_COMMAND); ProcessCommand(CommandNames.TURN_OFF_HOTWATERPUMP); TelemetryDataClass.isHeatingOn = false; } }
public string GetXMLResponse(string url, METHOD method, Dictionary<string, string> bodyParams) { return GetTeamLabResponse(url, EXTENSION.xml, method, null, bodyParams); }
// This constructor will set the method to GET by default, and initalize // the URI to an empty string. public Client() { URI = ""; HttpMethod = METHOD.GET; }
public ParsTableNode(METHOD M,int Number) { this.item.method = M; this.item.number = Number; next = null; }
private void KrigingInThread() { int nRC, nI; double dRC, dC0, dC1, dSill, dDistance, dXmin, dXmax, dYmin, dYmax, dXStep, dYStep, dX, dY; InitNodeTypeArray(); try { // Set Block Kriging (0 - classic Kriging) nI = 1; Kriging.KrigingSetBlockKriging(nI); // Set data points nRC = Kriging.KrigingSetData(GlnCount, Marshal.UnsafeAddrOfPinnedArrayElement(GlardX, 0), Marshal.UnsafeAddrOfPinnedArrayElement(GlardY, 0), Marshal.UnsafeAddrOfPinnedArrayElement(GlardZ, 0)); if (nRC == KRIGING_RC_ERROR || nRC == KRIGING_RC_NO_MEMORY) { System.Windows.Forms.MessageBox.Show("Object Kriging can't set data"); return; } // Calculate maximum distance between points CalculateMaxDistance(out dDistance); // Set range ( The distance which cause the variogram reach plateau is called range) dRC = Kriging.KrigingSetRange(dDistance); // Debug.Print "Old value of range was " & Trim(Str(dRC)) dRC = Kriging.KrigingGetRange(); //Debug.Print "Current value of range is " & Trim(Str(dRC)) // Get default variogram model nRC = Kriging.KrigingGetModel(); //Debug.Print "Default model is " & Trim(Str(nRC)) // Set variogram model nRC = Kriging.KrigingSetModel(nRC); // Get default sill dSill = Kriging.KrigingGetSill(out dC0, out dC1); // The default values: dC0 = 1., dC1 = 2., dSill = 3. //Debug.Print "Default sill is " & Trim(Str(dSill)) // Set sill (dSill = dC0 + dC1) dSill = Kriging.KrigingSetSill(dC0, dC1); // Calculate the minimum and maximum points coordinates CalculateMinMaxPointsCoordinates(out dXmin, out dYmin, out dXmax, out dYmax); // Calculate the steps of grid for (int row = 0; row < GlnRowCount; row++) { for (int col = 0; col < GlnColumnCount; col++) { Coordinate cor = this.GetXYCell(_rasterGrid, col, row); _rasterGrid.Value[row, col] = 0; GldColumnCoord[col] = cor.X; GldRowCoord[row] = cor.Y; } } /* dXStep = (dXmax - dXmin) / (GlnColumnCount - 1); dYStep = (dYmax - dYmin) / (GlnRowCount - 1); // Calculate the coordinates of grid dX = dXmin; for (nI = 1; nI <= GlnColumnCount; nI++) { GldColumnCoord[nI - 1] = dX; dX = dX + dXStep; } dY = dYmin; for (nI = 1; nI <= GlnRowCount; nI++) { GldRowCoord[nI - 1] = dY; dY = dY + dYStep; } */ nRC = Kriging.KrigingSetGridCoordinate(GlnColumnCount, Marshal.UnsafeAddrOfPinnedArrayElement(GldColumnCoord, 0), GlnRowCount, Marshal.UnsafeAddrOfPinnedArrayElement(GldRowCoord, 0)); GlnMaxProgress = Kriging.KrigingGetMaxProgressBar() / 100; progressBar1.Maximum = GlnMaxProgress; nRC = Kriging.KrigingCalculateInThread(); timer1.Enabled = true; timer1.Interval = 50; // Set Timer interval. progressBar1.Minimum = 0; progressBar1.Value = progressBar1.Minimum; progressBar1.Visible = false; GlnMethod = METHOD.KRIGING; return; } catch { System.Windows.Forms.MessageBox.Show("Function KrigingSetData is missing"); return; } }
public static uint CTL_CODE(DEVICE_TYPE deviceType, ushort function, METHOD method, FILE_ACCESS access) { return (uint) ((((((uint) deviceType) << 0x10) | (((byte) access) << 14)) | (function << 2)) | ((long) method)); }
public async void ReadTemperature() { var _receiveData = new ReceiveData(); var _sensorsClient = new RinsenOneWireClient(); var _sendListData = new SendDataAzure(); var Methods = new METHOD(); //currentSumOfTempDeltas is some bigger number than the delta (0,5) is used to determine temperature changes double SumOfTemperatureDeltas = 10; //initiate the list with the temps and names ListOfAllSensors = await _sensorsClient.ReadSensors(); //fill out LastTemperatures and initial Temperature trend which is initially always TRUE ListOfAllSensors = UpdateSensorsTrendAndLastTemp(ListOfAllSensors, ListOfAllSensors); var filename = Methods.GetFilePath(CONSTANT.FILENAME_ROOM_TEMPERATURES); if (File.Exists(filename)) { var dataFromFile = await Methods.OpenExistingFile(filename); List <SensorReading> SetRoomTemps = JsonSerializer.Deserialize <List <SensorReading> >(dataFromFile); SetTemperatures(SetRoomTemps); } while (true) { //get a new sensor readings and then update SensorReadings sensorReadings = await _sensorsClient.ReadSensors(); ListOfAllSensors = UpdateSensorsTrendAndLastTemp(ListOfAllSensors, sensorReadings); //summing all the room temperature changes together add new deltas until it bigger that 4 degrees SumOfTemperatureDeltas += ListOfAllSensors.Temperatures.Where(x => x.isRoom).Sum(x => Math.Abs(x.Temperature - x.LastTemperature)); //manage Livingroom heating actuator if (ListOfAllSensors.Temperatures.FirstOrDefault(x => x.RoomName == LIVING).isHeatingRequired) { Pins.PinWrite(Pins.livingRoomHeatControlOut, PinValue.High); } else { Pins.PinWrite(Pins.livingRoomHeatControlOut, PinValue.Low); } //manage Office heating actuator if (ListOfAllSensors.Temperatures.FirstOrDefault(x => x.RoomName == OFFICE).isHeatingRequired) { Pins.PinWrite(Pins.homeOfficeHeatControlOut, PinValue.High); } else { Pins.PinWrite(Pins.homeOfficeHeatControlOut, PinValue.Low); } //manage Piano heating actuator bool isPianoHeatingOn = ListOfAllSensors.Temperatures.FirstOrDefault(x => x.RoomName == PIANO).isHeatingRequired; await Shelly.SetShellySwitch(isPianoHeatingOn, Shelly.PianoHeating, nameof(Shelly.PianoHeating)); //manage Bedroom heating actuator bool isBedroomHeatingOn = ListOfAllSensors.Temperatures.FirstOrDefault(x => x.RoomName == BEDROOM).isHeatingRequired; await Shelly.SetShellySwitch(isBedroomHeatingOn, Shelly.BedroomHeating, nameof(Shelly.BedroomHeating)); //manage sauna temperature if (ListOfAllSensors.Temperatures.FirstOrDefault(x => x.RoomName == SAUNA).isHeatingRequired&& TelemetryDataClass.isSaunaOn) { Pins.PinWrite(Pins.saunaHeatOutPin, PinValue.Low); } else { Pins.PinWrite(Pins.saunaHeatOutPin, PinValue.High); } //if sauna extremely hot, then turn off if (ListOfAllSensors.Temperatures.FirstOrDefault(x => x.RoomName == SAUNA).Temperature > CONSTANT.EXTREME_SAUNA_TEMP) { _receiveData.ProcessCommand(CommandNames.TURN_OFF_SAUNA); } //if all rooms has achieved their target temperature then turn system off if (ListOfAllSensors.Temperatures.Where(x => x.isRoom).All(x => !x.isHeatingRequired)) { _receiveData.ProcessCommand(CommandNames.REDUCE_TEMP_COMMAND); } //if all room temperatures together has changed more that 3 degrees then send it out to database if (Math.Abs(SumOfTemperatureDeltas) > 4) { TelemetryDataClass.SourceInfo = $"Room temp changed {SumOfTemperatureDeltas:0.0}"; var monitorData = new { DeviceID = "RoomTemperatures", UtcOffset = METHOD.DateTimeTZ().Offset.Hours, DateAndTime = METHOD.DateTimeTZ().DateTime, time = METHOD.DateTimeTZ().ToString("HH:mm"), TelemetryDataClass.SourceInfo, ListOfAllSensors.Temperatures }; await _sendListData.PipeMessage(monitorData, Program.IoTHubModuleClient, TelemetryDataClass.SourceInfo, "output"); SumOfTemperatureDeltas = 0; //resetting to start summing up again } await Task.Delay(TimeSpan.FromMinutes(1)); //check temperatures every minute } }
public async Task <MessageResponse> PipeMessage(object inputdata, ModuleClient userContext, string SourceInfo, string output) { int counterValue = Interlocked.Increment(ref counter); if (!(userContext is ModuleClient moduleClient)) { throw new InvalidOperationException("UserContext doesn't contain " + "expected values"); } var messageJson = JsonSerializer.Serialize(inputdata); var message = new Message(Encoding.ASCII.GetBytes(messageJson)); byte[] messageBytes = message.GetBytes(); string messageString = Encoding.UTF8.GetString(messageBytes); if (!string.IsNullOrEmpty(messageString)) { //the following piece of code is necessary only if using Twin Desired/Reported properties //this desired/reported properties are not used at the moment in my code var pipeMessage = new Message(messageBytes); foreach (var prop in message.Properties) { pipeMessage.Properties.Add(prop.Key, prop.Value); } await moduleClient.SendEventAsync(output, pipeMessage); Console.WriteLine($"Azure IoT Hub message: {counterValue}. {SourceInfo}: {METHOD.DateTimeTZ().DateTime}"); } return(MessageResponse.Completed); }
private Uri ProcessURI(METHOD m, string path, Dictionary<string, string> args) { // Process the URI StringBuilder URI = new StringBuilder(); URI.Append(this.url); URI.Append(path); if (this.alwaysUseJson & (m == METHOD.GET || m == METHOD.PUT)) { if (args != null && !args.ContainsKey("format")) { args.Add("format", "json"); } } if (args != null && args.Count > 0) { URI.Append("?"); List<string> argList = new List<string>(); foreach (string k in args.Keys) { argList.Add(k + "=" + HttpUtility.UrlEncode(args[k])); } URI.Append(string.Join("&", argList.ToArray())); } return new Uri(URI.ToString()); }
public string GetAuthorizedXMLResponse(string url, METHOD method, Dictionary<string, string> bodyParams, string authorizationToken) { return GetTeamLabResponse(url, EXTENSION.xml, method, GetAuthorizationHeaders(authorizationToken), bodyParams); }
/// <summary> /// Makes a call to FluidDB using JSON payload /// </summary> /// <param name="method">The type of HTTP method</param> /// <param name="path">The path to call</param> /// <param name="body">The body of the request</param> /// <param name="args">Any further arguments to append to the URI</param> /// <returns>The raw result</returns> public HttpWebResponse Call(METHOD m, string path, Dictionary<string, string> args, Dictionary<string, object> body) { // Build the request Uri requestUri = ProcessURI(m, path, args); WebRequest request = WebRequest.Create(requestUri); request.Method = m.ToString(); // Make sure the headers are correct ((HttpWebRequest)request).UserAgent = ".NET FluidDB Client"; ((HttpWebRequest)request).Accept = "application/json"; if (!(this.password == string.Empty & this.username == string.Empty)) { string userpass = username + ":" + password; byte[] encUserPass = Encoding.UTF8.GetBytes(userpass); string auth = "Basic " + Convert.ToBase64String(encUserPass).Trim(); ((HttpWebRequest)request).Headers.Add(HttpRequestHeader.Authorization, auth); } if (body == null || body.Count == 0) { request.ContentType = "text/plain"; } else { Byte[] byteArray = Encoding.ASCII.GetBytes(this.jss.Serialize(body)); request.ContentType = "application/json"; request.ContentLength = byteArray.Length; Stream bodyStream = request.GetRequestStream(); bodyStream.Write(byteArray, 0, byteArray.Length); bodyStream.Close(); } // Call FluidDB try { return (HttpWebResponse)request.GetResponse(); } catch (WebException e) { // I don't want you to raise an exception dammit... I just want the raw // response and I'll process the errorClass from the content and maybe // raise an exception if appropriate elsewhere return (HttpWebResponse)e.Response; } }
public static async Task <bool> SetShellySwitch(bool turnOn, string ipAddress, string shellyName) { string TurnOnCommand = turnOn ? "on" : "off"; bool ison = false; try { var http = new HttpClient(); string url = $"http://{ipAddress}/relay/0?turn={TurnOnCommand}"; HttpResponseMessage response = await http.GetAsync(url); var result = response.Content.ReadAsStringAsync(); //deserialize all content var nps = JsonSerializer.Deserialize <JsonElement>(result.Result); ison = nps.GetProperty("ison").GetBoolean(); if (shellyName == "OutsideLight" || shellyName == "GarageLight") { Console.WriteLine($"Shelly {shellyName} {(turnOn ? "turned on" : "turned off")} {METHOD.DateTimeTZ().DateTime:T}"); } } catch (Exception e) { Console.WriteLine($"Send command to Shelly exception {shellyName} {turnOn}: {e.Message}"); } return(ison); }
public async void QueryWiFiProbes() { http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.ASCII.GetBytes($"{username}:{password}"))); var filename = Methods.GetFilePath(CONSTANT.FILENAME_HOME_DEVICES); try { //open file and -> list of devices from Raspberry if the file exists if (File.Exists(filename)) { var result = await Methods.OpenExistingFile(filename); WiFiDevice.WellKnownDevices = JsonSerializer.Deserialize <List <WiFiDevice> >(result).ToList(); } else { double unixTimestamp = DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds; //following will happen only if there is no file on Raspberry and the list will be loaded from the environment variables WiFiDevice.WellKnownDevices.ForEach(x => x.StatusUnixTime = unixTimestamp); } } catch (Exception e) { Console.WriteLine($"open file {e}"); } await SendMacAddressToCosmos(WiFiDevice.WellKnownDevices); bool isAnyDeviceChanged = true; var UnknownDevices = new List <WiFiDevice>(); while (true) { double unixTimestamp = METHOD.DateTimeToUnixTimestamp(DateTime.UtcNow); double timeOffset = METHOD.DateTimeTZ().Offset.TotalHours; //if there are some items from PowerApps then proceed if (WiFiDevicesFromPowerApps.Any()) { //Add, Remove or Change WiFiDevices list according to WiFiDevices From PowerApps WiFiDevice.WellKnownDevices = AddRemoveChangeDevices(WiFiDevicesFromPowerApps, WiFiDevice.WellKnownDevices); WiFiDevicesFromPowerApps.Clear(); //send all devices to CosmosDB await SendMacAddressToCosmos(WiFiDevice.WellKnownDevices); } //prepare multimac query //create a list of the MAC Addresses for multimac query List <string> deviceMacs = new List <string>(); WiFiDevice.WellKnownDevices.ForEach(x => deviceMacs.Add(x.MacAddress)); string jsonMacAddresses = JsonSerializer.Serialize(deviceMacs); string urlMultiMac = $"{urlKismet}/devices/multimac/devices.json"; string jsonContentFieldsMac = "json={\"fields\":" + jsonFields + ",\"devices\":" + jsonMacAddresses + "}"; List <WiFiDevice> KismetKnownDevices = await GetDevices(urlMultiMac, jsonContentFieldsMac); //clear devices list. WiFiDevicesToPowerApps.Clear(); //building list of the local devices which are last seen foreach (var knownDevice in WiFiDevice.WellKnownDevices) { foreach (var kismet in KismetKnownDevices) { if (knownDevice.MacAddress == kismet.MacAddress) { knownDevice.LastUnixTime = kismet.LastUnixTime; knownDevice.LastSignal = kismet.LastSignal; knownDevice.SignalType = kismet.SignalType; knownDevice.SSID = kismet.SSID; knownDevice.WiFiName = kismet.ProbedSSID; if (kismet.SignalType.Contains("Wi-Fi")) { knownDevice.AccessPoint = WiFiDevice.WellKnownDevices.Where(x => x.MacAddress == kismet.LastBSSID).Select(x => x.DeviceName).DefaultIfEmpty("No AP").First(); if (string.IsNullOrEmpty(knownDevice.WiFiName) || knownDevice.WiFiName == "0") { knownDevice.WiFiName = WiFiDevice.WellKnownDevices.Where(x => x.MacAddress == kismet.LastBSSID).Select(x => x.SSID).DefaultIfEmpty("No AP").First(); } } break; } } //checking active devices and setting Active/NonActive statuses. Each device can have individual timewindow knownDevice.IsChanged = false; //this is just for debugging, no other reason var durationUntilNotActive = (unixTimestamp - knownDevice.LastUnixTime) / 60; //timestamp in minutes knownDevice.IsPresent = durationUntilNotActive < knownDevice.ActiveDuration; if (knownDevice.IsPresent && !knownDevice.StatusChange) { knownDevice.StatusUnixTime = unixTimestamp; knownDevice.StatusChange = true; isAnyDeviceChanged = true; knownDevice.IsChanged = true; } if (!knownDevice.IsPresent && knownDevice.StatusChange) { knownDevice.StatusUnixTime = knownDevice.LastUnixTime; knownDevice.StatusChange = false; isAnyDeviceChanged = true; knownDevice.IsChanged = true; } //following list WiFiDevicesToPowerApps is used to send minimal data to PowerApps (sending only userdevices) //this list will be sent as a response after PowerApps asks something or refreshing it's data if (knownDevice.DeviceType != WiFiDevice.DEVICE) { WiFiDevicesToPowerApps.Add(new Localdevice() { DeviceOwner = knownDevice.DeviceOwner, DeviceName = knownDevice.DeviceName, DeviceType = knownDevice.DeviceType, IsPresent = knownDevice.IsPresent, StatusFrom = METHOD.UnixTimeStampToDateTime(knownDevice.StatusUnixTime), ActiveDuration = knownDevice.ActiveDuration, MacAddress = knownDevice.MacAddress, SignalType = knownDevice.SignalType, IsChanged = knownDevice.IsChanged }); } //build a list with the names who is expected to track //this list will be sent through Azure Functions to the owners e-mail if (knownDevice.DeviceType == WiFiDevice.MOBILE || knownDevice.DeviceType == WiFiDevice.WATCH || knownDevice.DeviceType == WiFiDevice.CAR) { //to be sure that every person is listed just once if (!WiFiDevicesWhoIsChanged.Any(x => x.DeviceOwner == knownDevice.DeviceOwner) || !WiFiDevicesWhoIsChanged.Any()) { WiFiDevicesWhoIsChanged.Add(new Localdevice() { DeviceOwner = knownDevice.DeviceOwner, DeviceName = knownDevice.DeviceName, IsPresent = knownDevice.IsPresent, StatusFrom = METHOD.UnixTimeStampToDateTime(knownDevice.StatusUnixTime), SignalType = knownDevice.SignalType, IsChanged = knownDevice.IsChanged }); } } } //update the list of the correct statuses, are they home or away foreach (var item in WiFiDevicesWhoIsChanged) { item.IsChanged = false; foreach (var device in WiFiDevicesToPowerApps) { if (item.DeviceOwner == device.DeviceOwner && (device.DeviceType == WiFiDevice.MOBILE || device.DeviceType == WiFiDevice.WATCH || device.DeviceType == WiFiDevice.CAR)) { if (device.IsChanged) { item.IsChanged = device.IsChanged; item.DeviceName = device.DeviceName; item.StatusFrom = device.StatusFrom.AddHours(timeOffset); item.SignalType = device.SignalType; item.IsPresent = device.IsPresent; } //if device is exist and has'nt been changed, then mark it as unchanged and move to next item //if device is not exist (not seen) but has been changed then mark it as unchanged and move to next item = do not notify leaving devices //this is XOR if (device.IsPresent ^ device.IsChanged) { item.IsChanged = false; break; } } } } //save the data locally into Raspberry var jsonString = JsonSerializer.Serialize(WiFiDevice.WellKnownDevices); await Methods.SaveStringToLocalFile(filename, jsonString); //send an e-mail only if someone has arrived at home or left the home if (WiFiDevicesWhoIsChanged.Any(x => x.IsChanged)) { string status = "Look who is at home:\n\n"; WiFiDevicesWhoIsChanged.ForEach(x => status += $"{(x.IsPresent ? x.DeviceOwner + " " + x.DeviceName + " at home from" : x.DeviceOwner + " not seen since")} {x.StatusFrom:HH:mm dd.MM.yyyy} \n "); var x = WiFiDevicesWhoIsChanged.First(x => x.IsChanged); string whoChanged = $"{(x.IsPresent ? x.DeviceOwner + " at home " : x.DeviceOwner + " not seen since")} {x.StatusFrom:HH:mm dd.MM.yyyy}"; _sendListData = new SendDataAzure(); TelemetryDataClass.SourceInfo = $"{whoChanged}"; //send data to CosmosDB var monitorData = new { DeviceID = "HomeController", TelemetryDataClass.SourceInfo, status, DateAndTime = METHOD.DateTimeTZ().DateTime, isHomeSecured = true }; await _sendListData.PipeMessage(monitorData, Program.IoTHubModuleClient, TelemetryDataClass.SourceInfo, "output"); } //if any mobile phone or watch is present then someone is at home IsAnyMobileAtHome = WiFiDevice.WellKnownDevices.Any(x => x.IsPresent && (x.DeviceType == WiFiDevice.MOBILE || x.DeviceType == WiFiDevice.WATCH || x.DeviceType == WiFiDevice.CAR)); //if security mode automatic and home secured then unsecure home if any known mobile device is seen if (IsAnyMobileAtHome && TelemetryDataClass.isHomeSecured && !SomeoneAtHome.IsSecurityManuallyOn) { SomeoneAtHome.SomeoneAtHomeChanged(); } #region Known Device Listing, only for debugging //for local debugging only show the active/non active devices in console window if (isAnyDeviceChanged) { isAnyDeviceChanged = false; var sortedList = WiFiDevice.WellKnownDevices.OrderByDescending(y => y.IsPresent).ThenBy(w => w.AccessPoint).ThenBy(z => z.SignalType).ThenBy(x => x.DeviceName).ToList(); Console.WriteLine(); Console.WriteLine($"All known devices at: {METHOD.DateTimeTZ().DateTime:G}"); Console.WriteLine(); Console.WriteLine($" | From | Status | Device | WiFi network | AccessPoint | SignalType"); Console.WriteLine($" | ------ | ------- | -------- | ----- | ----- | -------- "); foreach (var device in sortedList) { if (device.LastUnixTime > 0 && device.SignalType != "Wi-Fi AP" && device.DeviceOwner != "Unknown" && device.DeviceType != WiFiDevice.DEVICE) //show only my own ever seen LocalUserDevices devices { Console.WriteLine($" {(device.IsChanged ? "1" : " ")} " + $"| {METHOD.UnixTimeStampToDateTime(device.StatusUnixTime).AddHours(timeOffset):T} " + $"| {(device.IsPresent ? "Active " : "Not Act")} " + $"| {device.DeviceName}{"".PadRight(26 - (device.DeviceName.Length > 26 ? 26 : device.DeviceName.Length))}" + $"| {device.WiFiName}{"".PadRight(26 - (!string.IsNullOrEmpty(device.WiFiName) ? (device.WiFiName.Length > 26 ? 26 : device.WiFiName.Length) : 0))}" + $"| {device.AccessPoint}{"".PadRight(26 - (!string.IsNullOrEmpty(device.AccessPoint) ? (device.AccessPoint.Length > 26 ? 26 : device.AccessPoint.Length) : 0))}" + $"| {device.SignalType} "); } } Console.WriteLine(); } #endregion #region Unknown Devices Debugging //prepare last active devices query string urlLastActive = $"{urlKismet}/devices/last-time/{CONSTANT.ACTIVE_DEVICES_IN_LAST}/devices.json"; string jsonContentFields = "json={\"fields\":" + jsonFields + "}"; List <WiFiDevice> KismetActiveDevices = await GetDevices(urlLastActive, jsonContentFields); //removing all known devices from the last seen devices list //known devices are all locally registered devices in the list WiFiDevice.WifiDevices var tempDelList = new List <WiFiDevice>(); var AllActiveDevices = new List <WiFiDevice>(KismetActiveDevices); foreach (var kismet in KismetActiveDevices) { foreach (var knownDevice in WiFiDevice.WellKnownDevices) { if (kismet.MacAddress == knownDevice.MacAddress || kismet.LastSignal < CONSTANT.SIGNAL_TRESHOLD || (kismet.CommonName == kismet.MacAddress && kismet.Manufacture == "Unknown")) { tempDelList.Add(kismet); break; } } } KismetActiveDevices.RemoveAll(i => tempDelList.Contains(i)); //adding new members to the close devices list if (KismetActiveDevices.Any()) { var tempAddList = new List <WiFiDevice>(); bool isNewItem = true; foreach (var kismet in KismetActiveDevices) { foreach (var unknownDevice in UnknownDevices) { if (kismet.MacAddress == unknownDevice.MacAddress) { unknownDevice.Count++; unknownDevice.LastUnixTime = kismet.LastUnixTime; unknownDevice.WiFiName = kismet.ProbedSSID; if (kismet.SignalType.Contains("Wi-Fi")) { //get device AccessPoint and WIFI network names from Kismet (if reported by device) List <WiFiDevice> KismetOneMac = new List <WiFiDevice>(); string urlOneMac = $"{urlKismet}/devices/by-mac/{kismet.MacAddress}/devices.json"; KismetOneMac = await GetDevices(urlOneMac, jsonContentFields); //have to check KismetOneMac list because sometimes it is empty if (KismetOneMac.Any()) { unknownDevice.AccessPoint = AllActiveDevices.Where(x => x.MacAddress == KismetOneMac.First().LastBSSID).Select(x => x.BaseName).DefaultIfEmpty("No AP").First(); if (string.IsNullOrEmpty(kismet.ProbedSSID) || unknownDevice.WiFiName == "0") { unknownDevice.WiFiName = AllActiveDevices.Where(x => x.MacAddress == KismetOneMac.First().LastBSSID).Select(x => x.SSID).DefaultIfEmpty("No AP").First(); } } } isNewItem = false; break; } else { isNewItem = true; } } if (isNewItem) { tempAddList.Add(kismet); } } UnknownDevices.AddRange(tempAddList.ToArray()); UnknownDevices.RemoveAll(x => (unixTimestamp - x.LastUnixTime) / 60 > 120); //remove all entries older that 2 hour //local debugging: show the devices list in console only if some device has been added if (tempAddList.Any() && UnknownDevices.Any()) { var sortedList = UnknownDevices.OrderBy(x => x.SignalType).ThenByDescending(y => y.LastUnixTime).ToList(); Console.WriteLine(); Console.WriteLine($"All unknown devices at: {METHOD.DateTimeTZ().DateTime:G}"); Console.WriteLine(); Console.WriteLine($"dB | First | Last | Mac Address |Count | SignalType | WiFi network | AccessPoint | Common Name | Manufacturer "); Console.WriteLine($" - | ---- | ---- | ----------- | --- | ---------- | --------- | --------- | ----------- | ----------- "); foreach (var device in sortedList) { Console.WriteLine($"{device.LastSignal}{"".PadRight(device.LastSignal < 0 ? 1 : 3)}" + $"| {METHOD.UnixTimeStampToDateTime(device.FirstUnixTime).AddHours(timeOffset):t} " + $"| {METHOD.UnixTimeStampToDateTime(device.LastUnixTime).AddHours(timeOffset):t} " + $"| {device.MacAddress} " + $"| {device.Count}{"".PadRight(device.Count < 10 ? 3 : device.Count < 100 ? 2 : 1)} " + $"| {device.SignalType}{"".PadRight(14 - (!string.IsNullOrEmpty(device.SignalType) ? (device.SignalType.Length > 14 ? 14 : device.SignalType.Length) : 0))}" + $"| {device.WiFiName}{"".PadRight(26 - (!string.IsNullOrEmpty(device.WiFiName) ? (device.WiFiName.Length > 26 ? 26 : device.WiFiName.Length) : 0))}" + $"| {device.AccessPoint}{"".PadRight(26 - (!string.IsNullOrEmpty(device.AccessPoint) ? (device.AccessPoint.Length > 26 ? 26 : device.AccessPoint.Length) : 0))}" + $"| {device.CommonName}{"".PadRight(19 - (!string.IsNullOrEmpty(device.CommonName) ? (device.CommonName.Length > 19 ? 19 : device.CommonName.Length) : 0))}" + $"| {device.Manufacture}"); } Console.WriteLine(); } } #endregion await Task.Delay(TimeSpan.FromSeconds(60)); //check statuses every 10 millisecond } }
public async void IRSensorsReading() { _sendListData = new SendDataAzure(); State NONE = new State { DoorValue = false, IRValue = false }; //door closed, IR passive State DOOR = new State { DoorValue = true, IRValue = false }; //door open, IR passive State ALL = new State { DoorValue = true, IRValue = true }; //door open, IR active State IR = new State { DoorValue = false, IRValue = true }; //door closed, IR active List <State> Entry = new List <State> { NONE, DOOR, ALL, IR, NONE }; List <State> Entry2 = new List <State> { NONE, DOOR, ALL, DOOR, NONE }; List <State> Exit = new List <State> { NONE, IR, NONE, DOOR, ALL, IR, NONE }; List <State> Exit1 = new List <State> { NONE, IR, NONE, DOOR, ALL, DOOR, NONE }; List <State> Exit2 = new List <State> { NONE, IR, ALL, DOOR, ALL, IR, NONE }; List <State> Exit3 = new List <State> { NONE, IR, ALL, IR, NONE }; List <State> Exit4 = new List <State> { NONE, IR, ALL, DOOR, NONE }; List <State> DoorOpenClose = new List <State> { NONE, DOOR, NONE }; List <State> RepeatDoorAll = new List <State> { DOOR, ALL }; //repeat List <State> RepeatAllDoor = new List <State> { ALL, DOOR }; //repeat List <State> RepeatIRAll = new List <State> { IR, ALL }; //repeat List <State> _queue = new List <State> { new State { DoorValue = false, IRValue = false } }; DateTime lastSentTime = METHOD.DateTimeTZ().DateTime; while (true) { try { DateTime CurrentDateTime = METHOD.DateTimeTZ().DateTime; //check the last zone event time to report is there anybody at home Zone LastActiveZone = Zones.First(x => x.ZoneId == LastActiveZoneID); var timerInMinutes = TelemetryDataClass.isHomeSecured ? CONSTANT.TIMER_MINUTES_WHEN_SECURED_HOME_EMPTY : CONSTANT.TIMER_MINUTES_WHEN_HOME_EMPTY; var DurationUntilHouseIsEmpty = !LastActiveZone.IsZoneOpen ? (CurrentDateTime - LastActiveZone.ZoneEventTime).TotalMinutes : 0; SomeoneAtHome.IsSomeoneAtHome = DurationUntilHouseIsEmpty < timerInMinutes || WiFiProbes.IsAnyMobileAtHome; //check each zone in 2 minutes window to report the zone active time foreach (var zone in Zones) { var durationUntilZoneIsEmpty = !zone.IsZoneOpen ? (CurrentDateTime - zone.ZoneEventTime).TotalSeconds : 0; zone.IsZoneEmpty = durationUntilZoneIsEmpty > CONSTANT.TIMER_SECONDS_WHEN_ZONE_EMPTY; if (zone.IsZoneEmpty && zone.ZoneEmptyDetectTime != DateTime.MinValue) { //add alerting sensors into list alertingSensors.Add(new AlertingZone(zone.ZoneName, zone.ZoneEmptyDetectTime.ToString("dd.MM"), zone.ZoneEmptyDetectTime.ToString("HH:mm"), zone.ZoneEventTime.ToString("HH:mm"), zone.IsHomeSecured)); //Console.WriteLine($" {zone.ZoneName} {zone.ZoneEmptyDetectTime:t} - {zone.ZoneEventTime:t} {zone.ZoneEmptyDetectTime:dd.MM} {(zone.IsHomeSecured ? "SECURED" : null)}"); zone.ZoneEmptyDetectTime = new DateTime(); } if (!zone.IsZoneEmpty && zone.ZoneEmptyDetectTime == DateTime.MinValue) { zone.ZoneEmptyDetectTime = CurrentDateTime; } } //if home secured forcing outside lights ON if (TelemetryDataClass.isHomeSecured && SomeoneAtHome.IsSomeoneAtHome && !TelemetryDataClass.isOutsideLightsOn) { SomeoneAtHome.LightsManuallyOnOff = true; TelemetryDataClass.isOutsideLightsOn = await Shelly.SetShellySwitch(true, Shelly.OutsideLight, nameof(Shelly.OutsideLight)); } var DurationUntilToSendData = alertingSensors.Any() ? (CurrentDateTime - lastSentTime).TotalMinutes : 0; var isTimeToSendData = DurationUntilToSendData > CONSTANT.TIMER_MINUTES_TO_SEND_ZONE_COSMOS; if (isTimeToSendData) { alertingSensors.Reverse(); TelemetryDataClass.SourceInfo = $"Zones activity {alertingSensors.Count}"; //check if the last zone was added into list during the home was secured bool isLastZoneSecured = false; string lastZoneName = null; AlertingZone LastZone = alertingSensors.First(); lastZoneName = LastZone.ZoneName; isLastZoneSecured = LastZone.IsHomeSecured; string sensorsOpen = ""; //run the alert only if home is secured and there are some alerting zone if (TelemetryDataClass.isHomeSecured && isLastZoneSecured) { TelemetryDataClass.SourceInfo = $"Home secured {lastZoneName}"; sensorsOpen = "Look where someone is moving:\n\n"; foreach (var zone in alertingSensors) { //create a string with all zones for an e-mail if (zone.IsHomeSecured) { sensorsOpen += $" {zone.ZoneName} {zone.TimeStart} - {zone.TimeEnd}\n"; } } alertingSensors.ForEach(x => Console.WriteLine($"{x.ZoneName} {x.TimeStart} - {x.TimeEnd} {(x.IsHomeSecured ? "SECURED" : null)}")); } var monitorData = new { DeviceID = "HomeController", TelemetryDataClass.SourceInfo, TelemetryDataClass.isHomeSecured, DateAndTime = CurrentDateTime, alertingSensors, date = CurrentDateTime.ToString("dd.MM"), time = CurrentDateTime.ToString("HH:mm"), status = sensorsOpen }; await _sendListData.PipeMessage(monitorData, Program.IoTHubModuleClient, TelemetryDataClass.SourceInfo, "output"); alertingSensors.Clear(); lastSentTime = CurrentDateTime; } //maximum is 1000 items in alertingSensor list if (alertingSensors.Count >= CONSTANT.MAX_ITEMS_IN_ALERTING_LIST) { alertingSensors.RemoveAt(0); } Zone doorZone = Zones.First(ir => ir.ZoneId == 1); Zone IrZone = Zones.First(ir => ir.ZoneId == 2); Zone smokeZone = Zones.First(ir => ir.ZoneId == 7); bool isDoorOpen = doorZone.IsZoneOpen; bool isIrOpen = IrZone.IsZoneOpen; bool isSmokeOpen = smokeZone.IsZoneOpen; TelemetryDataClass.isHomeDoorOpen = isDoorOpen; //if door opens or someone in entry then turn on Entry light. Shelly is configured to turn off after 2 minutes if (isDoorOpen || isIrOpen) { await Shelly.SetShellySwitch(true, Shelly.EntryLight, nameof(Shelly.EntryLight)); } //if door or IR is closed more that 2 minutes then clear the queue var LastActive = doorZone.ZoneEventTime > IrZone.ZoneEventTime ? doorZone.ZoneEventTime : IrZone.ZoneEventTime; var durationUntilReset = _queue.Count > 1 ? (CurrentDateTime - LastActive).TotalSeconds : 0; bool isClearTime = durationUntilReset > CONSTANT.TIMER_SECONDS_CLEAR_DOOR_QUEUE; if (isClearTime && !isDoorOpen) { _queue.Clear(); _queue.Add(new State { DoorValue = false, IRValue = false }); //Console.WriteLine($"{CurrentDateTime:T} queue cleared"); } //save the door and IR statuses for the queue State _state = new State { DoorValue = isDoorOpen, IRValue = isIrOpen }; if (_queue.Count > 6) { _queue = new List <State>(Helpers.Rotate(_queue, 1)); _queue.RemoveAt(_queue.Count - 1); } //if list is empty, then return both open, otherwise last item State lastItem = (_queue.Count != 0) ? _queue[_queue.Count - 1] : new State { DoorValue = true, IRValue = true }; string status = "No pattern"; if (_state != lastItem) { _queue.Add(_state); if (RemoveDuplicate(_queue, RepeatDoorAll)) { Console.WriteLine($"Door-All duplicate removed"); } if (RemoveDuplicate(_queue, RepeatAllDoor)) { Console.WriteLine($"All-Door duplicate removed"); } if (RemoveDuplicate(_queue, RepeatIRAll)) { Console.WriteLine($"IR-All duplicate removed"); } if (_queue.Count > 2) //only check pattern if there are more than 3 events in queue { if (ContainsPattern(_queue, Entry)) { status = "entry"; } if (ContainsPattern(_queue, Entry2)) { status = "entry 2"; } if (ContainsPattern(_queue, Exit)) { status = "exit"; } if (ContainsPattern(_queue, Exit1)) { status = "exit 1"; } if (ContainsPattern(_queue, Exit2)) { status = "exit 2"; } if (ContainsPattern(_queue, Exit3)) { status = "exit 3"; } if (ContainsPattern(_queue, Exit4)) { status = "exit 4"; } if (ContainsPattern(_queue, DoorOpenClose)) { status = "door open-closed"; } } } if (status != "No pattern") { _queue.Clear(); //clear queue and pattern _queue.Add(new State { DoorValue = false, IRValue = false }); //add first all-closed pattern TelemetryDataClass.SourceInfo = $"Home {status}"; var monitorData = new { DeviceID = "SecurityController", door = "Home", status = TelemetryDataClass.SourceInfo, TelemetryDataClass.isHomeSecured, date = CurrentDateTime.ToString("dd.MM"), time = CurrentDateTime.ToString("HH:mm"), DateAndTime = CurrentDateTime }; await _sendListData.PipeMessage(monitorData, Program.IoTHubModuleClient, TelemetryDataClass.SourceInfo, "output"); status = "No pattern"; } } catch (Exception e) { Console.WriteLine($"Paradox exception: {e}"); } await Task.Delay(TimeSpan.FromMilliseconds(10)); //check statuses every 10 millisecond } }
private int LastActiveZoneID = 1; //lets be door, actually this doesnt matter public async void ParadoxSecurity() { string ComPort = "/dev/ttyAMA0"; int baudrate = 9600; _serialPort = new SerialPort(ComPort, baudrate); try { _serialPort.Open(); } catch (IOException ex) { Console.WriteLine($"{ex}"); } byte[] DataStream = new byte[4]; byte index = 0; while (true) { await Task.Delay(TimeSpan.FromMilliseconds(1)); //check statuses every millisecond //Spectra message output is always 4 bytes try { if (_serialPort.BytesToRead < 4) { index = 0; while (index < 4) { DataStream[index++] = (byte)_serialPort.ReadByte(); } } } catch (Exception e) { Console.WriteLine($"Timeout {e}"); } int EventId = DataStream[0] >> 2; int CategoryId = ((DataStream[0] & 3) << 4) + (DataStream[1] >> 4); string Event = events.Where(x => x.EventId == EventId).Select(x => x.EventName).DefaultIfEmpty($"Event_{EventId}").First(); int EventCategory = events.Where(x => x.EventId == EventId).Select(x => x.EventCategory).DefaultIfEmpty(EventId).First(); string Message = CategoryId.ToString(); bool isZoneEvent = EventCategory == Category.ZONE; bool isStatus = EventCategory == Category.STATUS; bool isTrouble = EventCategory == Category.TROUBLE; bool isAccessCode = EventCategory == Category.ACCESS_CODE; bool isSpecialAlarm = EventCategory == Category.SPECIAL_ALARM; bool isSpecialArm = EventCategory == Category.SPECIAL_ARM; bool isSpecialDisarm = EventCategory == Category.SPECIAL_DISARM; bool isNonReportEvents = EventCategory == Category.NON_REPORT_EVENTS; bool isSpecialReport = EventCategory == Category.SPECIAL_REPORT; bool isRemoteControl = EventCategory == Category.REMOTE_CONTROL; if (isZoneEvent) { bool IsZoneOpen = false; if (EventId == 1) { IsZoneOpen = true; } //update existing list with the IR statuses and activating/closing time Zones.Where(x => x.ZoneId == CategoryId).Select(x => { x.IsZoneOpen = IsZoneOpen; x.IsHomeSecured = TelemetryDataClass.isHomeSecured; x.ZoneEventTime = METHOD.DateTimeTZ().DateTime; return(x); }).ToList(); LastActiveZoneID = CategoryId; //last active zone ID used to check if anybody is home Message = Zones.Where(x => x.ZoneId == CategoryId).Select(x => $"{x.ZoneName}").DefaultIfEmpty($"Zone_{CategoryId}").First(); } if (isStatus) { Message = PartitionStatuses.Where(x => x.CategoryId == CategoryId).Select(x => x.Name).DefaultIfEmpty($"Status_{CategoryId}").First(); } if (isTrouble) { Message = SystemTroubles.Where(x => x.CategoryId == CategoryId).Select(x => x.Name).DefaultIfEmpty($"Trouble_{CategoryId}").First(); } if (isSpecialAlarm) { Message = SpecialAlarms.Where(x => x.CategoryId == CategoryId).Select(x => x.Name).DefaultIfEmpty($"SpecialAlarm_{CategoryId}").First(); } if (isSpecialArm) { Message = SpecialArms.Where(x => x.CategoryId == CategoryId).Select(x => x.Name).DefaultIfEmpty($"SpecialArm_{CategoryId}").First(); } if (isSpecialDisarm) { Message = SpecialDisarms.Where(x => x.CategoryId == CategoryId).Select(x => x.Name).DefaultIfEmpty($"SpecialDisarm_{CategoryId}").First(); } if (isNonReportEvents) { Message = NonReportableEvents.Where(x => x.CategoryId == CategoryId).Select(x => x.Name).DefaultIfEmpty($"NonReportEvent_{CategoryId}").First(); } if (isSpecialReport) { Message = SpecialReportings.Where(x => x.CategoryId == CategoryId).Select(x => x.Name).DefaultIfEmpty($"SpecialReporting_{CategoryId}").First(); } if (isRemoteControl) { Message = $"Remote_{CategoryId}"; } if (isAccessCode) { Message = GetAccessCode(CategoryId); } if (!(isStatus && (CategoryId == 0 || CategoryId == 1)) && !(EventId == 0 || EventId == 1)) //not show System Ready/Not ready messages and zone open/close messages. { //Console.WriteLine($"{METHOD.DateTimeTZ():HH:mm:ss,ff} {Event}, {Message}"); } } }
public MethodChecked(METHOD value) { this.Value = value; }
/// <summary> /// 构造函数 /// </summary> /// <param name="AMethod">解析方法类型</param> public DatagramResolver(METHOD AMethod) { _ResolveMethod = AMethod; }