public async Task ReadAllAsync()
{
foreach (var subscription in _subscriptions)
{
var request = new RestRequest("sensors", Method.GET)
{
Timeout = 2000
};
request.AddQueryParameter("sensorName", subscription);
try
{
var response = await _restClient.ExecuteTaskAsync <SensorPayload>(request);
if (response.IsSuccessful)
{
_valueCallback.SetValue(subscription, response.Data.Value, response.Data.LastChangeDateTime, StatusBits.Spontaneous);
}
else
{
_logger.Error($"Error while requesting symbolic address '{subscription}' from Web Service: " + response.ErrorMessage);
_valueCallback.SetValue(subscription, StatusBits.Invalid);
}
}
catch (Exception e)
{
_logger.Error($"Exception while requesting symbolic address '{subscription}' from Web Service: " + e.Message);
_valueCallback.SetValue(subscription, StatusBits.Invalid);
}
}
}
/// <summary>
/// is called when the value of the variables are read
/// </summary>
public Task ReadAllAsync()
{
if (_subscriptions.Keys.Count <= 0)
{
return(Task.CompletedTask);
}
foreach (var variable in _subscriptions)
{
if (variable.Value != null)
{
if (variable.Value is string stringValue)
{
// get the value from the database
var dbManager = new DbManager();
var result = dbManager.GetValue(1);
_logger.DeepDebug($"Current Read Value: {result}");
_valueCallback.SetValue(variable.Key, result);
}
else if (variable.Value is double value)
{
_valueCallback.SetValue(variable.Key, value);
}
}
}
return(Task.CompletedTask);
}
public async Task InitializeAsync(ILogger logger, IValueCallback valueCallback, string configFilePath)
{
_logger = logger;
_valueCallback = valueCallback;
var configuration = GetConfiguration(configFilePath);
var serverAddress = configuration["MqttServerAddress"] ?? "localhost";
var clientId = configuration["ClientId"] ?? "myLocalClientId";
// Create TCP based options using the builder.
var options = new MqttClientOptionsBuilder()
.WithClientId(clientId)
.WithTcpServer(serverAddress)
// .WithCredentials("bud", "%spencer%")
// .WithTls()
.WithCleanSession()
.Build();
await _mqttClient.ConnectAsync(options, CancellationToken.None);
_mqttClient.UseDisconnectedHandler(async e =>
{
if (!_mqttClient.IsConnected)
{
foreach (var subscription in _subscriptions)
{
_valueCallback.SetValue(subscription, StatusBits.Invalid);
}
}
logger.Warn("### DISCONNECTED FROM SERVER ###");
await Task.Delay(TimeSpan.FromSeconds(5));
try
{
await _mqttClient.ReconnectAsync();
foreach (var symbolicAddress in _subscriptions)
{
await _mqttClient.SubscribeAsync(
new TopicFilterBuilder().WithTopic(symbolicAddress).Build());
}
}
catch
{
logger.Error("### RECONNECTING FAILED ###");
}
});
_mqttClient.UseApplicationMessageReceivedHandler(args =>
{
var payload = Encoding.UTF8.GetString(args.ApplicationMessage.Payload);
var t = JsonConvert.DeserializeObject <SensorPayload>(payload);
_valueCallback.SetValue(args.ApplicationMessage.Topic, t.Value, t.LastChangeDateTime);
});
}
public Task ReadAllAsync()
{
_logger.Info("Read system information...");
SystemInfo systemInfo = ReadSystemInfoAsync();
var keys = new List <string>(subscriptions.Keys);
foreach (var key in keys)
{
if (key.StartsWith("CPU Core"))
{
var currentCpuNumber = key.Substring(9);
var coreInfo = systemInfo.CoreInfos.FirstOrDefault(p => p.Name.Contains("#" + currentCpuNumber));
if (coreInfo != null)
{
subscriptions[key] = coreInfo.Temp;
}
}
}
foreach (var subscription in subscriptions)
{
if (subscription.Value != null)
{
_valueCallback.SetValue(subscription.Key, (double)subscription.Value, DateTime.Now);
}
}
foreach (SystemInfo.CoreInfo cInfo in systemInfo.CoreInfos)
{
_logger.Info($"Name: {cInfo.Name} - {cInfo.Load} % - {cInfo.Temp} �C");
}
return(Task.CompletedTask);
}
public Task ReadAllAsync()
{
foreach (var variable in _subscriptions)
{
if (variable.Value != null)
{
if (variable.Value is string stringValue)
{
_valueCallback.SetValue(variable.Key, stringValue, StatusBits.Spontaneous);
}
else if (variable.Value is double value)
{
_valueCallback.SetValue(variable.Key, value, StatusBits.Spontaneous);
}
}
}
return(Task.CompletedTask);
}
/// <summary>
/// is called when the value of the variables are read
/// </summary>
public Task ReadAllAsync()
{
if (_subscriptions.Keys.Count <= 0)
{
return(Task.CompletedTask);
}
var latitudeKey = "Latitude";
if (_subscriptions.ContainsKey(latitudeKey))
{
_subscriptions[latitudeKey] = latitude;
_valueCallback.SetValue(latitudeKey, latitude, DateTime.Now, StatusBits.Spontaneous);
}
var longitudeKey = "Longitude";
if (_subscriptions.ContainsKey(longitudeKey))
{
_subscriptions[longitudeKey] = longitude;
_valueCallback.SetValue(longitudeKey, longitude, DateTime.Now, StatusBits.Spontaneous);
}
//Take care on the subscription! for the example, a free developer key is used. If used excessively, the costs can be increased drastically.
//Also think setting the update time of the driver to a long interval. after all, weather does not need to be queried multiple times a second, right?
var weatherFrog = new AzureWeatherApiClient();
var weatherKeys = weatherFrog.GetWeatherParameterKeys();
var weatherDataTask = weatherFrog.GetCurrentWeatherData(latitude, longitude);
weatherDataTask.Wait();
var weatherData = weatherDataTask.Result;
var statusBit = StatusBits.Spontaneous;
if (weatherData.HasErrors())
{
//If you defined a variable with the symbolic address 'ErrorText' the error message is set to the value of that variable.
if (_subscriptions.ContainsKey("ErrorText"))
{
_valueCallback.SetValue("ErrorText", (string)weatherData.Error, DateTime.Now, StatusBits.Invalid);
}
statusBit &= StatusBits.Invalid;
}
//The symbolic address of the variable has to match the keys given in weather data object!
foreach (var key in weatherKeys)
{
if (_subscriptions.ContainsKey(key))
{
if (weatherData.Data[key] is double)
{
_valueCallback.SetValue(key, (double)weatherData.Data[key], weatherData.DateTime, statusBit);
}
else
{
_valueCallback.SetValue(key, weatherData.Data[key].ToString(), weatherData.DateTime, statusBit);
}
}
}
return(Task.CompletedTask);
}
