public static async void SendData(Object telemetryDataPoint, string deviceKey)
{
deviceClient = DeviceClient.Create(iotHubUri, new DeviceAuthenticationWithRegistrySymmetricKey(App.deviceName, deviceKey));
while (true)
{
var messageString = JsonConvert.SerializeObject(telemetryDataPoint);
var message = new Microsoft.Azure.Devices.Client.Message(Encoding.ASCII.GetBytes(messageString));
await deviceClient.SendEventAsync(message);
}
}
public async Task SendAsync(byte[] message, string propKey = null, string propValue = null)
{
var msg = new Microsoft.Azure.Devices.Client.Message(message);
if (!string.IsNullOrEmpty(propKey))
{
msg.Properties.Add(propKey, propValue);
}
await deviceClient.SendEventAsync(msg);
}
static async void SendDeviceToCloudMessagesAsync(DeviceClient deviceClient)
{
//var deviceClient = DeviceClient.Create(iotHubUri,
// AuthenticationMethodFactory.CreateAuthenticationWithRegistrySymmetricKey(deviceId, deviceKey),
// TransportType.Http1);
//var deviceClient = DeviceClient.CreateFromConnectionString(connectionString, TransportType.Http1);
var package = $"{{lightLevel: {lightLevel}, temp: {temp:N3}, analog: {analog:N2}, x: {x}, y: {y}, z: {z} }}";
var message = new Message(Encoding.ASCII.GetBytes(package));
await deviceClient.SendEventAsync(message);
}
static async Task SendEvent(DeviceClient deviceClient)
{
string[] filePath = Directory.GetFiles(@"C:\Weblog\", "*.csv");
string csv_file_path = string.Empty;
int size = filePath.Length;
for (int i = 0; i < size; i++)
{
Console.WriteLine(filePath[i]);
csv_file_path = filePath[i];
}
DataTable csvData = GetDataTableFromCSVFile(csv_file_path);
Console.WriteLine("Rows count:" + csvData.Rows.Count);
DataTable table = csvData;
foreach (DataRow row in table.Rows)
{
foreach (var item in row.ItemArray)
data = item.ToString();
Console.Write(data);
try
{
foreach (DataRow rows in table.Rows)
{
var info = new WeatherData
{
weatherDate = rows.ItemArray[0].ToString(),
weatherTime = rows.ItemArray[1].ToString(),
Type = rows.ItemArray[2].ToString(),
AirTemperature = rows.ItemArray[3].ToString(),
RelativeHumidity = rows.ItemArray[4].ToString(),
WindSpeed = rows.ItemArray[5].ToString(),
SolarRadiation = rows.ItemArray[6].ToString(),
Temperature = rows.ItemArray[7].ToString(),
};
var serializedString = JsonConvert.SerializeObject(info);
var message = data;
Console.WriteLine("{0}> Sending events: {1}", DateTime.Now.ToString(), serializedString.ToString());
await deviceClient.SendEventAsync(new Message(Encoding.UTF8.GetBytes(serializedString.ToString())));
}
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("{ 0} > Exception: { 1}", DateTime.Now.ToString(), ex.Message);
Console.ResetColor();
}
}
Console.WriteLine("Press Ctrl - C to stop the sender process");
Console.WriteLine("Press Enter to start now");
Console.ReadLine();
}
public static async void SendReading(DateTime triggerTime)
{
deviceClient = DeviceClient.CreateFromConnectionString("HostName=IoTLeg.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey=dmg/tdAmz6r13qhToNy6AptULWvbtXeO0aZY2D2qoC4=","alarm");
var telemetryDataPoint = new
{
deviceId = "alarm",
triggerTime = triggerTime
};
var messageString = JsonConvert.SerializeObject(telemetryDataPoint);
var message = new Message(Encoding.ASCII.GetBytes(messageString));
await deviceClient.SendEventAsync(message);
}
static async Task SendEvent(DeviceClient deviceClient)
{
string dataBuffer;
Debug.WriteLine("Device sending {0} messages to IoTHub...\n", MESSAGE_COUNT);
for (int count = 0; count < MESSAGE_COUNT; count++)
{
dataBuffer = string.Format("Msg from UWP: {0}_{1}", count, Guid.NewGuid().ToString());
Message eventMessage = new Message(Encoding.UTF8.GetBytes(dataBuffer));
Debug.WriteLine("\t{0}> Sending message: {1}, Data: [{2}]", DateTime.Now.ToLocalTime(), count, dataBuffer);
await deviceClient.SendEventAsync(eventMessage);
}
}
private static async Task <bool> sendTelemetry()
{
while (true)
{
var messageType3String = MessageType3.GetMessage();
var d2cMessageType3 = new Message(Encoding.ASCII.GetBytes(messageType3String));
try {
await deviceClient.SendEventAsync(d2cMessageType3);
}
catch (Exception ex) {
Console.WriteLine(string.Format("Exception sending D2C message: {0}", ex.Message));
}
await Task.Delay(1000);
}
}
public static async Task SendEvent(DeviceClient deviceClient, string cmd)
{
string dataBuffer;
System.Diagnostics.Debug.WriteLine("Device sending {0} messages to IoTHub...\n", MESSAGE_COUNT);
if (deviceClient != null)
{
for (int count = 0; count < MESSAGE_COUNT; count++)
{
dataBuffer = cmd + ", " + Guid.NewGuid().ToString();
Message eventMessage = new Message(Encoding.UTF8.GetBytes(dataBuffer));
System.Diagnostics.Debug.WriteLine("\t{0}> Sending message: {1}, Data: [{2}]", DateTime.Now.ToLocalTime(), count, dataBuffer);
await deviceClient.SendEventAsync(eventMessage);
}
}
}
static async Task SendEvent(Microsoft.Azure.Devices.Client.DeviceClient deviceClient)
{
Console.WriteLine("Device sending {0} messages to IoTHub...\n", MESSAGE_COUNT);
for (int count = 0; count < MESSAGE_COUNT; count++)
{
temperature = rnd.Next(20, 35);
humidity = rnd.Next(60, 80);
var dataBuffer = string.Format("{{\"messageId\":{0},\"temperature\":{1},\"humidity\":{2}}}", count, temperature, humidity);
Message eventMessage = new Message(Encoding.UTF8.GetBytes(dataBuffer));
eventMessage.Properties.Add("temperatureAlert", (temperature > TEMPERATURE_THRESHOLD) ? "true" : "false");
Console.WriteLine("\t{0}> Sending message: {1}, Data: [{2}]", DateTime.Now.ToLocalTime(), count, dataBuffer);
await deviceClient.SendEventAsync(eventMessage).ConfigureAwait(false);
System.Threading.Thread.Sleep(1500);
}
}
public static async void SendMessagesAsync(Microsoft.Azure.Devices.Client.DeviceClient _deviceClient)
{
while (true)
{
var telemetryDataPoint = new
{
ticketId = System.Guid.NewGuid(),
entryTime = DateTime.UtcNow
};
var messageString = JsonConvert.SerializeObject(telemetryDataPoint);
var message = new Message(Encoding.ASCII.GetBytes(messageString));
await _deviceClient.SendEventAsync(message);
Console.WriteLine("{0} > Sending message: {1}", DateTime.Now, messageString);
await Task.Delay(1000);
}
}
private async Task CheckDeviceAsync(string deviceId)
{
if (_whiteList.ContainsKey(deviceId))
return;
if (_serviceSettings == null)
return;
var connectionString = string.Format("HostName={0}.azure-devices.net;SharedAccessKeyName={1};SharedAccessKey={2}",
_serviceSettings.Host, _serviceSettings.KeyName, _serviceSettings.Key);
var registry = Microsoft.Azure.Devices.RegistryManager.CreateFromConnectionString(connectionString);
var deviceReg = await registry.GetDeviceAsync(deviceId);
if (deviceReg == null)
{
deviceReg = new Microsoft.Azure.Devices.Device(deviceId);
deviceReg = await registry.AddDeviceAsync(deviceReg);
}
var device = new DeviceModel();
device.DeviceId = deviceId;
//device.DeviceRegId = deviceReg.Id;
device.Key = deviceReg.Authentication.SymmetricKey.PrimaryKey;
_whiteList.Add(deviceId, device);
var data = new DeviceMetaData();
data.Version = "1.0";
data.IsSimulatedDevice = false;
data.Properties.DeviceID = deviceId;
data.Properties.FirmwareVersion = "42";
data.Properties.HubEnabledState = true;
data.Properties.Processor = "Foo";
data.Properties.Platform = "Yep";
data.Properties.SerialNumber = "Sigfox-" + deviceId;
data.Properties.InstalledRAM = "1 MB";
data.Properties.ModelNumber = "007-BOND";
data.Properties.Manufacturer = "Sigfox";
//data.Properties.UpdatedTime = DateTime.UtcNow;
data.Properties.DeviceState = DeviceState.Normal;
var content = JsonConvert.SerializeObject(data);
connectionString = string.Format("HostName={0}.azure-devices.net;DeviceId={1};SharedAccessKey={2}",
"sigfoxmonitoring", device.DeviceId, device.Key);
_client = DeviceClient.CreateFromConnectionString(connectionString, TransportType.Http1);
await _client.SendEventAsync(new Message(Encoding.UTF8.GetBytes(content)));
}
private async Task SendEvent(DeviceClient deviceClient)
{
Debug.WriteLine("\nDevice waiting to send messages to IoTHub ...\n");
while (true)
{
var message = _outgoing_queue.Take();
var eventMessage = new Message(Encoding.UTF8.GetBytes(message));
Debug.WriteLine(message);
try
{
await deviceClient.SendEventAsync(eventMessage);
}
catch
{
Debug.WriteLine("SendEvent: Encountered an exception");
}
await Task.Delay(1000);
}
}
private async Task SendEvents(DeviceClient deviceClient)
{
try
{
string dataBuffer;
SensorReader c = new SensorReader(4);
Guid id = Guid.NewGuid();
while (true)
{
var data=c.Read();
if (data!=null && data.IsValid)
{
try {
System.Diagnostics.Debug.WriteLine(string.Format("Temp:{0} Hum:{1}", data.Temperature, data.Humidity));
dataBuffer = string.Format(jsonFormat,
GUID, ORGANIZATION, DISPLAYNAME, LOCATION, TEMPMEASURE, TEMPUNITS, data.Temperature, DateTime.UtcNow);
Message eventMessage = new Message(Encoding.UTF8.GetBytes(dataBuffer));
await deviceClient.SendEventAsync(eventMessage);
dataBuffer = string.Format(jsonFormat,
GUID, ORGANIZATION, DISPLAYNAME, LOCATION, HUMIDMEASURE, HUMIDUNITS, data.Humidity, DateTime.UtcNow);
eventMessage = new Message(Encoding.UTF8.GetBytes(dataBuffer));
await deviceClient.SendEventAsync(eventMessage);
}
catch(Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
await Task.Delay(2000).ConfigureAwait(false);
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(string.Format("{0}: {1}", ex.Message, ex.StackTrace));
}
}
private static async Task CheckDeviceAsync(string deviceId)
{
if (_whiteList.ContainsKey(deviceId))
return;
//var connectionString = IotHubConnectionStringBuilder.Create("sigfoxmonitoring",
// AuthenticationMethodFactory.CreateAuthenticationWithSharedAccessPolicyKey(deviceId, "registryReadWrite", "weAJyh51pxOk5f/OVZRGXc4JR6AJDg+JYjiK3rlDTzs="));
var connectionString = string.Format("HostName={0}.azure-devices.net;SharedAccessKeyName={1};SharedAccessKey={2}",
"sigfoxmonitoring", "iothubowner", "B2LsypvIEz7bdy0217QYfeUvO1xUjKVujlte4wETrvM=");
var registry = Microsoft.Azure.Devices.RegistryManager.CreateFromConnectionString(connectionString);
await registry.RemoveDeviceAsync("Sigfox-FAE88");
return;
var deviceReg = await registry.GetDeviceAsync(deviceId);
if (deviceReg == null)
{
deviceReg = new Microsoft.Azure.Devices.Device(deviceId);
deviceReg = await registry.AddDeviceAsync(deviceReg);
}
var device = new DeviceModel();
device.DeviceId = deviceId;
//device.DeviceRegId = deviceReg.Id;
device.Key = deviceReg.Authentication.SymmetricKey.PrimaryKey;
_whiteList.Add(deviceId, device);
var data = new DeviceMetaData();
data.Version = "1.0";
data.IsSimulatedDevice = false;
data.Properties.DeviceID = deviceId;
data.Properties.FirmwareVersion = "42";
data.Properties.HubEnabledState = true;
data.Properties.Processor = "Foo";
data.Properties.Platform = "Yep";
data.Properties.SerialNumber = "Sigfox-" + deviceId;
data.Properties.InstalledRAM = "1 MB";
data.Properties.ModelNumber = "007-BOND";
data.Properties.Manufacturer = "Sigfox";
//data.Properties.UpdatedTime = DateTime.UtcNow;
data.Properties.DeviceState = DeviceState.Normal;
var content = JsonConvert.SerializeObject(data);
connectionString = string.Format("HostName={0}.azure-devices.net;DeviceId={1};SharedAccessKey={2}",
"sigfoxmonitoring", device.DeviceId, device.Key);
_client = DeviceClient.CreateFromConnectionString(connectionString, TransportType.Http1);
await _client.SendEventAsync(new Message(Encoding.UTF8.GetBytes(content)));
}
public async Task InitAsync()
{
_board = IoC.Instance.Resolve<IBoardService>();
//if (_board == null)
// throw new Exception("A board must be registered");
var connectionString = string.Format("HostName={0}.azure-devices.net;DeviceId={1};SharedAccessKey={2}",
SettingsViewModel.Default.Host, SettingsViewModel.Default.DeviceId, SettingsViewModel.Default.Key);
_client = DeviceClient.CreateFromConnectionString(connectionString, TransportType.Http1);
var data = new DeviceMetaData();
data.Version = "1.0";
data.IsSimulatedDevice = false;
data.Properties.DeviceID = SettingsViewModel.Default.DeviceId;
data.Properties.FirmwareVersion = "1.42";
data.Properties.HubEnabledState = true;
data.Properties.Processor = "ARM";
data.Properties.Platform = "UWP";
data.Properties.SerialNumber = "1234567890";
data.Properties.InstalledRAM = "1024 MB";
data.Properties.ModelNumber = "007-BOND";
data.Properties.Manufacturer = "Raspberry";
//data.Properties.UpdatedTime = DateTime.UtcNow;
data.Properties.DeviceState = DeviceState.Normal;
data.Commands.Add(new DeviceCommandDefinition("SwitchLight"));
data.Commands.Add(new DeviceCommandDefinition("LightColor",
new DeviceCommandParameterDefinition[] {
new DeviceCommandParameterDefinition("Color", DeviceCommandParameterType.String)
}));
data.Commands.Add(new DeviceCommandDefinition("PingDevice"));
data.Commands.Add(new DeviceCommandDefinition("StartTelemetry"));
data.Commands.Add(new DeviceCommandDefinition("StopTelemetry"));
data.Commands.Add(new DeviceCommandDefinition("ChangeSetPointTemp"));
data.Commands.Add(new DeviceCommandDefinition("DiagnosticTelemetry"));
data.Commands.Add(new DeviceCommandDefinition("ChangeDeviceState"));
var content = JsonConvert.SerializeObject(data);
await _client.SendEventAsync(new Message(Encoding.UTF8.GetBytes(content)));
}
public async Task SendAsync(byte[] message)
{
var msg = new Microsoft.Azure.Devices.Client.Message(message);
await deviceClient.SendEventAsync(msg);
}
private async Task SendTelemetryAsync(PayloadModel payload)
{
if (!_whiteList.ContainsKey(payload.device))
return;
var device = _whiteList[payload.device];
var connectionString = string.Format("HostName={0}.azure-devices.net;DeviceId={1};SharedAccessKey={2}",
_serviceSettings.Host, device.DeviceId, device.Key);
_client = DeviceClient.CreateFromConnectionString(connectionString, TransportType.Http1);
var MSB = Math.Floor(payload.byte2 / Math.Pow(2, 4));
var LSB = payload.byte3 % 64;
var temperature = (((MSB * Math.Pow(2, 6)) + LSB) - 200) / 8;
var humidity = payload.byte4 * 0.5;
var data = new DeviceMonitoringData();
data.DeviceId = payload.device;
data.Temperature = temperature;
data.Humidity = humidity;
var content = JsonConvert.SerializeObject(data);
AddLog("Device=" + payload.device + " Telemetry=" + content);
await _client.SendEventAsync(new Message(Encoding.UTF8.GetBytes(content)));
}
// Create a message and send it to IoT Hub.
static async Task SendEvent(DeviceClient deviceClient, Car CurrentCar, VehicleTireReading TireData)
{
try
{
string jsonData = JsonConvert.SerializeObject(TireData);
Microsoft.Azure.Devices.Client.Message eventMessage = new Microsoft.Azure.Devices.Client.Message(Encoding.UTF8.GetBytes(jsonData));
eventMessage.Properties.Add("messagetype", "TLM");
await deviceClient.SendEventAsync(eventMessage);
Console.WriteLine("Sent Data for Vehicle={0};ReadingId={1}", CurrentCar.Id, TireData.ReadingId);
}
catch (Exception ex)
{
Console.WriteLine("An error occured writing to event hub" + ex.ToString());
}
}
static async void SendDeviceToCloudMessagesAsync(DeviceClient deviceClient)
{
var package = $"{{LightLevel: {lightLevel}, Temp: {temp:N3}, Analog: {analog:N2}, X: {x}, Y: {y}, Z: {z} }}";
var sensorPayload = new SensorPayload
{
LightLevel = lightLevel,
Temp = temp,
Analog = analog,
X = x,
Y = y,
Z = z
};
var jsonPackage = JsonConvert.SerializeObject(sensorPayload);
var message = new Message(Encoding.ASCII.GetBytes(jsonPackage));
if(deviceClient != null)
await deviceClient.SendEventAsync(message);
}
public Task SendEventAsync(Message message)
{
_diagnosticProvider.Process(message);
return(_deviceClient.SendEventAsync(message));
}
private static void Init()
{
_deviceId = ConfigurationManager.AppSettings["DeviceId"];
var host = ConfigurationManager.AppSettings["Host"];
var key = ConfigurationManager.AppSettings["Key"];
var connectionString = string.Format("HostName={0}.azure-devices.net;DeviceId={1};SharedAccessKey={2}",
host, _deviceId, key);
_client = DeviceClient.CreateFromConnectionString(connectionString, TransportType.Http1);
var data = new DeviceMetaData();
data.Version = "1.0";
data.IsSimulatedDevice = false;
data.Properties.DeviceID = _deviceId;
data.Properties.FirmwareVersion = "1.42";
data.Properties.HubEnabledState = true;
data.Properties.Processor = "ARM";
data.Properties.Platform = "UWP";
data.Properties.SerialNumber = "1234567890";
data.Properties.InstalledRAM = "1024 MB";
data.Properties.ModelNumber = "007-BOND";
data.Properties.Manufacturer = "Raspberry";
//data.Properties.UpdatedTime = DateTime.UtcNow;
data.Properties.DeviceState = DeviceState.Normal;
data.Commands.Add(new DeviceCommandDefinition("SwitchLight"));
data.Commands.Add(new DeviceCommandDefinition("LightColor",
new DeviceCommandParameterDefinition[] {
new DeviceCommandParameterDefinition("Color", DeviceCommandParameterType.String),
new DeviceCommandParameterDefinition("Color2", DeviceCommandParameterType.String)
}));
data.Commands.Add(new DeviceCommandDefinition("PingDevice"));
data.Commands.Add(new DeviceCommandDefinition("StartTelemetry"));
data.Commands.Add(new DeviceCommandDefinition("StopTelemetry"));
var content = JsonConvert.SerializeObject(data);
_client.SendEventAsync(new Message(Encoding.UTF8.GetBytes(content)));
}