protected override void Update(ISensorContainer sensor, SwimmingPool pool, SwimmingPoolWeather obj) { sensor.SetAttribute("temp_min", obj.TemperatureMin); sensor.SetAttribute("temp_max", obj.TemperatureMax); sensor.SetValue(HassTopicKind.State, obj.TemperatureCurrent); }
protected override void Update(ISensorContainer sensor, SwimmingPool pool, SwimmingPoolWeather obj) { sensor.SetAttribute("temp_min", obj.TemperatureMin); sensor.SetAttribute("temp_max", obj.TemperatureMax); sensor.SetAttribute("temp", obj.TemperatureCurrent); sensor.SetAttribute("wind_speed", obj.WindSpeedCurrent); sensor.SetAttribute("uv", obj.UvCurrent); sensor.SetValue(HassTopicKind.State, obj.WeatherCurrentDescription); }
private Task UponorClientOnOnFailedResponse(string message) { ISensorContainer sensor = _hassMqttManager.GetSensor(DeviceId, EntityId); sensor.SetValue(HassTopicKind.State, ProblemMessage); sensor.SetAttribute("last_bad", DateTime.UtcNow.ToString("O")); sensor.SetAttribute("last_bad_status", message); _shouldFlush.Set(); return(Task.CompletedTask); }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { ISensorContainer operationalSensor = CreateSystemEntities(); try { // Update loop while (!stoppingToken.IsCancellationRequested) { _logger.LogDebug("Beginning update"); try { await PerformUpdate(stoppingToken); // Track API operational status operationalSensor.SetValue(HassTopicKind.State, OkMessage); operationalSensor.SetAttribute("last_ok", DateTime.UtcNow.ToString("O")); } catch (OperationCanceledException) when(stoppingToken.IsCancellationRequested) { // Do nothing } catch (Exception e) { _logger.LogError(e, "An error occurred while performing the update"); // Track API operational status operationalSensor.SetValue(HassTopicKind.State, ProblemMessage); operationalSensor.SetAttribute("last_bad", DateTime.UtcNow.ToString("O")); operationalSensor.SetAttribute("last_bad_status", e.Message); } await Task.Delay(_config.DiscoveryInterval, stoppingToken); } } finally { // Stop all updaters _logger.LogInformation("Stopping all pool updaters"); foreach (SingleBlueRiiotPoolUpdater updater in _updaters.Values) { updater.Stop(); } } }
protected override void UpdateInternal(SwimmingPool pool, List <SwimmingPoolLastMeasurementsGetResponse> measurements, SwimmingPoolLastMeasurementsGetResponse latest) { ISensorContainer sensor = HassMqttManager .GetSensor(HassUniqueIdBuilder.GetPoolDeviceId(pool), "last_measurement") .SetPoolAttributes(pool); if (latest == null) { // No measurements sensor.SetValue(HassTopicKind.State, null); sensor.SetAttribute(AttributeMeasurement, "none"); return; } SwpLastMeasurements lastMeasurement = null; if (latest.LastBlueMeasureTimestamp.HasValue && (!latest.LastStripTimestamp.HasValue || latest.LastBlueMeasureTimestamp > latest.LastStripTimestamp)) { // Blue measurement is latest lastMeasurement = latest.Data.OrderByDescending(s => s.Timestamp).FirstOrDefault(); sensor.SetValue(HassTopicKind.State, latest.LastBlueMeasureTimestamp); sensor.SetAttribute("method", "blue"); } else if (latest.LastStripTimestamp.HasValue) { // Strip measurement is latest lastMeasurement = latest.Data.OrderByDescending(s => s.Timestamp).FirstOrDefault(); sensor.SetValue(HassTopicKind.State, latest.LastStripTimestamp); sensor.SetAttribute("method", "strip"); } else { // No measurements sensor.SetAttribute(AttributeMeasurement, "none"); sensor.SetValue(HassTopicKind.State, null); } if (lastMeasurement != null) { sensor.SetAttribute(AttributeMeasurement, lastMeasurement.Name); } }
protected sealed override void UpdateInternal(SwimmingPool pool, SwimmingPoolWeather obj) { ISensorContainer sensor = HassMqttManager.GetSensor(HassUniqueIdBuilder.GetPoolDeviceId(pool), _measurement); Update(sensor, pool, obj); sensor .SetAttribute("timestamp", obj.Timestamp) .SetPoolAttributes(pool); }
protected override void UpdateInternal(SwimmingPool pool, SwimmingPoolDevice data) { string deviceId = HassUniqueIdBuilder.GetBlueDeviceId(data); ISensorContainer deviceSensor = HassMqttManager .GetSensor(deviceId, "device") .SetPoolAttributes(pool); ISensorContainer batterySensor = HassMqttManager .GetSensor(deviceId, "battery") .SetPoolAttributes(pool); ISensorContainer statusSensor = HassMqttManager .GetSensor(deviceId, "status") .SetPoolAttributes(pool); // Device // Determine last contact DateTime?latestContact = ComparisonHelper.GetMax(data.Created, data.BlueDevice.LastHelloMessageV, data.BlueDevice.LastMeasureMessage, data.BlueDevice.LastMeasureMessageBle, data.BlueDevice.LastMeasureMessageSigfox); deviceSensor.SetValue(HassTopicKind.State, latestContact); // Device attributes deviceSensor.SetAttribute("serial", data.BlueDevice.Serial); deviceSensor.SetAttribute("serial_number", data.BlueDevice.Sn); deviceSensor.SetAttribute("wake_interval", data.BlueDevice.WakePeriod); deviceSensor.SetAttribute("firmware", data.BlueDevice.FwVersionPsoc); deviceSensor.SetAttribute("firmware_installed", data.BlueDevice.FwVersionHistory?.OrderByDescending(s => s.Timestamp).Select(s => s.Timestamp).FirstOrDefault()); // Battery if (data.BlueDevice.BatteryLow) { batterySensor.SetValue(HassTopicKind.State, 10); } else { batterySensor.SetValue(HassTopicKind.State, 100); } // Status (awake, sleeping, ..) statusSensor.SetValue(HassTopicKind.State, data.BlueDevice.SleepState); }
protected override void UpdateInternal(SwimmingPool pool, SwimmingPoolGuidanceGetResponse guidance) { ISensorContainer sensor = HassMqttManager .GetSensor(HassUniqueIdBuilder.GetPoolDeviceId(pool), "guidance") .SetPoolAttributes(pool); if (guidance.Guidance?.IssueToFix == null) { sensor.SetValue(HassTopicKind.State, "No guidance at this time"); sensor.SetAttribute("status", "ok"); return; } string text = $"{guidance.Guidance.IssueToFix.IssueTitle}: {guidance.Guidance.IssueToFix.ActionTitle}"; sensor.SetValue(HassTopicKind.State, text); sensor.SetAttribute("status", "alert"); }
private Task UponorClientOnOnSuccessfulResponse() { ISensorContainer sensor = _hassMqttManager.GetSensor(DeviceId, EntityId); sensor.SetValue(HassTopicKind.State, OkMessage); sensor.SetAttribute("last_ok", DateTime.UtcNow.ToString("O")); _shouldFlush.Set(); return(Task.CompletedTask); }
public override void Process(UponorResponseContainer values) { List <string> problems = new List <string>(); foreach ((int controller, int thermostat) in _systemDetails.GetAvailableThermostats()) { string deviceId = HassUniqueIdBuilder.GetThermostatDeviceId(controller, thermostat); // Battery sensor // We don't know what the battery level is with Uponor. So we can only say it's "good" or "bad" ISensorContainer sensor = HassMqttManager.GetSensor(deviceId, "battery"); if (values.TryGetValue( UponorObjects.Thermostat(UponorThermostats.BatteryAlarm, controller, thermostat), UponorProperties.Value, out object objVal) && objVal != null) { sensor.SetValue(HassTopicKind.State, BatteryLow); } else { sensor.SetValue(HassTopicKind.State, BatteryOk); } // Alarm sensor sensor = HassMqttManager.GetSensor(deviceId, "alarms"); problems.Clear(); // Check one of: RfAlarm, BatteryAlarm, TechnicalAlarm, TamperIndication if (values.TryGetValue( UponorObjects.Thermostat(UponorThermostats.RfAlarm, controller, thermostat), UponorProperties.Value, out objVal) && objVal != null) { problems.Add("No signal"); sensor.SetAttribute("signal", "alarm"); } else { sensor.SetAttribute("signal", "ok"); } if (values.TryGetValue( UponorObjects.Thermostat(UponorThermostats.TechnicalAlarm, controller, thermostat), UponorProperties.Value, out objVal) && objVal != null) { problems.Add("Technical (?)"); sensor.SetAttribute("technical", "alarm"); } else { sensor.SetAttribute("technical", "ok"); } if (values.TryGetValue( UponorObjects.Thermostat(UponorThermostats.TamperIndication, controller, thermostat), UponorProperties.Value, out objVal) && objVal != null) { problems.Add("Tampering"); sensor.SetAttribute("tampering", "alarm"); } else { sensor.SetAttribute("tampering", "ok"); } if (problems.Any()) { sensor.SetValue(HassTopicKind.State, "on"); sensor.SetAttribute("problem", string.Join(", ", problems)); } else { sensor.SetValue(HassTopicKind.State, "off"); sensor.SetAttribute("problem", string.Empty); } } }
private async Task Run() { ISensorContainer operationalSensor = CreateSystemEntities(); // Update loop while (!_stoppingToken.Token.IsCancellationRequested) { _logger.LogDebug("Beginning update for pool {Pool}", _pool.SwimmingPoolId); try { await PerformUpdate(_stoppingToken.Token); // Track API operational status operationalSensor.SetValue(HassTopicKind.State, BlueRiiotMqttService.OkMessage); operationalSensor.SetAttribute("last_ok", DateTime.UtcNow); } catch (OperationCanceledException) when(_stoppingToken.Token.IsCancellationRequested) { // Do nothing } catch (Exception e) { _logger.LogError(e, "An error occurred while performing the update for pool {Pool}", _pool.SwimmingPoolId); // Track API operational status operationalSensor.SetValue(HassTopicKind.State, BlueRiiotMqttService.ProblemMessage); operationalSensor.SetAttribute("last_bad", DateTime.UtcNow); operationalSensor.SetAttribute("last_bad_status", e.Message); } TimeSpan?runDelay; if (_config.EnableSchedule) { // Calculate time to next update runDelay = _delayCalculator.CalculateNextRun(DateTime.UtcNow); DateTime runNext = DateTime.UtcNow + runDelay.Value; operationalSensor.SetAttribute("next_run", runNext); } else { // We will forever wait for manual sync runDelay = null; operationalSensor.SetAttribute("next_run", "manual"); } try { await _hassMqttManager.FlushAll(_stoppingToken.Token); } catch (OperationCanceledException) when(_stoppingToken.Token.IsCancellationRequested) { // Do nothing } catch (Exception e) { _logger.LogError(e, "An error occurred while pushing updated data to MQTT for pool {Pool}", _pool.SwimmingPoolId); } // Wait on the force sync reset event, for the specified time. // If either the reset event or the time runs out, we do an update using (CancellationTokenSource cts = new CancellationTokenSource()) using (CancellationTokenSource linkedToken = CancellationTokenSource.CreateLinkedTokenSource(cts.Token, _stoppingToken.Token)) { if (runDelay.HasValue) { cts.CancelAfter(runDelay.Value); } try { await _forceSyncResetEvent.WaitAsync(linkedToken.Token); // We were forced _logger.LogDebug("Forcing a sync for pool {Pool} with BlueRiiot", _pool.SwimmingPoolId); } catch (OperationCanceledException) { } } } }
public static ISensorContainer SetPoolAttributes(this ISensorContainer sensor, SwimmingPool pool) { return(sensor.SetAttribute("pool_id", pool.SwimmingPoolId)); }
public void SetAttribute(string name, object value) { ISensorContainer sensor = _hassMqttManager.GetSensor(_config.DeviceId, _config.EntityId); sensor.SetAttribute(name, value); }