public SensorReadings ReadSensors()
{
if (_devices == null)
{
_devices = _handler.GetDevices <DS18B20>();
}
var secondsFromLastReading = (DateTime.Now - _previousReadingTime).TotalSeconds;
if (secondsFromLastReading <= _devices.Count() * 2)
{
return(null);
}
_previousReadingTime = DateTime.Now;
var result = new SensorReadings();
result.ReadingTime = _previousReadingTime;
foreach (var device in _devices)
{
var reading = new SensorReading();
reading.SensorId = device.OneWireAddressString;
reading.Reading = device.GetTemperature();
result.Readings.Add(reading);
}
return(result);
}
public List <SensorReading> getSensorReadingsForDayPeriod(Sensor sensor)
{
List <SensorReading> readings = new List <SensorReading>();
string locationName = "";
DateTime currentDateTime = DateTime.Now;
string formated24HourCurrentDateTime = currentDateTime.ToString("yyyy-MM-dd HH:mm:ss");
DateTime previousDayDateTime = currentDateTime.AddHours(-24);
string formated24HourPreviousDayDateTime = previousDayDateTime.ToString("yyyy-MM-dd HH:mm:ss");
if (sensor.Location.Contains(' '))
{
locationName = sensor.Location.Replace(' ', '_');
}
else
{
locationName = sensor.Location;
}
string tableName = "tbl" + locationName + "_" + sensor.Type + "_" + sensor.SensorID.ToString();
DataTable data = readDataFromDB("SELECT * FROM " + tableName + " WHERE ReadingDateTime BETWEEN '" + formated24HourPreviousDayDateTime + "' AND '" + formated24HourCurrentDateTime + "'");
foreach (DataRow item in data.Rows)
{
SensorReading reading = new SensorReading(Convert.ToDateTime(item["ReadingDateTime"]), Convert.ToDecimal(item["ReadingVal"]), 0);
readings.Add(reading);
}
return(readings);
}
public void LogSensorReading(SensorReading Data)
{
Data.RecordedTS = DateTime.Now;
_context.Add(Data);
_context.SaveChanges();
return;
}
private void NewReadingEvent(SensorReading reading)
{
_sensorReadingViewModel.Yaw = String.Format("Yaw: {0}", reading.YawDegrees);
_sensorReadingViewModel.Pitch = String.Format("Pitch: {0}", reading.PitchDegrees);
_sensorReadingViewModel.Roll = String.Format("Roll: {0}", reading.RollDegrees);
_sensorReadingViewModel.Accuracy = String.Format("Accuracy: {0}", reading.Accuracy);
}
/// <summary>
/// Check the battery for either low voltage or low percentage. Either
/// can trigger a low battery alert.
/// </summary>
/// <param name="reading"></param>
/// <param name="settings"></param>
/// <returns></returns>
private static bool DeviceHasLowBattery(SensorReading reading, Settings settings)
{
bool lowBattery = false;
// First check the voltage
if (reading.battery.HasValue)
{
// Check for low battery by voltagee
if (reading.device.type != "HiveHome" && reading.battery > 0.0)
{
lowBattery = reading.battery < settings.lowBatteryThresholdVolts;
}
}
// Now check the percentage.
if (!lowBattery && reading.batteryPercentage.HasValue)
{
// Check for low battery via percentage
if (reading.batteryPercentage < settings.lowBatteryThresholdPercent)
{
lowBattery = true;
}
}
return(lowBattery);
}
public SensorReading Add(SensorReading sensorReading)
{
var res = db.SensorReadings.Add(sensorReading);
db.SaveChanges();
return(res);
}
private void OnWeightReceivedEvent(object sender, SensorReading sensorReading)
{
if (WeightReceived != null)
{
WeightReceived(sender, sensorReading);
}
}
private static async void SendDeviceToCloudMessagesAsync()
{
Random rnd = new Random();
while (true)
{
SensorReading tSensorReading = new SensorReading();
tSensorReading.NurseryId = 1;
tSensorReading.RowId = 222;
tSensorReading.SensorId = 99;
tSensorReading.Strain = "Arduino";
tSensorReading.MinValue = 1;
tSensorReading.MaxValue = 6;
tSensorReading.CurrentValue = Math.Round((rnd.NextDouble() * 8), 1);
tSensorReading.SensorType = "PH";
var messageString = JsonConvert.SerializeObject(tSensorReading);
var message = new Message(Encoding.ASCII.GetBytes(messageString));
await deviceClient.SendEventAsync(message);
Console.WriteLine("{0} > Sending message: {1}", DateTime.Now, messageString);
Task.Delay(3000).Wait();
}
}
public SensorReading ReadMeasuredValue()
{
SensorReading reading = null;
try
{
reading = ReadValues();
ReadException = null;
}
catch (Exception e)
{
ReadException = e;
}
if (CommenceException != null || CompleteException != null || ReadException != null)
{
return(new ErrorReadingSensor
{
CommenceException = CommenceException,
CompleteException = CompleteException,
ReadException = ReadException,
Data = reading
});
}
return(reading);
}
public SensorReading ReadSensorValue()
{
var data = new SensorReading();
lock (lastSensorReading)
{
data.AccelX = lastSensorReading.AccelX;
data.AccelY = lastSensorReading.AccelY;
data.AccelZ = lastSensorReading.AccelZ;
data.GyroX = lastSensorReading.GyroX;
data.GyroY = lastSensorReading.GyroY;
data.GyroZ = lastSensorReading.GyroZ;
data.MagX = lastSensorReading.MagX;
data.MagY = lastSensorReading.MagY;
data.MagZ = lastSensorReading.MagZ;
data.ATemperature = lastSensorReading.ATemperature;
data.OTemperature = lastSensorReading.OTemperature;
data.Pressure = lastSensorReading.Pressure;
data.Humidity = lastSensorReading.Humidity;
data.BatteryLevel = lastSensorReading.BatteryLevel;
data.Lightness = lastSensorReading.Lightness;
data.LeftKey = lastSensorReading.LeftKey;
data.RightKey = lastSensorReading.RightKey;
}
return(data);
}
/// <summary>
/// Transform the specified input.
/// </summary>
/// <returns>The transform.</returns>
/// <param name="input">Input.</param>
public List <SensorReading> Transform(IEnumerable <ICsvWritable> input)
{
var emaAzimuth = new ExponentialMovingAverage();
var emaPitch = new ExponentialMovingAverage();
var emaRoll = new ExponentialMovingAverage();
var emaAccelX = new ExponentialMovingAverage();
var emaAccelY = new ExponentialMovingAverage();
var emaAccelZ = new ExponentialMovingAverage();
var output = new List <SensorReading>();
foreach (SensorReading reading in input)
{
var newReading = new SensorReading(reading);
newReading.SetGyroVector(emaAzimuth.GetAverage(reading.Azimuth),
emaPitch.GetAverage(reading.Pitch),
emaRoll.GetAverage(reading.Roll));
newReading.SetAccelVector(emaAccelX.GetAverage(reading.AccelX),
emaAccelY.GetAverage(reading.AccelY),
emaAccelZ.GetAverage(reading.AccelZ));
output.Add(newReading);
}
return(output);
}
/// <summary>
/// Analyze the specified input and parameters.
/// </summary>
/// <returns>The analyze.</returns>
/// <param name="input">Input.</param>
/// <param name="parameters">Parameters.</param>
public IEnumerable <ICsvWritable> Analyze(IEnumerable <SensorReading> input,
IEnumerable <Parameter> parameters)
{
var results = new List <RetractResult>();
foreach (var param in parameters.Where(x => x.Field.Equals("AccelX")))
{
var threshold = Decimal.Parse(param.GetClauseValue(CommandParameters.Threshold));
var windowSize = Int32.Parse(param.GetClauseValue(CommandParameters.Window));
var windowRecords = new List <SensorReading>();
foreach (var record in input)
{
if (windowRecords.Count < windowSize && record.HasValidAccelVector)
{
LogManager.Debug($"\tCurrent window record count: {windowRecords.Count}" +
$"\n\tAdding new record num: {record.RecordNum}", this);
windowRecords.Add(record);
}
if (windowRecords.Count == windowSize)
{
LogManager.Debug("Window record collection is full", this);
var peaks = new List <SensorReading[]>();
SensorReading peakStart = null;
var aboveThreshold = false;
// check to see if we have one or more peaks along the X axis
foreach (var windowRecord in windowRecords)
{
if (windowRecord.AccelX > threshold)
{
peakStart = windowRecord;
aboveThreshold = true;
}
else
{
if (aboveThreshold && peakStart != null)
{
peaks.Add(new SensorReading[] { peakStart, windowRecord });
}
aboveThreshold = false;
peakStart = null;
}
}
// update match result set
if (peaks.Any())
{
AddMatches(results, peaks);
}
// shift window and try again
var initialWindowRecordCount = windowRecords.Count;
windowRecords.RemoveAt(0);
}
}
}
return(results);
}
/// <summary>
/// Reads all sensor data from the device.
/// </summary>
public virtual Mpu9250SensorReading ReadAll()
{
// Read sensor values
var results = ReadMotion9();
SensorReading.AccelXAxis = results[0];
SensorReading.AccelYAxis = results[1];
SensorReading.AccelZAxis = results[2];
SensorReading.GyroXAxis = results[3];
SensorReading.GyroYAxis = results[4];
SensorReading.GyroZAxis = results[5];
SensorReading.MagXAxis = results[6];
SensorReading.MagYAxis = results[7];
SensorReading.MagZAxis = results[8];
// Update fusion results
if (OperationMode == Mpu9250OperationsMode.Fusion ||
OperationMode == Mpu9250OperationsMode.Fusion2)
{
SensorReading.Update();
}
// Return results
return(SensorReading);
}
/// <summary>
/// Verifies the sensor reading.
/// </summary>
/// <param name="expected">Expected.</param>
/// <param name="actual">Actual.</param>
/// <param name="includeSupportingFields">If set to <c>true</c> include supporting fields.</param>
protected static void VerifySensorReading(SensorReading expected, SensorReading actual, bool includeSupportingFields = false)
{
Assert.AreEqual(expected.Time, actual.Time);
Assert.AreEqual(expected.RecordNum, actual.RecordNum);
Assert.AreEqual(Math.Round(expected.Azimuth, PRECISION),
Math.Round(actual.Azimuth, PRECISION));
Assert.AreEqual(Math.Round(expected.Pitch, PRECISION),
Math.Round(actual.Pitch, PRECISION));
Assert.AreEqual(Math.Round(expected.Roll, PRECISION),
Math.Round(actual.Roll, PRECISION));
Assert.AreEqual(Math.Round(expected.AccelX, PRECISION),
Math.Round(actual.AccelX, PRECISION));
Assert.AreEqual(Math.Round(expected.AccelY, PRECISION),
Math.Round(actual.AccelY, PRECISION));
Assert.AreEqual(Math.Round(expected.AccelZ, PRECISION),
Math.Round(actual.AccelZ, PRECISION));
if (includeSupportingFields)
{
Assert.AreEqual(Math.Round(expected.AccelMag, PRECISION),
Math.Round(actual.AccelMag, PRECISION));
Assert.AreEqual(Math.Round(expected.InstantSpeed, PRECISION),
Math.Round(actual.InstantSpeed, PRECISION));
Assert.AreEqual(expected.Start, actual.Start);
Assert.AreEqual(expected.End, actual.End);
Assert.AreEqual(expected.Label, actual.Label);
}
}
public HttpResponseMessage Post(SensorReading sensorReading)
{
if (!DoesDeviceAlreadyExist(sensorReading.DeviceId))
{
return(Request.CreateResponse <SensorReading>(HttpStatusCode.NotFound, sensorReading));
}
SaveReading(sensorReading);
// Send notification - Flame detected
try
{
var connectionString = ConfigurationManager.AppSettings.Get("ConnectionString");
var queueName = "flamesensorqueue";
var client = QueueClient.CreateFromConnectionString(connectionString, queueName);
var message = new BrokeredMessage("Flame detected!");
client.Send(message);
}
catch (Exception e)
{
Debug.WriteLine(e);
}
return(Request.CreateResponse <SensorReading>(HttpStatusCode.OK, sensorReading));
}
private void ProcessNewSensorReading(Notification notification, SensorReading reading)
{
try
{
Debug.Print("Received new reading from device {0}! {1}={2}", reading.DeviceId, reading.Type, reading.Value);
//Type can be a number of things, for example:
/*
* if (reading.Type.Equals("temp"))
* {
* // for temp, value is a float:
* var temperature = (float)reading.Value;
* processTemperature(deviceId, temperature);
* }
* else if (reading.Type.Equals("geofence_sync"))
* {
* //RTK devices only
* ` Debug.Print("Device {0} has synchronised geofence settings", reading.DeviceId);
* }
* else if (reading.Type.Equals("geofence_log"))
* {
* //RTK devices only
* dynamic data = JObject.Parse(reading.Value.ToString());
* Debug.Print($"Device {reading.DeviceId} had geofence event @ {reading.Timestamp}. ZoneId = {data.zoneId}, type = {data.type}, action taken = {data.action}");
* }
*/
}
catch (Exception e)
{
Debug.Print("Invalid sensor message received: {0}", e.Message);
}
}
/// <summary>
/// Transform the specified input.
/// </summary>
/// <returns>The transform.</returns>
/// <param name="input">Input.</param>
public List <SensorReading> Transform(IEnumerable <ICsvWritable> input)
{
const decimal alpha = 0.8M;
List <SensorReading> output = new List <SensorReading>();
foreach (SensorReading reading in input)
{
decimal xAccel = reading.AccelX,
yAccel = reading.AccelY,
zAccel = reading.AccelZ;
GRAVITY[ACCEL_X] = alpha * GRAVITY[ACCEL_X] + (1 - alpha) * xAccel;
GRAVITY[ACCEL_Y] = alpha * GRAVITY[ACCEL_Y] + (1 - alpha) * yAccel;
GRAVITY[ACCEL_Z] = alpha * GRAVITY[ACCEL_Z] + (1 - alpha) * zAccel;
decimal newAccelX = (xAccel - GRAVITY[ACCEL_X]),
newAccelY = (yAccel - GRAVITY[ACCEL_Y]),
newAccelZ = (zAccel - GRAVITY[ACCEL_Z]);
SensorReading newReading = new SensorReading(reading);
newReading.SetAccelVector(newAccelX, newAccelY, newAccelZ);
output.Add(newReading);
}
return(output);
}
public void TestBasicDataLoad()
{
List <SensorReading> inputRecords =
SensorReading.ReadSensorFile(GetInputFilePath(DefaultInput.Filename));
Assert.AreEqual(DefaultInput.RawInputRecordCount, inputRecords.Count);
}
/// <summary>
/// Queries the data in the sensor tag.
/// </summary>
public ICollection <SensorReading> QueryHiveData(HiveService service, List <SensorDevice> allDevices)
{
List <SensorReading> readings = new List <SensorReading>();
var hiveBattChannel = service.GetHiveChannel(HiveService.ChannelType.battery);
var hiveTempChannel = service.GetHiveChannel(HiveService.ChannelType.temperature);
var fromDate = getDeviceHighWaterMark(hiveTempChannel.UUID);
var toDate = DateTime.UtcNow;
SensorDevice device = new SensorDevice {
uuid = hiveTempChannel.UUID, name = "Hive", type = "HiveHome", location = ""
};
allDevices.Add(device);
Utils.Log("Querying hive {0} data between {1} and {2}...", hiveTempChannel.id, fromDate, toDate);
var values = service.QueryHiveValues(hiveTempChannel, device, fromDate, toDate, settings.refreshPeriodMins);
var battValues = service.QueryHiveValues(hiveBattChannel, device, fromDate, toDate, settings.refreshPeriodMins);
if (values.Any())
{
SensorReading lastReading = null;
foreach (var pair in values)
{
lastReading = new SensorReading
{
timestamp = Utils.getFromEpoch(pair.Key),
temperature = pair.Value,
lux = null,
humidity = null,
device = device
};
if (battValues.ContainsKey(pair.Key))
{
lastReading.battery = battValues[pair.Key];
}
readings.Add(lastReading);
}
if (readings.Any())
{
Utils.Log("Found {0} readings for device '{1}' (latest: {2:dd-MMM-yy HH:mm:ss}).", readings.Count(), device.name, readings.Max(x => x.timestamp));
}
else
{
Utils.Log("No readings found for device {1}.", device.name);
}
// Now query the current battery level, and set it in the most recent reading.
lastReading.batteryPercentage = service.QueryHiveBattery();
}
return(readings);
}
/// <param name='operations'>
/// Reference to the LazySaturdayPi.RaspberryPi.ISensor.
/// </param>
/// <param name='sensorReading'>
/// Required.
/// </param>
public static SensorReading Post(this ISensor operations, SensorReading sensorReading)
{
return(Task.Factory.StartNew((object s) =>
{
return ((ISensor)s).PostAsync(sensorReading);
}
, operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult());
}
private static void SendTelemetry(Teammate teammate)
{
var rowindex = 0;
const double brzrkr = 1.5; // inflate readings to quickly simulate alarm conditions
// initialize the simulation dataset
teammate.DataSet = _simData.GetDataSet(teammate.DataSetName);
// connect to IoT Hub
var auth = AuthenticationMethodFactory.CreateAuthenticationWithRegistrySymmetricKey(teammate.Manifest.SerialNumber, teammate.Manifest.Key.PrimaryKey);
var client = DeviceClient.Create(teammate.Manifest.Hub, auth);
// start a background thread to send telemetry
var simTask = Task.Factory.StartNew(async() =>
{
while (true)
{
var datarow = _simData.GetNextDataRow(teammate.DataSet.rows[rowindex++]);
if (rowindex >= teammate.DataSet.rows.Count)
{
rowindex = 0;
}
var reading = new SensorReading
{
UserId = teammate.Profile.id,
DeviceId = teammate.Manifest.SerialNumber,
Longitude = teammate.Manifest.Longitude,
Latitude = teammate.Manifest.Latitude,
Status = SensorStatus.Normal,
Timestamp = DateTime.Now,
Age = teammate.Profile.healthInformation.age,
Weight = teammate.Profile.healthInformation.weight,
Height = teammate.Profile.healthInformation.height,
BreathingRate = datarow.columns[0].dataValue * brzrkr,
Ventilization = datarow.columns[1].dataValue * brzrkr,
Activity = datarow.columns[2].dataValue * brzrkr,
HeartRateBPM = datarow.columns[3].dataValue * brzrkr,
Cadence = datarow.columns[4].dataValue * brzrkr,
Velocity = datarow.columns[5].dataValue * brzrkr,
Speed = datarow.columns[6].dataValue * brzrkr,
HIB = datarow.columns[7].dataValue * brzrkr,
HeartrateRedZone = datarow.columns[8].dataValue * brzrkr,
HeartrateVariability = datarow.columns[9].dataValue * brzrkr,
Temperature = datarow.columns[10].dataValue * brzrkr
};
var json = JsonConvert.SerializeObject((object)reading);
var message = new Message(Encoding.ASCII.GetBytes(json));
await client.SendEventAsync(message);
System.Threading.Thread.Sleep(System.Convert.ToInt32(teammate.Manifest.Extensions["telemetry"]));
}
});
}
/// <summary>
/// 収集した情報をAzureへ転送する。
/// </summary>
/// <returns></returns>
private async Task SendEvent()
{
List <SensorReadingBuffer> currentReadings = new List <SensorReadingBuffer>();
lock (this)
{
foreach (var r in lastSensorReading)
{
currentReadings.Add(new SensorReadingBuffer()
{
AccelX = r.AccelX,
AccelY = r.AccelY,
AccelZ = r.AccelZ,
Temperature = r.Temperature,
Brightness = r.Brightness,
Timestamp = r.Timestamp
});
}
lastSensorReading.Clear();
}
Debug.WriteLine("Device sending {0} message to IoTHu...\n", currentReadings.Count);
try
{
List <SensorReading> sendingBuffers = new List <SensorReading>();
for (int count = 0; count < currentReadings.Count; count++)
{
var sensorReading = new SensorReading()
{
msgId = _deviceId.ToString() + currentReadings[count].Timestamp.ToString("yyyyMMddHHmmssfff"),
accelx = currentReadings[count].AccelX,
accely = currentReadings[count].AccelY,
accelz = currentReadings[count].AccelZ,
deviceId = _deviceId.ToString(),
temp = currentReadings[count].Temperature,
time = currentReadings[count].Timestamp,
Longitude = ChobiIotConfig.Longitude,
Latitude = ChobiIotConfig.Latitude
};
sendingBuffers.Add(sensorReading);
}
// JSONコンバート
var payload = JsonConvert.SerializeObject(sendingBuffers);
// JSONデータをモバイルサービスへ転送する。
Message eventMessage = new Message(Encoding.UTF8.GetBytes(payload));
Debug.WriteLine("\t{0}> Sending message: {1}, Data: [{2}]", DateTime.Now.ToLocalTime(), currentReadings.Count, payload);
await _deviceClient.SendEventAsync(eventMessage);
tbSendStatus.Text = "Send[" + sendCount++ + "]@" + DateTime.Now.ToString();
IndicateDebug(FEZHAT.Color.Blue, 10);
}
catch (Exception ex)
{
Debug.Write(ex.Message);
IndicateDebug(FEZHAT.Color.Yellow, 3600);
}
}
public SensorReading Add(SensorReading sensorReading)
{
if (sensorReading.Id == Guid.Empty)
{
sensorReading.Id = Guid.NewGuid();
}
return(sensorReading);
}
public SensorReading ReadCurrentValues()
{
var valueLeft = mLeftSensor.Read();
var valueRight = mRightSensor.Read();
return(LastReading = new SensorReading {
LeftValue = valueLeft, RightValue = valueRight
});
}
public SensorReading ToEntity()
{
SensorReading sensorReading = new SensorReading();
sensorReading.SensorId = SensorId;
sensorReading.DateTime = DateTime;
sensorReading.Value = Value;
return(sensorReading);
}
public void Add(SensorReading sensorReading)
{
const string METHOD = "SensorReadingManager.Add(SensorReading)";
if (_sensorReadingValidator.IsValid(sensorReading))
{
_exceptionHandler.RunAction(METHOD,
() => _sensorReadingsRepository.Add(sensorReading));
}
}
public async Task <SensorReading> ReadAsync()
{
var connectionResponse = await _connection.ReadAsync();
return(connectionResponse.IsValid
? SensorReading.Valid("Ok!")
: SensorReading.Error(
connectionResponse.Errors
.Select(e => new ResponseError(e.Message))
.ToArray()));
}
public HttpResponseMessage Post(SensorReading sensorReading)
{
if (!DoesDeviceAlreadyExist(sensorReading.DeviceId))
{
return Request.CreateResponse<SensorReading>(HttpStatusCode.NotFound, sensorReading);
}
SaveReading(sensorReading);
return Request.CreateResponse<SensorReading>(HttpStatusCode.OK, sensorReading);
}
public HttpResponseMessage Post(SensorReading sensorReading)
{
if (!DoesDeviceAlreadyExist(sensorReading.DeviceId))
{
return(Request.CreateResponse <SensorReading>(HttpStatusCode.NotFound, sensorReading));
}
SaveReading(sensorReading);
return(Request.CreateResponse <SensorReading>(HttpStatusCode.OK, sensorReading));
}
/// <summary>
/// Interrupt from the MAG3110 conversion complete interrupt.
/// </summary>
private void DigitalInputPortChanged(object sender, DigitalInputPortEventArgs e)
{
if (OnReadingComplete != null)
{
Read();
var readings = new SensorReading();
readings.X = X;
readings.Y = Y;
readings.Z = Z;
OnReadingComplete(readings);
}
}
private byte[] BuildMessage(SensorReading newSensorReading)
{
return(new double[]
{
0,
0,
0,
newSensorReading.YawDegrees,
newSensorReading.PitchDegrees,
newSensorReading.RollDegrees
}.SelectMany(BitConverter.GetBytes).ToArray());
}
public void Run()
{
InitializeSubscriptionClient();
var entitiesContext = new EntitiesContext();
ITemperatureAggregateService temperatureAggregateService = new TemperatureAggregateService(
new EntityRepository<TemperatureAggregate>(entitiesContext), new EntityRepository<Brew>(entitiesContext));
while (true)
{
Trace.WriteLine("Receiving message...", "Info");
var brokeredMessage = _subscriptionClient.Receive();
if (brokeredMessage != null)
{
Trace.WriteLine("Received message.", "Info");
Trace.WriteLine(
string.Format("Message id: {0} - Message enqueued: {1}", brokeredMessage.MessageId,
brokeredMessage.EnqueuedTimeUtc), "Verbose");
SensorReading sensorReading = null;
// We support two message types: a serialized SensorReading and one that only sends us
// message properties (for netmf support). Let's see what we have...
if (brokeredMessage.Properties.Any() && brokeredMessage.Properties.ContainsKey("SensorId"))
{
sensorReading = new SensorReading
{
SensorId = (string)brokeredMessage.Properties["SensorId"],
When = new DateTime(Convert.ToInt64(brokeredMessage.Properties["When"]), DateTimeKind.Utc),
Value = Convert.ToDouble(brokeredMessage.Properties["Value"], CultureInfo.CreateSpecificCulture("en-US"))
};
if (sensorReading.When.Year > (DateTime.UtcNow.Year + 1) || sensorReading.When.Year < DateTime.UtcNow.Year)
{
sensorReading.When = brokeredMessage.EnqueuedTimeUtc;
}
}
else
{
sensorReading = brokeredMessage.GetBody<SensorReading>();
}
Trace.WriteLine(string.Format("Message id: {0} - Sensor: {1} - Sensor reading: {2}", brokeredMessage.MessageId, sensorReading.SensorId, sensorReading.Value), "Verbose");
Trace.WriteLine("Processing message...", "Info");
temperatureAggregateService.AggregateData(sensorReading.SensorId, sensorReading.When, sensorReading.Value);
brokeredMessage.Complete();
Trace.WriteLine("Processed message.", "Info");
}
}
}
private static async void SendDeviceToCloudMessagesAsync()
{
var random = new Random();
var spin = new ConsoleSpiner();
while (true)
{
spin.Turn();
try
{
var deviceReading = new DeviceMessage();
var index = random.Next(0, _devices.list.Count - 1);
// randomly select a device from the registry
var device = _devices.list[index];
// lookup the participant associated with this device
var participant = _profiles.Find(p => p.id == device.participantid);
// create an IoT Hub client for this device if necessary
if (DeviceClients[index] == null)
{
// connect to the IoT Hub using unique device registration settings (deviceid, devicekey)
var deviceid = device.model + "-" + device.id;
DeviceClients[index] = DeviceClient.Create(
ConfigurationManager.AppSettings["IoTHubUri"],
new DeviceAuthenticationWithRegistrySymmetricKey(deviceid, device.key));
}
// begin to create the simulated device message
deviceReading.deviceid = device.id;
deviceReading.participantid = participant.id;
deviceReading.location.latitude = participant.location.latitude;
deviceReading.location.longitude = participant.location.longitude;
// generate simulated sensor reaings
var glucose = new SensorReading
{
type = SensorType.Glucose,
value = random.Next(70, 210)
};
var heartrate = new SensorReading
{
type = SensorType.Heartrate,
value = random.Next(60, 180)
};
var temperature = new SensorReading
{
type = SensorType.Temperature,
value = random.Next(98, 105) + (.1 * random.Next(0, 9))
};
var bloodoxygen = new SensorReading
{
type = SensorType.Bloodoxygen,
value = random.Next(80, 100)
};
deviceReading.sensors.Add(glucose);
deviceReading.sensors.Add(heartrate);
deviceReading.sensors.Add(temperature);
deviceReading.sensors.Add(bloodoxygen);
deviceReading.reading = DateTime.Now;
// serialize the message to JSON
var json = ModelManager.ModelToJson<DeviceMessage>(deviceReading);
// send the message to EventHub
DeviceClients[index].SendEventAsync(new Message(Encoding.ASCII.GetBytes(json))).Wait();
}
catch (Exception exception)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("{0} > Exception: {1}", DateTime.Now, exception.Message);
Console.ResetColor();
}
Thread.Sleep(1000);
}
}
private async void OnTemperatureChangedEvent(TemperatureChangedEventArgs e)
{
try
{
// ***
// *** Send the start event
// ***
this.EventAggregator.GetEvent<Events.TelemetryStatusChangedEvent>().Publish(new TelemetryStatusChangedEventArgs()
{
Status = TelemetryChangedStatus.Sending,
TotalSent = _totalSent,
TotalFailed = _totalFailed
});
// ***
// *** Only send telemetry events when the source is Device
// ***
if (e.SensorReading.Source == ApplicationSensorReadingSource.Device)
{
SensorReading sensorReading = new SensorReading()
{
Source = 1,
TimestampUtc = e.SensorReading.TimestampUtc,
Temperature = e.SensorReading.Temperature,
IsCritical = e.SensorReading.IsCritical ? 1 : 0,
IsAboveUpperThreshold = e.SensorReading.IsAboveUpperThreshold ? 1 : 0,
IsBelowLowerThreshold = e.SensorReading.IsBelowLowerThreshold ? 1 : 0
};
if (await AzureServiceBusHub.SendData(this.HubConfiguration, sensorReading))
{
// ***
// *** Increment the counter
// ***
_totalSent++;
}
else
{
// ***
// *** Increment the failed counter
// ***
_totalFailed++;
}
}
}
catch (Exception ex)
{
// ***
// *** Increment the failed counter
// ***
_totalFailed++;
this.EventAggregator.GetEvent<Events.DebugEvent>().Publish(new DebugEventArgs(ex));
}
finally
{
// ***
// *** Send the completed event
// ***
this.EventAggregator.GetEvent<Events.TelemetryStatusChangedEvent>().Publish(new TelemetryStatusChangedEventArgs()
{
Status = TelemetryChangedStatus.Completed,
TotalSent = _totalSent,
TotalFailed = _totalFailed
});
}
}
private bool SaveReading(SensorReading sensorReading)
{
// todo: implement
return true;
}
public SensorReading ReadSensorValue()
{
var data = new SensorReading();
lock (lastSensorReading)
{
data.AccelX = lastSensorReading.AccelX;
data.AccelY = lastSensorReading.AccelY;
data.AccelZ = lastSensorReading.AccelZ;
data.ATemperature = lastSensorReading.ATemperature;
data.OTemperature = lastSensorReading.OTemperature;
data.Pressure = lastSensorReading.Pressure;
data.Humidity = lastSensorReading.Humidity;
data.LeftKey = lastSensorReading.LeftKey;
data.RightKey = lastSensorReading.RightKey;
}
return data;
}
protected BLETISensor()
{
lastSensorReading = new SensorReading();
}
public static void InsertSensorData(String computerComponentId, String sensorID, int sensorTypeID, double value)
{
ThreadPool.QueueUserWorkItem(AggregateHistoricalData, null);
lock (s_lockObject)
{
Int64 componentSensorId = -1;
using (SQLiteCommand command = new SQLiteCommand(s_dataManager._sqliteConnection))
{
command.CommandText = "SELECT ComponentSensorID FROM ComponentSensor WHERE ComputerComponentID = @computerComponentId AND SensorID = @sensorId AND SensorTypeID = @sensorTypeId AND ComputerID = @computerID";
command.Parameters.Add(new SQLiteParameter("@computerComponentId", computerComponentId));
command.Parameters.Add(new SQLiteParameter("@sensorId", sensorID));
command.Parameters.Add(new SQLiteParameter("@sensorTypeId", sensorTypeID));
command.Parameters.Add(new SQLiteParameter("@computerID", GetComputerId(GetMacAddress)));
SQLiteDataReader reader= command.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
componentSensorId = Convert.ToInt64(reader["ComponentSensorID"]);
}
else
return;
}
const string c_insertSensorData = "INSERT INTO SensorData (ComponentSensorID, Date, Value) values (@componentSensorId, @date, @Value)";
DateTime currentTime = DateTime.UtcNow;
using (SQLiteCommand sqlInsertCommand = new SQLiteCommand(s_dataManager._sqliteConnection))
{
sqlInsertCommand.CommandText = c_insertSensorData;
sqlInsertCommand.Parameters.Add(new SQLiteParameter("@componentSensorId", componentSensorId));
sqlInsertCommand.Parameters.Add(new SQLiteParameter("@date", currentTime));
sqlInsertCommand.Parameters.Add(new SQLiteParameter("@Value", value));
sqlInsertCommand.ExecuteNonQuery();
}
if (sensorTypeID == (long)SensorType.Temperature)
{
lock (LastSamples)
{
Dictionary<long, Threshold> thresholds = Thresholds;
Threshold threshold;
if (thresholds.TryGetValue(componentSensorId, out threshold))
{
SensorReadingContainer readingContainer;
if (!LastSamples.TryGetValue(componentSensorId, out readingContainer))
{
readingContainer = new SensorReadingContainer();
LastSamples[componentSensorId] = readingContainer;
}
// Remove old readings
while (readingContainer.Readings.First != null &&
readingContainer.Readings.First.Value.SampleTime < currentTime.AddSeconds(-60))
{
SensorReading currentReading = readingContainer.Readings.First.Value;
readingContainer.Readings.RemoveFirst();
if (//currentReading.Sum < threshold.LowerThreshold ||
currentReading.Sum > threshold.UpperThreshold)
{
readingContainer.CountOutsideRange--;
}
readingContainer.Sum -= currentReading.Sum;
}
SensorReading lastReading = new SensorReading();
lastReading.SumOfSquares = value * value;
lastReading.Sum = value;
lastReading.SampleTime = currentTime;
lastReading.Count = 1;
if (lastReading.Sum > threshold.UpperThreshold /*||
lastReading.Sum < threshold.LowerThreshold*/)
{
readingContainer.CountOutsideRange++;
if (readingContainer.CountOutsideRange > 30)
{
readingContainer.WarnUntilTime = currentTime.AddMinutes(5);
if (!FlaggedWarnings.Contains(componentSensorId))
{
readingContainer.EmailSent = false;
FlaggedWarnings.Add(componentSensorId);
// This will trigger an email being sent if necessary
GetAlerts();
}
}
}
readingContainer.Sum += lastReading.Sum;
readingContainer.Readings.AddLast(lastReading);
}
}
}
}
}
static void Main(string[] args)
{
Console.WriteLine("************************************************************");
Console.WriteLine("* B I O M A X S E N S O R E V E N T G E N E R A T O R *");
Console.WriteLine("************************************************************");
Console.WriteLine();
Console.WriteLine("Press Enter to start the generator.");
Console.WriteLine("Press Ctrl-C to stop the generator.");
Console.WriteLine();
Console.ReadLine();
Console.Write("Working....");
_configM = new ConfigM();
_registryM = new DeviceM();
_profilesM = new ProfileM();
// the endpoiont for ConfigM is defined in the app config
_configM.ApiUrl = ConfigurationManager.AppSettings["ConfigM"];
var deviceManifest = _configM.GetByName("DeviceM");
var profileManifest = _configM.GetByName("ProfileM");
_registryM.ApiUrl = deviceManifest.lineitems[LineitemsKey.AdminAPI];
_profilesM.ApiUrl = profileManifest.lineitems[LineitemsKey.PublicAPI];
// get the device registry from the device microservice
_devices = _registryM.GetAll();
// get all the participants in the study
_profiles = _profilesM.GetAllByType("Participant");
var random = new Random();
var spin = new ConsoleSpiner();
// connect to Event Hub
var servicebus = ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"];
var eventhub = ConfigurationManager.AppSettings["EventHub"];
var eventHubClient = EventHubClient.CreateFromConnectionString(servicebus, eventhub);
while (true)
{
spin.Turn();
try
{
var deviceReading = new DeviceMessage();
var index = random.Next(0, _devices.list.Count - 1);
// randomly select a device from the registry
var device = _devices.list[index];
// lookup the participant
var participant = _profiles.Find(p => p.id == device.participantid);
// beging to create the simulated device message
deviceReading.deviceid = device.id;
deviceReading.participantid = participant.id;
deviceReading.location.latitude = participant.location.latitude;
deviceReading.location.longitude = participant.location.longitude;
// generate simulated sensor reaings
var glucose = new SensorReading
{
type = SensorType.Glucose,
value = random.Next(70, 210)
};
var heartrate = new SensorReading
{
type = SensorType.Heartrate,
value = random.Next(60, 180)
};
var temperature = new SensorReading
{
type = SensorType.Temperature,
value = random.Next(98, 105) + (.1 * random.Next(0, 9))
};
var bloodoxygen = new SensorReading
{
type = SensorType.Bloodoxygen,
value = random.Next(80, 100)
};
deviceReading.sensors.Add(glucose);
deviceReading.sensors.Add(heartrate);
deviceReading.sensors.Add(temperature);
deviceReading.sensors.Add(bloodoxygen);
deviceReading.reading = DateTime.Now;
// serialize the message to JSON
var json = ModelManager.ModelToJson<DeviceMessage>(deviceReading);
// use these lines to gen JSON files for SA test input
//var filename = AppDomain.CurrentDomain.BaseDirectory + @"\data\device-" + DateTime.Now.Ticks + ".json";
//System.IO.File.WriteAllText(filename, json);
// send the message to EventHub
eventHubClient.SendAsync(new EventData(Encoding.UTF8.GetBytes(json)));
}
catch (Exception exception)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("{0} > Exception: {1}", DateTime.Now, exception.Message);
Console.ResetColor();
}
Thread.Sleep(200);
}
}
public static void AggregateHistoricalData(object unused)
{
DateTime currentTime = DateTime.UtcNow;
// We'll check the hour aggregation, since the day aggregation can only be triggered when the hour one is also triggered
if (s_lastHourAggregation < (currentTime.AddHours(-1)))
{
lock (s_lockObject)
{
if (s_lastHourAggregation < (currentTime.AddHours(-1)))
{
DateTime hourFloorTime = RoundDownToHour(currentTime);
const string c_selectSensorData = "SELECT ComponentSensorID,Date,Value FROM SensorData WHERE Date < @minTime ORDER BY ComponentSensorID ASC, Date ASC";
using (SQLiteCommand sqlSelectCommand = new SQLiteCommand(s_dataManager._sqliteConnection))
{
sqlSelectCommand.CommandText = c_selectSensorData;
sqlSelectCommand.Parameters.Add(new SQLiteParameter("@minTime", hourFloorTime.AddHours(-1)));
using (SQLiteDataReader reader = sqlSelectCommand.ExecuteReader())
{
long currentComponentSensorId = -1;
DateTime currentHourCutoff = DateTime.MinValue;
DateTime currentHour = DateTime.MinValue;
double sum = 0;
double max = 0;
double min = 0;
double sumOfSquares = 0;
long count = 0;
while (reader.Read())
{
long componentSensorId = Convert.ToInt64(reader["ComponentSensorID"]);
DateTime measureTime = Convert.ToDateTime(reader["Date"]);
double measure = Convert.ToDouble(reader["Value"]);
if (currentComponentSensorId != componentSensorId ||
measureTime > currentHourCutoff)
{
// We don't want to save anything back if we're setting up
if (currentComponentSensorId != -1)
{
InsertHistoricalData(currentComponentSensorId,
currentHour,
DateRangeType.hour,
count,
sum,
sumOfSquares,
min,
max);
}
// Reset our aggregation
currentComponentSensorId = componentSensorId;
currentHour = RoundDownToHour(measureTime);
currentHourCutoff = currentHour.AddHours(1);
max = measure;
min = measure;
count = 0;
sum = 0;
sumOfSquares = 0;
}
max = Math.Max(max, measure);
min = Math.Min(min, measure);
count++;
sum += measure;
sumOfSquares += (measure * measure);
}
// Save the last set of measures. We don't want to save anything back if we're setting up
if (currentComponentSensorId != -1)
{
InsertHistoricalData(currentComponentSensorId,
currentHour,
DateRangeType.hour,
count,
sum,
sumOfSquares,
min,
max);
}
}
}
const string c_deleteSensorData = "DELETE FROM SensorData WHERE Date < @minTime";
using (SQLiteCommand sqlDeleteCommand = new SQLiteCommand(s_dataManager._sqliteConnection))
{
sqlDeleteCommand.CommandText = c_deleteSensorData;
// Always make sure we have one full hour of full resolution
sqlDeleteCommand.Parameters.Add(new SQLiteParameter("@minTime", hourFloorTime.AddHours(-1)));
sqlDeleteCommand.ExecuteNonQuery();
}
s_lastHourAggregation = hourFloorTime;
}
if (s_lastDayAggregation < (currentTime.AddDays(-1)))
{
DateTime dayFloorTime = RoundDownToDay(currentTime);
const string c_selecttHistoricalData = "SELECT ComponentSensorID,Date,Count,Sum,SumOfSquares,Min,Max FROM HistoricalAggregation WHERE Date < @date AND DateRange = @dateRange ORDER BY ComponentSensorID ASC, Date ASC";
// If the row already exists, we need to add the data together
using (SQLiteCommand sqlSelectCommand = new SQLiteCommand(s_dataManager._sqliteConnection))
{
sqlSelectCommand.CommandText = c_selecttHistoricalData;
sqlSelectCommand.Parameters.Add(new SQLiteParameter("@date", dayFloorTime.AddDays(-1)));
sqlSelectCommand.Parameters.Add(new SQLiteParameter("@dateRange", DateRangeType.hour));
using (SQLiteDataReader reader = sqlSelectCommand.ExecuteReader())
{
long currentComponentSensorId = -1;
DateTime currentDayCutoff = DateTime.MinValue;
DateTime currentDay = DateTime.MinValue;
double sum = 0;
double max = 0;
double min = 0;
double sumOfSquares = 0;
long count = 0;
while (reader.Read())
{
long componentSensorId = Convert.ToInt64(reader["ComponentSensorID"]);
DateTime measureTime = Convert.ToDateTime(reader["Date"]);
if (currentComponentSensorId != componentSensorId ||
measureTime > currentDayCutoff)
{
// We don't want to save anything back if we're setting up
if (currentComponentSensorId != -1)
{
InsertHistoricalData(currentComponentSensorId,
currentDay,
DateRangeType.day,
count,
sum,
sumOfSquares,
min,
max);
}
// Reset our aggregation
currentComponentSensorId = componentSensorId;
currentDay = RoundDownToDay(measureTime);
currentDayCutoff = currentDay.AddHours(1);
max = Convert.ToDouble(reader["Max"]);
min = Convert.ToDouble(reader["Min"]);
count = 0;
sum = 0;
sumOfSquares = 0;
}
count += Convert.ToInt64(reader["Count"]);
sum += Convert.ToDouble(reader["Sum"]);
sumOfSquares += Convert.ToDouble(reader["SumOfSquares"]);
double tempMin = Convert.ToDouble(reader["Min"]);
min = Math.Min(min, tempMin);
double tempMax = Convert.ToDouble(reader["Max"]);
max = Math.Max(max, tempMax);
}
// Save the last set of measures. We don't want to save anything back if we're setting up
if (currentComponentSensorId != -1)
{
InsertHistoricalData(currentComponentSensorId,
currentDay,
DateRangeType.day,
count,
sum,
sumOfSquares,
min,
max);
}
}
}
List<AggregateContainer> dataToSendToServer = new List<AggregateContainer>();
DateTime lastWatermark = DateTime.MinValue;
// NOTE: SQL does not support "TOP 1", so we'll just read one
const string c_selecttWatermark = "SELECT Date FROM Watermarks WHERE WatermarkId = @watermarkId ORDER BY Date DESC";
// If the row already exists, we need to add the data together
using (SQLiteCommand sqlSelectCommand = new SQLiteCommand(s_dataManager._sqliteConnection))
{
sqlSelectCommand.CommandText = c_selecttWatermark;
sqlSelectCommand.Parameters.Add(new SQLiteParameter("@watermarkId", "ServerWatermark"));
using (SQLiteDataReader reader = sqlSelectCommand.ExecuteReader())
{
if (reader.Read())
{
lastWatermark = Convert.ToDateTime(reader["Date"]);
// Go ahead and add one day so we don't resend data
lastWatermark = lastWatermark.AddDays(1);
}
}
}
const string c_selecttHistoricalData1 =
@"SELECT ha.ComponentSensorId,Name,Type,SensorTypeId,Date,Count,Sum,SumOfSquares,Min,Max
FROM HistoricalAggregation ha
JOIN ComponentSensor cs
ON cs.ComponentSensorId = ha.ComponentSensorId
JOIN ComputerComponent cc
ON cs.ComputerComponentId = cc.ComputerComponentId
JOIN Component ct
ON ct.ComponentId = cc.ComponentId
WHERE Date <= @maxDate
AND DateRange = @dateRange
ORDER BY Date ASC";
Dictionary<long, SensorReading> readings = new Dictionary<long, SensorReading>();
// If the row already exists, we need to add the data together
using (SQLiteCommand sqlSelectCommand = new SQLiteCommand(s_dataManager._sqliteConnection))
{
sqlSelectCommand.CommandText = c_selecttHistoricalData1;
sqlSelectCommand.Parameters.Add(new SQLiteParameter("@maxDate", dayFloorTime.AddDays(-1)));
sqlSelectCommand.Parameters.Add(new SQLiteParameter("@dateRange", DateRangeType.day));
using (SQLiteDataReader reader = sqlSelectCommand.ExecuteReader())
{
while (reader.Read())
{
AggregateContainer container = new AggregateContainer();
long componentSensorId = Convert.ToInt64(reader["ComponentSensorId"]);
long sensorType = Convert.ToInt64(reader["SensorTypeId"]);
container.SensorType = (SensorType)sensorType;
container.Name = Convert.ToString(reader["Name"]);
container.Type = Convert.ToString(reader["Type"]);
container.CurrentDay = Convert.ToDateTime(reader["Date"]);
container.Count = Convert.ToInt64(reader["Count"]);
container.Sum = Convert.ToDouble(reader["Sum"]);
container.SumOfSquares = Convert.ToDouble(reader["SumOfSquares"]);
container.Min = Convert.ToDouble(reader["Min"]);
container.Max = Convert.ToDouble(reader["Max"]);
SensorReading sensorReading;
if (!readings.TryGetValue(componentSensorId, out sensorReading))
{
sensorReading = new SensorReading();
readings[componentSensorId] = sensorReading;
}
sensorReading.Count += container.Count;
sensorReading.Sum += container.Sum;
sensorReading.SumOfSquares += container.SumOfSquares;
if (container.CurrentDay > lastWatermark)
{
dataToSendToServer.Add(container);
}
}
}
}
Dictionary<long, Threshold> thresholds = new Dictionary<long, Threshold>();
foreach (long key in readings.Keys)
{
SensorReading reading = readings[key];
double average = (double)reading.Sum / reading.Count;
double stddev = Math.Sqrt((reading.SumOfSquares / reading.Count) - (average * average));
Threshold threshold = new Threshold();
threshold.LowerThreshold = ThresholdMultiplier*(average - stddev);
threshold.UpperThreshold = ThresholdMultiplier*(average + stddev);
thresholds[key] = threshold;
}
// Atomically replace
Thresholds = thresholds;
bool sendToServerSuccess = s_httpClient.SendToServer(dataToSendToServer);
if (sendToServerSuccess)
{
List<DataManager.ComponentSensorTypesContainer> componentSensorList = GetComponentSensorList();
AggregatedData = s_httpClient.GetAggregatedStats(componentSensorList);
if (lastWatermark > DateTime.MinValue)
{
const string c_insertNewWatermark = "UPDATE Watermarks SET Date = @date WHERE WatermarkId = @watermarkId";
using (SQLiteCommand command = new SQLiteCommand(s_dataManager._sqliteConnection))
{
command.CommandText = c_insertNewWatermark;
command.Parameters.Add(new SQLiteParameter("@watermarkId", "ServerWatermark"));
command.Parameters.Add(new SQLiteParameter("@date", dayFloorTime.AddDays(-1)));
command.ExecuteNonQuery();
}
}
else
{
const string c_insertNewWatermark = "INSERT INTO Watermarks (WatermarkId,Date) values (@watermarkId,@date)";
using (SQLiteCommand command = new SQLiteCommand(s_dataManager._sqliteConnection))
{
command.CommandText = c_insertNewWatermark;
command.Parameters.Add(new SQLiteParameter("@watermarkId", "ServerWatermark"));
command.Parameters.Add(new SQLiteParameter("@date", dayFloorTime.AddDays(-1)));
command.ExecuteNonQuery();
}
}
}
const string c_deleteSensorData = "DELETE FROM HistoricalAggregation WHERE Date < @date AND DateRange = @dateRange";
using (SQLiteCommand sqlDeleteCommand = new SQLiteCommand(s_dataManager._sqliteConnection))
{
sqlDeleteCommand.CommandText = c_deleteSensorData;
// Always make sure we have one full day of hour resolution
sqlDeleteCommand.Parameters.Add(new SQLiteParameter("@date", dayFloorTime.AddDays(-1)));
sqlDeleteCommand.Parameters.Add(new SQLiteParameter("@dateRange", DateRangeType.hour));
sqlDeleteCommand.ExecuteNonQuery();
}
s_lastDayAggregation = dayFloorTime;
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="dataType"></param>
/// <param name="value"></param>
private void setReading(HaDevice device, OWMDataTypes dataType, double value, string label)
{
if (device.sensorReadings == null)
{
device.sensorReadings = new List<SensorReading>();
}
var reading = device.sensorReadings.Where(r => r.name == dataType.ToString()).FirstOrDefault();
if (reading == null)
{
reading = new SensorReading();
device.sensorReadings.Add(reading);
}
reading.value = value;
reading.name = dataType.ToString();
reading.label = label;
}
public SensorUpdate(string id, SensorReading[] readings)
{
Id = id;
Readings = readings;
}
