public async Task SendMessage()
{
do
{
int deviceCount = 1;
int requestCount = 0;
//Console.WriteLine("no of requests = no of devices X request per device (Note: Enter ctrl+cc to exit)");
//Console.WriteLine("no of devices: ");
//int.TryParse(Console.ReadLine(), out deviceCount);
Console.WriteLine("requests per device:");
int.TryParse(Console.ReadLine(), out requestCount);
byte[] recordedBytes = File.ReadAllBytes(filePath);
for (int device = 0; device < deviceCount; device++)
{
for (int i = 0; i < requestCount; i++)
{
var deviceTelemetry = new DeviceTelemetry {
RecordedTime = DateTime.UtcNow, RecordedStream = recordedBytes
};
//await iotHubClient.SendToHub(deviceTelemetry);
await iotHubClient.SendToHubV1(deviceTelemetry, deviceConnectionStrings[device]);
Console.WriteLine($"Message sent to device : {device}");
}
}
} while (Console.ReadLine() != "cc");
////////////////////////
}
static async Task Main(string[] args)
{
var publisher = new Publisher();
publisher.Init(EventHubConnectionStringPublisher, EventHubName);
var numEvents = 100;
var random = new Random(Environment.TickCount);
var eventProcessorHost = new EventProcessorHost(
EventHubName,
"realTime",
EventHubConnectionStringConsumer,
StorageConnectionString,
StorageContainerName);
await eventProcessorHost.RegisterEventProcessorAsync <RealTimeConsumer>();
for (int i = 0; i < numEvents; i++)
{
var randomDeviceTelemetry = DeviceTelemetry.GenerateRandom(random);
await publisher.PublishAsync(randomDeviceTelemetry);
}
Console.ReadKey();
}
public static void Run(
[ServiceBusTrigger("car-telemetry", "storage", AccessRights.Listen, Connection = "ConnectedCarServiceBus")] string rawTelemetryData,
[Table("devicetelemetry", Connection = "ConnectedCarTableStorage")] out DeviceTelemetry deviceData, TraceWriter log)
{
var telemetryData = JsonConvert.DeserializeObject <TelemetryData>(rawTelemetryData);
deviceData = new DeviceTelemetry
{
Humidity = telemetryData.Humidity,
Light = telemetryData.Light,
Motion = telemetryData.Motion,
AirQuality = telemetryData.AirQuality,
Sound = telemetryData.Sound,
Temp = telemetryData.Temp,
Lon = telemetryData.Gps.Lon,
Lat = telemetryData.Gps.Lat,
Speed = telemetryData.Gps.Speed,
Course = telemetryData.Gps.Course,
GpsStatusCode = telemetryData.Gps.GpsStatusCode,
PartitionKey = "636508278883351383",
RowKey = $"{DateTime.MaxValue.Ticks - DateTime.UtcNow.Ticks:D19}"
};
log.Info($"Succesfully proccessed event {rawTelemetryData}");
}
static async Task Main(string[] args)
{
var publisher = new Publisher();
publisher.Init(EventHubConnectionStringPublisher, EventHubName);
var numEvents = 1000;
var random = new Random(Environment.TickCount);
var deviceTelemetry = new DeviceTelemetry
{
DeviceType = DeviceType.Phone,
IpAddress = "127.0.0.1",
IsOn = true,
Time = DateTime.Now
};
var eventProcessorHost = new EventProcessorHost(
EventHubName,
PartitionReceiver.DefaultConsumerGroupName,
EventHubConnectionStringConsumer,
StorageConnectionString,
StorageContainerName);
await eventProcessorHost.RegisterEventProcessorAsync<Consumer>();
for (int i = 0; i < numEvents; i++)
{
var randomDeviceTelemetry = DeviceTelemetry.GenerateRandom(random);
await publisher.PublishAsync(randomDeviceTelemetry);
}
Console.ReadKey();
}
public void TelemetryReceived(DeviceTelemetry telemetry)
{
if (HistoryData == null)
{
HistoryData = new Dictionary <DateTimeOffset, DeviceData>();
}
if (telemetry.Timestamp < DateTimeOffset.Now.Subtract(EntityConfig.HistoryRetention))
{
return;
}
telemetry.Data.Temperature = Math.Round(telemetry.Data.Temperature, 1);
telemetry.Data.Humidity = Math.Round(telemetry.Data.Humidity, 1);
HistoryData[telemetry.Timestamp] = telemetry.Data;
if (LastUpdate < telemetry.Timestamp)
{
LastUpdate = telemetry.Timestamp;
LastData = telemetry.Data;
DeviceName = telemetry.DeviceName;
}
var dataToRemove = HistoryData
.Where(a => a.Key < DateTimeOffset.Now.Subtract(EntityConfig.HistoryRetention));
if (dataToRemove.Any())
{
foreach (var item in dataToRemove)
{
HistoryData.Remove(item.Key);
}
}
}
//Simulate DEVICE feed
public static string SendDevicesToCloudNonAsync(int timeout = -1)
{
DeviceTelemetry deviceDataChunk = new DeviceTelemetry();
while (timeout < 0)
{
outputItems++;
//Arbitrary simulations
deviceDataChunk.setDeviceTelemetry(
rand.NextDouble() * 5 + 15,
rand.NextDouble() * 5,
Math.Round(rand.NextDouble() * 25000),
Math.Round(rand.NextDouble() * 15000),
rand.NextDouble() * 0.015
);
// Create JSON message
var messageStringFromNestedClass = JsonConvert.SerializeObject(deviceDataChunk, Formatting.Indented);
Console.WriteLine("{0} > Sending message: {1}", DateTime.Now, messageStringFromNestedClass);
//Insert(Upsert) into database
if (couchbaseConnectionInitialised)
{
Console.WriteLine("Upsert: {0}", UpsertNoSQL(deviceDataChunk.dID.ToString(), deviceDataChunk));
}
//Just some fancy screen stuff
//if (outputItems % 10 == 0)
// Console.Clear();
//This was for async version
//await Task.Delay(1000);
// Sleep for x seconds
System.Threading.Thread.Sleep(SimulationSpeed);
}
return(JsonConvert.SerializeObject(deviceDataChunk, Formatting.Indented));
}
private static async Task SendDeviceToCloudMessagesAsync(DeviceConfiguration device, CancellationToken ct)
{
DeviceClient deviceClient = null;
if (!string.IsNullOrWhiteSpace(device.ConnectionString))
{
var cs = IotHubConnectionStringBuilder.Create(device.ConnectionString);
deviceClient = DeviceClient.CreateFromConnectionString(cs.ToString(), TransportType.Mqtt);
}
var temperatureGenerator = TelemetryGeneratorFactory.Create(device.TemperatureGenerator);
var humidityGenerator = TelemetryGeneratorFactory.Create(device.HumidityGenerator);
var startupDelay = rand.Next(0, 10000);
await Task.Delay(startupDelay, ct);
while (!ct.IsCancellationRequested)
{
var telemetry = new DeviceTelemetry()
{
DeviceId = device.Id,
DeviceName = device.Name,
Timestamp = DateTimeOffset.Now,
Data = new DeviceData()
{
Humidity = await humidityGenerator.GenerateNextValueAsync(ct),
Temperature = await temperatureGenerator.GenerateNextValueAsync(ct)
}
};
string messageBody = JsonSerializer.Serialize(telemetry);
using var message = new Message(Encoding.ASCII.GetBytes(messageBody))
{
ContentType = "application/json",
ContentEncoding = "utf-8",
};
// Send the telemetry message (if the connectionstring for device is configured)
if (deviceClient != null)
{
await deviceClient.SendEventAsync(message);
}
Console.WriteLine($"{DateTime.Now} > Sending message: {messageBody}");
try
{
await Task.Delay(device.PollingIntervalInSec * 1000, ct);
}
catch (TaskCanceledException)
{
break;
}
}
if (deviceClient != null)
{
deviceClient.Dispose();
}
}
private void SendToIotHub(DateTime recordingTime, StorageFile audioFile)
{
var deviceTelemetry = new DeviceTelemetry { /*RecordedTime = recordingTime,*/
RecordedStream = GetBytesAsync(audioFile).Result
};
iotHubClient.SendToHub(deviceTelemetry).GetAwaiter().GetResult();
}
private async Task TelemetryReceived(DeviceTelemetry telemetry)
{
//query device with serial number
var device = _deviceRepository.AsQueryable().FirstOrDefault(q => q.SerialNumber == telemetry.SerialNumber);
//check if device is known
if (device == null)
{
Console.WriteLine($"WARN: Received telemetry for unknown device: {telemetry.SerialNumber}");
return;
}
//check if this telemetry is first entry for the device
if (!device.LastKnownLatitue.HasValue || !device.LastKnownLongitude.HasValue)
{
device.LastKnownLongitude = telemetry.Longitude;
device.LastKnownLatitue = telemetry.Latitude;
device.LastContact = telemetry.DeviceDate;
//this is first telemetry so we can not calculate speed for the device
await _deviceRepository.UpdateAsync(device);
return;
}
//calculate distance in meters
var distance = Math.Round(new Coordinates(device.LastKnownLatitue.Value, device.LastKnownLongitude.Value)
.DistanceTo(
new Coordinates(telemetry.Latitude, telemetry.Longitude),
UnitOfLength.Meter
), 2);
//calculate speed meters per hour
double speed = 0;
if (distance > 0)
{
speed = Math.Round(
GeolocationDistanceCalculator.SpeedAsMeterPerHour(distance, telemetry.DeviceDate,
device.LastContact.Value), 2);
}
//set last known speed for the device
device.LastKnownSpeed = speed;
//check device behaviour
device.State = distance <= DeviceConstants.MoveAlertInMeters
? DeviceState.OperatingAbnormally
: DeviceState.OperatingNormally;
device.LastContact = telemetry.DeviceDate;
//update device
await _deviceRepository.UpdateAsync(device);
}
public void FindByIdAsync()
{
var telemetry = new DeviceTelemetry()
{
Id = Guid.NewGuid(),
CreatedAt = DateTime.UtcNow,
DeviceDate = DateTime.UtcNow,
LastModifiedAt = DateTime.UtcNow
};
_repo.AddAsync(telemetry);
var result = _repo.FindByIdAsync(telemetry.Id).GetAwaiter().GetResult();
Assert.AreEqual(result, telemetry);
}
public void AsQueryable()
{
var telemetry = new DeviceTelemetry()
{
Id = Guid.NewGuid(),
CreatedAt = DateTime.UtcNow,
DeviceDate = DateTime.UtcNow,
LastModifiedAt = DateTime.UtcNow
};
_repo.AddAsync(telemetry);
var fromRepo = _repo.AsQueryable().FirstOrDefault(q => q.Id == telemetry.Id);
Assert.AreEqual(fromRepo, telemetry);
}
internal async Task SendToHub(DeviceTelemetry deviceTelemetry)
{
try
{
using (DeviceClient deviceClient = DeviceClient.CreateFromConnectionString(deviceConnectionString, transportType))
{
//await deviceClient.OpenAsync();
//await UpdateTwin(deviceClient);
await SendTelemetry(deviceClient, deviceTelemetry);
}
}
catch (Exception)
{
loggingChannel.LogMessage("Exception occured while creating device client", LoggingLevel.Error);
}
}
private DeviceTelemetry GetDeviceTelemetry()
{
var temp = _senseHat.Sensors.Temperature.Value;
var hum = _senseHat.Sensors.Humidity.Value;
var press = _senseHat.Sensors.Pressure.Value;
var telemetry = new DeviceTelemetry()
{
DeviceId = deviceId,
TimeStamp = DateTime.UtcNow,
Temperature = temp,
Humidity = hum,
Pressure = press
};
return(telemetry);
}
public async Task <bool> SendTelemetryToDeviceAsync(DeviceTelemetry telemetry, CancellationToken cancellationToken)
{
if (telemetry == null)
{
throw new ArgumentNullException(nameof(telemetry));
}
var uri = this.CreateAPIUri();
string telemetryJson = JsonConvert.SerializeObject(telemetry, Formatting.None);
var postContent = new StringContent(telemetryJson, Encoding.UTF8, "application/json");
var response = await this._httpClient.PostAsync(uri, postContent, cancellationToken);
return(response.IsSuccessStatusCode);
}
public async Task PostTelemetryAsync(DeviceTelemetry deviceTelemetry)
{
if (_iotHubClient != null)
{
var payload = JsonConvert.SerializeObject(deviceTelemetry);
try
{
await _iotHubClient.SendEventAsync(new Message(Encoding.UTF8.GetBytes(payload)));
Debug.WriteLine(payload);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
}
private static async Task SaveTelemetryToTableStorage(DeviceTelemetry deviceTelemetry)
{
string storageConnectionString = "<storageConnectionString>";
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(storageConnectionString);
CloudTableClient cloudTableClient = storageAccount.CreateCloudTableClient();
var table = cloudTableClient.GetTableReference("deviceTelemetry");
await table.CreateIfNotExistsAsync();
var deviceTelemetryEntity = new DeviceTelemetryEntity(deviceTelemetry.IpAddress, deviceTelemetry.Time, deviceTelemetry.DeviceType, deviceTelemetry.IsOn);
TableOperation insertOperation = TableOperation.Insert(deviceTelemetryEntity);
await table.ExecuteAsync(insertOperation);
}
public async Task <HttpResponseMessage> PostTelemetryAsync(DeviceTelemetry deviceTelemetry)
{
var postContent = new HttpStringContent(JsonConvert.SerializeObject(deviceTelemetry),
Windows.Storage.Streams.UnicodeEncoding.Utf8, "application/json");
//Microsoft.ApplicationInsights.TelemetryClient client = new Microsoft.ApplicationInsights.TelemetryClient();
//client.TrackEvent(new EventTelemetry { Name = "Event Hub Post" });
HttpResponseMessage resp = null;
try
{
resp = await _httpClient.PostAsync(_postUri, postContent);
}
catch (Exception ex)
{
//client.TrackException(new ExceptionTelemetry { Exception = ex });
}
return(resp);
}
private static void SaveTelemetryToSqlDatabase(DeviceTelemetry deviceTelemetry, string sqlDatabaseConnectionString)
{
using (var connection = new SqlConnection(sqlDatabaseConnectionString))
{
connection.Open();
const string sqlCommandText =
"insert into DeviceTelemetry(IPAdresses,Time,DeviceType,IsOn) values (@IPAdresses,@Time,@DeviceType,@IsOn);";
using (var command = new SqlCommand(sqlCommandText, connection))
{
command.Parameters.AddWithValue("@IPAdresses", deviceTelemetry.IpAddress);
command.Parameters.AddWithValue("@Time", deviceTelemetry.Time);
command.Parameters.AddWithValue("@DeviceType", deviceTelemetry.DeviceType);
command.Parameters.AddWithValue("@IsOn", deviceTelemetry.IsOn);
Console.WriteLine($"Added Device IP {deviceTelemetry.IpAddress} to the database.");
command.ExecuteNonQuery();
}
}
}
private static void Main(string[] args)
{
var publisher = new Publisher();
publisher.Init(
"");
var random = new Random(Environment.TickCount);
const int numEvents = 1000;
Console.ForegroundColor = ConsoleColor.Green;
for (var i = 0; i < numEvents; i++)
{
var deviceTelemetry = DeviceTelemetry.GenerateRandom(random);
publisher.Publish(deviceTelemetry);
Console.Clear();
Console.WriteLine($"Published {i + 1} events...");
}
Console.ReadLine();
}
public void TelemetryReceived(DeviceTelemetry telemetry)
{
if (HistoryData == null)
{
HistoryData = new Dictionary <DateTimeOffset, DeviceData>();
}
if (telemetry.Timestamp < DateTimeOffset.Now.Subtract(EntityConfig.HistoryRetention))
{
return;
}
HistoryData[telemetry.Timestamp] = telemetry.Data;
if (LastUpdate < telemetry.Timestamp)
{
LastUpdate = telemetry.Timestamp;
LastData = telemetry.Data;
DeviceName = telemetry.DeviceName;
}
ClearHistoryData();
CheckAlert();
}
private static async Task SendTelemetry(DeviceClient deviceClient, DeviceTelemetry deviceTelemetry)
{
var payload = JsonConvert.SerializeObject(deviceTelemetry);
var message = new Message(Encoding.ASCII.GetBytes(payload));
await deviceClient.SendEventAsync(message);
}
