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; }