private async Task SendTemperatureTelemetryAsync(string componentName, CancellationToken cancellationToken)
{
const string telemetryName = "temperature";
double currentTemperature = _temperature[componentName];
using Message msg = PnpConvention.CreateMessage(telemetryName, currentTemperature, componentName);
await _deviceClient.SendEventAsync(msg, cancellationToken);
_logger.LogDebug($"Telemetry: Sent - component=\"{componentName}\", {{ \"{telemetryName}\": {currentTemperature} }} in °C.");
if (_temperatureReadingsDateTimeOffset.ContainsKey(componentName))
{
_temperatureReadingsDateTimeOffset[componentName].TryAdd(DateTimeOffset.UtcNow, currentTemperature);
}
else
{
_temperatureReadingsDateTimeOffset.TryAdd(
componentName,
new Dictionary <DateTimeOffset, double>
{
{ DateTimeOffset.UtcNow, currentTemperature },
});
}
}
// Send device serial number over property update.
private async Task SendDeviceSerialNumberAsync(CancellationToken cancellationToken)
{
const string propertyName = "serialNumber";
TwinCollection reportedProperties = PnpConvention.CreatePropertyPatch(propertyName, SerialNumber);
await _deviceClient.UpdateReportedPropertiesAsync(reportedProperties, cancellationToken);
_logger.LogDebug($"Property: Update - {{ \"{propertyName}\": \"{SerialNumber}\" }} is complete.");
}
private async Task UpdateMaxTemperatureSinceLastRebootAsync(string componentName, CancellationToken cancellationToken)
{
const string propertyName = "maxTempSinceLastReboot";
double maxTemp = _maxTemp[componentName];
TwinCollection reportedProperties = PnpConvention.CreateComponentPropertyPatch(componentName, propertyName, maxTemp);
await _deviceClient.UpdateReportedPropertiesAsync(reportedProperties, cancellationToken);
_logger.LogDebug($"Property: Update - component=\"{componentName}\", {{ \"{propertyName}\": {maxTemp} }} in °C is complete.");
}
// The desired property update callback, which receives the target temperature as a desired property update,
// and updates the current temperature value over telemetry and property update.
private async Task TargetTemperatureUpdateCallbackAsync(TwinCollection desiredProperties, object userContext)
{
string componentName = (string)userContext;
bool targetTempUpdateReceived = PnpConvention.TryGetPropertyFromTwin(
desiredProperties,
TargetTemperatureProperty,
out double targetTemperature,
componentName);
if (!targetTempUpdateReceived)
{
_logger.LogDebug($"Property: Update - component=\"{componentName}\", received an update which is not associated with a valid property.\n{desiredProperties.ToJson()}");
return;
}
_logger.LogDebug($"Property: Received - component=\"{componentName}\", {{ \"{TargetTemperatureProperty}\": {targetTemperature}°C }}.");
s_localWritablePropertiesVersion = desiredProperties.Version;
TwinCollection pendingReportedProperty = PnpConvention.CreateComponentWritablePropertyResponse(
componentName,
TargetTemperatureProperty,
targetTemperature,
(int)StatusCode.InProgress,
desiredProperties.Version,
"In progress - reporting current temperature");
await _deviceClient.UpdateReportedPropertiesAsync(pendingReportedProperty);
_logger.LogDebug($"Property: Update - component=\"{componentName}\", {{\"{TargetTemperatureProperty}\": {targetTemperature} }} in °C is {StatusCode.InProgress}.");
// Update Temperature in 2 steps
double step = (targetTemperature - _temperature[componentName]) / 2d;
for (int i = 1; i <= 2; i++)
{
_temperature[componentName] = Math.Round(_temperature[componentName] + step, 1);
await Task.Delay(6 * 1000);
}
TwinCollection completedReportedProperty = PnpConvention.CreateComponentWritablePropertyResponse(
componentName,
TargetTemperatureProperty,
_temperature[componentName],
(int)StatusCode.Completed,
desiredProperties.Version,
"Successfully updated target temperature");
await _deviceClient.UpdateReportedPropertiesAsync(completedReportedProperty);
_logger.LogDebug($"Property: Update - component=\"{componentName}\", {{\"{TargetTemperatureProperty}\": {_temperature[componentName]} }} in °C is {StatusCode.Completed}");
}
// Provision a device via DPS, by sending the PnP model Id as DPS payload.
private static async Task <DeviceRegistrationResult> ProvisionDeviceAsync(Parameters parameters, CancellationToken cancellationToken)
{
SecurityProvider symmetricKeyProvider = new SecurityProviderSymmetricKey(parameters.DeviceId, parameters.DeviceSymmetricKey, null);
ProvisioningTransportHandler mqttTransportHandler = new ProvisioningTransportHandlerMqtt();
ProvisioningDeviceClient pdc = ProvisioningDeviceClient.Create(parameters.DpsEndpoint, parameters.DpsIdScope, symmetricKeyProvider, mqttTransportHandler);
var pnpPayload = new ProvisioningRegistrationAdditionalData
{
JsonData = PnpConvention.CreateDpsPayload(ModelId),
};
return(await pdc.RegisterAsync(pnpPayload, cancellationToken));
}
private async Task ReportInitialPropertyAsync(string componentName, string propertyName, CancellationToken cancellationToken)
{
// If the device properties are empty, report the default value with ACK(ac=203, av=0) as part of the PnP convention.
// "DefaultPropertyValue" is set from the device when the desired property is not set via the hub.
TwinCollection reportedProperties = PnpConvention.CreateComponentWritablePropertyResponse(
componentName,
propertyName,
DefaultPropertyValue,
(int)StatusCode.ReportDeviceInitialProperty,
DefaultAckVersion,
"Initialized with default value");
await _deviceClient.UpdateReportedPropertiesAsync(reportedProperties, cancellationToken);
_logger.LogDebug($"Report the default values for \"{componentName}\".\nProperty: Update - {reportedProperties.ToJson()} is complete.");
}
// Send working set of device memory over telemetry.
private async Task SendDeviceMemoryAsync(CancellationToken cancellationToken)
{
const string workingSetName = "workingSet";
long workingSet = Process.GetCurrentProcess().PrivateMemorySize64 / 1024;
var telemetry = new Dictionary <string, object>
{
{ workingSetName, workingSet },
};
using Message msg = PnpConvention.CreateMessage(telemetry);
await _deviceClient.SendEventAsync(msg, cancellationToken);
_logger.LogDebug($"Telemetry: Sent - {JsonConvert.SerializeObject(telemetry)} in KB.");
}
private async static void SendTelemetry(double temperature, string telemetryName, string componentName)
{
Message message;
if (telemetryName == "temperature")
{
//telemetryPayload = $"{{ \"{telemetryName}\": {pt_temperature} }}";
message = PnpConvention.CreateMessage(telemetryName, pt_temperature, componentName);
await deviceClient.SendEventAsync(message);
}
if (telemetryName == "humidity")
{
//telemetryPayload = $"{{ \"{telemetryName}\": {pt_humidity} }}";
message = PnpConvention.CreateMessage(telemetryName, pt_humidity, componentName);
await deviceClient.SendEventAsync(message);
}
if (telemetryName == "inductance")
{
//telemetryPayload = $"{{ \"{telemetryName}\": {pt_humidity} }}";
message = PnpConvention.CreateMessage(telemetryName, induc, componentName);
await deviceClient.SendEventAsync(message);
}
if (telemetryName == "acceleration")
{
//telemetryPayload = $"{{ \"{telemetryName}\": {pt_humidity} }}";
message = PnpConvention.CreateMessage(telemetryName, acceleration, componentName);
await deviceClient.SendEventAsync(message);
}
if (telemetryName == "angularrate")
{
//telemetryPayload = $"{{ \"{telemetryName}\": {pt_humidity} }}";
message = PnpConvention.CreateMessage(telemetryName, angularrate, componentName);
await deviceClient.SendEventAsync(message);
}
if (telemetryName == "workingSet")
{
//telemetryPayload = $"{{ \"{telemetryName}\": {pt_humidity} }}";
message = PnpConvention.CreateMessage(telemetryName, workingsetsize);
await deviceClient.SendEventAsync(message);
}
}
private static async Task UpdateReadOnlyProperties(string propertyName, string componentName)
{
if (propertyName == "maxTempSinceLastReboot")
{
//var reportedProperties = new TwinCollection();
//reportedProperties[propertyName] = max_temperature;
//await deviceClient.UpdateReportedPropertiesAsync(reportedProperties);
TwinCollection reportedProperties = PnpConvention.CreateComponentPropertyPatch(componentName, propertyName, max_temperature);
await deviceClient.UpdateReportedPropertiesAsync(reportedProperties);
}
if (propertyName == "maxHumiditySinceLastReboot")
{
var reportedProperties = new TwinCollection();
reportedProperties[propertyName] = max_humidity;
await deviceClient.UpdateReportedPropertiesAsync(reportedProperties);
}
}
// Report the property updates on "deviceInformation" component.
private async Task UpdateDeviceInformationAsync(CancellationToken cancellationToken)
{
const string componentName = "deviceInformation";
TwinCollection deviceInfoTc = PnpConvention.CreateComponentPropertyPatch(
componentName,
new Dictionary <string, object>
{
{ "manufacturer", "element15" },
{ "model", "ModelIDxcdvmk" },
{ "swVersion", "1.0.0" },
{ "osName", "Windows 10" },
{ "processorArchitecture", "64-bit" },
{ "processorManufacturer", "Intel" },
{ "totalStorage", 256 },
{ "totalMemory", 1024 },
});
await _deviceClient.UpdateReportedPropertiesAsync(deviceInfoTc, cancellationToken);
_logger.LogDebug($"Property: Update - component = '{componentName}', properties update is complete.");
}
private static async void SendTelemetry2(object v1, string telemetryName, string componentName)
{
var message = PnpConvention.CreateMessage(telemetryName, v1, componentName);
await deviceClient.SendEventAsync(message);
}
private static async Task PatchProperty(string componentName, Dictionary <string, object> dictio)
{
TwinCollection deviceInfoTc = PnpConvention.CreateComponentPropertyPatch(componentName, dictio);
await deviceClient.UpdateReportedPropertiesAsync(deviceInfoTc);
}
private static async Task UpdateProperty(string componentName, string propertyName, string v)
{
TwinCollection reportedProperties = PnpConvention.CreateComponentPropertyPatch(componentName, propertyName, v);
await deviceClient.UpdateReportedPropertiesAsync(reportedProperties);
}
