private async void HeartRate_ReadingChanged(object sender, BandSensorReadingEventArgs <IBandHeartRateReading> e)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
PerformHealthCheck(e.SensorReading.HeartRate);
}).AsTask();
}
private void HeartRate_ReadingChanged(object sender, BandSensorReadingEventArgs <IBandHeartRateReading> e)
{
IBandHeartRateReading heartRateRead = e.SensorReading;
data.heartRate = heartRateRead.HeartRate;
HeartRateLocked = heartRateRead.Quality;
}
private async void HeartRate_ReadingChanged(object sender, BandSensorReadingEventArgs <IBandHeartRateReading> e)
{
if (e.SensorReading.Quality == HeartRateQuality.Locked)
{
int currentRate = e.SensorReading.HeartRate;
taskInstance.Progress = (uint)currentRate;
if ((currentRate >= MaxRate) && (!IsMaxNotified))
{
IsMaxNotified = true;
IsMinNotified = false;
await bandClient.NotificationManager.SendMessageAsync(heartData.MyTileId, "Workload Demo", "You have to rest some time!", DateTimeOffset.Now, MessageFlags.ShowDialog);
await bandClient.NotificationManager.VibrateAsync(VibrationType.ThreeToneHigh);
}
else if ((currentRate <= MinRate) && (!IsMinNotified) && (IsMaxNotified))
{
IsMaxNotified = false;
IsMinNotified = true;
await bandClient.NotificationManager.SendMessageAsync(heartData.MyTileId, "Workload Demo", "You can continue", DateTimeOffset.Now, MessageFlags.ShowDialog);
await bandClient.NotificationManager.VibrateAsync(VibrationType.TwoToneHigh);
}
}
bandClient.SensorManager.HeartRate.ReadingChanged -= HeartRate_ReadingChanged;
isSent = true;
}
private async void PedoReceived(object sender, BandSensorReadingEventArgs <IBandPedometerReading> e)
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
PDText.Text = e.SensorReading.TotalSteps.ToString();
});
}
private void Accelerometer_ReadingChanged(object sender, BandSensorReadingEventArgs <IBandAccelerometerReading> e)
{
_accX = e.SensorReading.AccelerationX.ToString(CultureInfo.InvariantCulture);
_accY = e.SensorReading.AccelerationY.ToString(CultureInfo.InvariantCulture);
_accZ = e.SensorReading.AccelerationZ.ToString(CultureInfo.InvariantCulture);
OnPropertyChanged(nameof(BandData));
}
/// <summary>
/// Manage Heart Rate sensor reading change
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
async void HeartRate_ReadingChanged(object sender, BandSensorReadingEventArgs <IBandHeartRateReading> e)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
UpdateSensorReading("HeartRate", (double)e.SensorReading.HeartRate, txtHeartRateSensor, chkHeartRateSensor);
});
}
//async void Gyroscope_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandGyroscopeReading> e)
//{
// throw new NotImplementedException();
//}
/// <summary>
/// Manage Skin Temperature sensor reading change
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
async void SkinTemperature_ReadingChanged(object sender, BandSensorReadingEventArgs <IBandSkinTemperatureReading> e)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
UpdateSensorReading("SkinTemperature", (double)e.SensorReading.Temperature, txtSkinTempSensor, chkSkinTempSensor);
});
}
private async void DistReceived(object sender, BandSensorReadingEventArgs <IBandDistanceReading> e)
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
DisText.Text = "Motion: " + e.SensorReading.CurrentMotion.ToString() + "\nPace: " + e.SensorReading.Pace.ToString() + "\nSpeed: " + e.SensorReading.Speed.ToString() + "\nTotal: " + e.SensorReading.TotalDistance.ToString();
});
}
private async void ConReceived(object sender, BandSensorReadingEventArgs <IBandContactReading> e)
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
ConText.Text = e.SensorReading.State.ToString();
});
}
private async void SkinTempReceived(object sender, BandSensorReadingEventArgs <IBandSkinTemperatureReading> e)
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
STText.Text = e.SensorReading.Temperature.ToString();
});
}
private async void HeartRateReceived(object sender, BandSensorReadingEventArgs <IBandHeartRateReading> e)
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
samplesRecievedHR++;
int HR = e.SensorReading.HeartRate;
HRText.Text = HR.ToString();
if (samplesRecievedHR % 10 == 0)
{
UpdateDB(HRText.Text);
}
if (HR > 120)
{
HRText.Text += " Very Elevated"; HRText.Foreground = new SolidColorBrush(Windows.UI.Colors.Red);
}
else if (HR > 100)
{
HRText.Text += " Elevated"; HRText.Foreground = new SolidColorBrush(Windows.UI.Colors.DarkOrange);
}
else if (HR < 40)
{
HRText.Text += " Very Low"; HRText.Foreground = new SolidColorBrush(Windows.UI.Colors.Red);
}
else if (HR < 60)
{
HRText.Text += " Low"; HRText.Foreground = new SolidColorBrush(Windows.UI.Colors.DarkOrange);
}
else
{
HRText.Text += " Normal"; HRText.Foreground = new SolidColorBrush(Windows.UI.Colors.LawnGreen);
}
});
}
private async void HeartRate_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandHeartRateReading> e)
{
if (!Dispatcher.HasThreadAccess)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, delegate { HeartRate_ReadingChanged(sender, e); });
return;
}
if (e.SensorReading.Quality == HeartRateQuality.Acquiring)
{
PatientHR.Text = "Aquiring...";
if (WasLocked)
{
if (DateTime.Now.Subtract(LastBandWarning).TotalSeconds > 10)
{
var WorkflowFrame = ((Window.Current.Content as Frame).Content as MainPage).WorkflowFrame;
if (WorkflowFrame.Content is EquipTrack || WorkflowFrame.Content is RecordConsent)
return; // Surgery mode!
Speak("Warning: Patient has removed their Band.");
LastBandWarning = DateTime.Now;
}
PatientHR.Text = "Lost";
}
}
else
{
PatientHR.Text = e.SensorReading.HeartRate.ToString() + " BPM";
WasLocked |= true;
}
}
private bool Subscribe()
{
TimeSpan interval;
if (FakeBandClientManager.Instance.UnitTesting)
{
interval = FakeBandClientManager.Instance.TestSensorInterval;
}
else
{
interval = ReportingInterval;
}
bool ret = false;
if (interval <= TimeSpan.Zero)
{
// Only fire an update if the value has changed (poll for change every second?)
var obs = Observable.Interval(TimeSpan.FromSeconds(1));
_subscription = obs.Subscribe(l =>
{
var rc = ReadingChanged;
if (rc == null)
{
return;
}
var t = (T)CreateReading();
if (!HasReadingChanged(t))
{
return;
}
BandSensorReadingEventArgs <T> e = new BandSensorReadingEventArgs <T>(t);
rc(this, e);
});
ret = true;
}
else
{
// use an rx observable to simulate the sensor
var obs = Observable.Interval(interval);
_subscription = obs.Subscribe(l =>
{
var rc = ReadingChanged;
if (rc == null)
{
return;
}
var t = (T)CreateReading();
BandSensorReadingEventArgs <T> e = new BandSensorReadingEventArgs <T>(t);
rc(this, e);
});
ret = true;
}
return(ret);
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
async void HeartRate_ReadingChanged(object sender, BandSensorReadingEventArgs <IBandHeartRateReading> e)
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
var hr = e.SensorReading.HeartRate;
var ts = e.SensorReading.Timestamp;
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
_data.DeviceId = _bandInfo.Name;
_data.HeartRate = hr;
_data.Timestamp = ts.ToString();
_telemetry.PostTelemetryAsync(
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
_data);
//UpdateHistory(hr);
//_events.Publish(_hrv);
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
_dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Low, () =>
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
{
HeartRate = hr;
TimeStamp = ts.ToString();
//increment notification timer
NotificationTimer++;
#if USE_NOTIFICATIONS
//increment notification timer
NotificationTimer++;
if ((NotificationTimer % 30) == 0)
{
//Display notification for heart rate
ToastTemplateType toastTemplate = ToastTemplateType.ToastImageAndText01;
XmlDocument toastXml = ToastNotificationManager.GetTemplateContent(toastTemplate);
XmlNodeList toastTextElements = toastXml.GetElementsByTagName("text");
toastTextElements[0].AppendChild(toastXml.CreateTextNode(_bandInfo.Name + " is working hard!\nHeart Rate: " + HeartRate + " bpm"));
XmlNodeList toastImageAttributes = toastXml.GetElementsByTagName("image");
((XmlElement)toastImageAttributes[0]).SetAttribute("src", "ms-appx:///assets/tpoc-heart-logo-hi.png");
((XmlElement)toastImageAttributes[0]).SetAttribute("alt", "heart");
IXmlNode toastNode = toastXml.SelectSingleNode("/toast");
((XmlElement)toastNode).SetAttribute("duration", "short");
ToastNotification toast = new ToastNotification(toastXml);
ToastNotificationManager.CreateToastNotifier().Show(toast);
NotificationTimer = 0;
}
#endif
});
// Only post telemetry if the heart rate is currently locked - also, only send every two readings
// (limit of 8000 messages per day in IOT hub..)
//if (e.SensorReading.Quality == HeartRateQuality.Acquiring || (NotificationTimer+1)%2 == 0)
// return;
}
async void SkinResponse_ReadingChanged(object sender, BandSensorReadingEventArgs <IBandGsrReading> e)
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
reading_SkinResponse = e.SensorReading.Resistance;
SkinResponse.Text = "Galvanic Response: " + reading_SkinResponse;
});
}
private double Accelerometer_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandAccelerometerReading> e)
{
IBandAccelerometerReading accel = e.SensorReading;
//Read in accelerometer data from sensor
string text = string.Format("Accelerometer X = {0:G4}, Y = {1:G4}, Z = {2:G4}", accel.AccelerationX, accel.AccelerationY, accel.AccelerationZ);
System.Diagnostics.Debug.WriteLine(text);
return Math.Abs(Math.Max(accel.AccelerationX, Math.Max(accel.AccelerationY, accel.AccelerationZ)));
}
async void AmbientLight_ReadingChanged(object sender, BandSensorReadingEventArgs <IBandAmbientLightReading> e)
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
reading_AmbientLight = e.SensorReading.Brightness;
AmbientLight.Text = "Ambient Light: " + reading_AmbientLight;
});
}
/// <summary>
/// 着用状態変更イベントハンドラ
/// </summary>
/// <param name="sender">イベント発行者</param>
/// <param name="e">イベント引数</param>
private void OnContactReadingChanged(object sender, BandSensorReadingEventArgs <IBandContactReading> e)
{
if (e == null)
{
return;
}
this.ContactState = e.SensorReading.State;
}
/// <summary>
/// 紫外線レベル変更イベントハンドラ
/// </summary>
/// <param name="sender">イベント発行者</param>
/// <param name="e">イベント引数</param>
private void OnUltravioletReadingChanged(object sender, BandSensorReadingEventArgs <IBandUVReading> e)
{
if (e == null)
{
return;
}
this.ExposureLevel = e.SensorReading.IndexLevel;
}
/// <summary>
/// 肌温度変更イベントハンドラ
/// </summary>
/// <param name="sender">イベント発行者</param>
/// <param name="e">イベント引数</param>
private void OnSkinTemperatureReadingChanged(object sender, BandSensorReadingEventArgs <IBandSkinTemperatureReading> e)
{
if (e == null)
{
return;
}
this.SkinTemperature = e.SensorReading.Temperature;
}
/// <summary>
/// 歩数変更イベントハンドラ
/// </summary>
/// <param name="sender">イベント発行者</param>
/// <param name="e">イベント引数</param>
private void OnPedometerReadingChanged(object sender, BandSensorReadingEventArgs <IBandPedometerReading> e)
{
if (e == null)
{
return;
}
this.TotalSteps = e.SensorReading.TotalSteps;
}
async void SkinTemperature_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandSkinTemperatureReading> e)
{
await _dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
SkinTemp = e.SensorReading.Temperature;
TimeStamp = e.SensorReading.Timestamp.UtcDateTime.ToString();
});
}
async void SkinTemperature_ReadingChanged(object sender, BandSensorReadingEventArgs <IBandSkinTemperatureReading> e)
{
await _dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
SkinTemp = App.Data.SkinTemp = e.SensorReading.Temperature;
TimeStamp = e.SensorReading.Timestamp.UtcDateTime.ToString();
});
}
async void SkinTemperature_ReadingChanged(object sender, BandSensorReadingEventArgs <IBandSkinTemperatureReading> e)
{
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
reading_SkinTemperature = e.SensorReading.Temperature;
SkinTemperature.Text = "Skin Temperature: " + reading_SkinTemperature;
});
}
private async void HeartRate_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandHeartRateReading> e)
{
IBandHeartRateReading hr = e.SensorReading;
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Send(hr.HeartRate.ToString());
}).AsTask();
}
private void OnReadingChanged(object sender, BandSensorReadingEventArgs <IBandAccelerometerReading> e)
{
var readingChangedHandler = ReadingChanged;
if (readingChangedHandler != null)
{
ReadingChanged(this, e);
}
}
private double Accelerometer_ReadingChanged(object sender, BandSensorReadingEventArgs <IBandAccelerometerReading> e)
{
IBandAccelerometerReading accel = e.SensorReading;
//Read in accelerometer data from sensor
string text = string.Format("Accelerometer X = {0:G4}, Y = {1:G4}, Z = {2:G4}", accel.AccelerationX, accel.AccelerationY, accel.AccelerationZ);
System.Diagnostics.Debug.WriteLine(text);
return(Math.Abs(Math.Max(accel.AccelerationX, Math.Max(accel.AccelerationY, accel.AccelerationZ))));
}
/// <summary>
/// 心拍数変更イベントハンドラ
/// </summary>
/// <param name="sender">イベント発行者</param>
/// <param name="e">イベント引数</param>
private void OnHeartRateReadingChanged(object sender, BandSensorReadingEventArgs <IBandHeartRateReading> e)
{
if (e == null)
{
return;
}
this.HeartRate = e.SensorReading.HeartRate;
this.HeartRateQuality = e.SensorReading.Quality;
}
private async void SkinTemperature_ReadingChanged(object sender, BandSensorReadingEventArgs <IBandSkinTemperatureReading> e)
{
IBandSkinTemperatureReading temperatureReading = e.SensorReading;
string text = string.Format("Temperature: {0}C", temperatureReading.Temperature);
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { this.textBlock.Text = text; }).AsTask();
//if (tilesRemaining > 0)
// await bandClientCopy.NotificationManager.SendMessageAsync(Guid.Parse(tileId), text, "Your temperature reading has been taken.", DateTimeOffset.Now, MessageFlags.ShowDialog);
}
/// <summary>
/// Manage Accelerometer sensor reading change
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
async void Accelerometer_ReadingChanged(object sender, BandSensorReadingEventArgs <IBandAccelerometerReading> e)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
UpdateSensorReading("AccelX", e.SensorReading.AccelerationX, txtAccelXSensor, chkAccelXSensor);
UpdateSensorReading("AccelY", e.SensorReading.AccelerationY, txtAccelYSensor, chkAccelYSensor);
UpdateSensorReading("AccelZ", e.SensorReading.AccelerationZ, txtAccelZSensor, chkAccelZSensor);
}
);
}
private void Gsr_ReadingChanged(object sender, BandSensorReadingEventArgs <IBandGsrReading> e)
{
lock (myLock)
{
sendTime[0] = DateTime.Now;
galvanicData.Gsr = e.SensorReading.Resistance;
galvanicData.DataTimeStamp = sendTime[0];
}
}
private void HeartRate_ReadingChanged(object sender, BandSensorReadingEventArgs <IBandHeartRateReading> e)
{
HeartRateSensorReading reading = new HeartRateSensorReading
{
HeartRate = e.SensorReading.HeartRate,
Quality = e.SensorReading.Quality
};
Changed?.Invoke(reading.Value, reading.Accuracy);
}
private async void SkinTemperature_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandSkinTemperatureReading> e)
{
if (!Dispatcher.HasThreadAccess)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, delegate { SkinTemperature_ReadingChanged(sender, e); });
return;
}
PatientSkinTemp.Text = e.SensorReading.Temperature.ToString()+" °C";
}
private void HeartRate_ReadingChanged(object sender, BandSensorReadingEventArgs <IBandHeartRateReading> e)
{
lock (myLock)
{
sendTime[0] = DateTime.Now;
heartRateData.Data = e.SensorReading.HeartRate;
heartRateData.DataTimeStamp = sendTime[0];
}
}
private void SkinTemperature_ReadingChanged(object sender, BandSensorReadingEventArgs <IBandSkinTemperatureReading> e)
{
lock (myLock)
{
sendTime[0] = DateTime.Now;
skinTemperatureData.Data = e.SensorReading.Temperature;
skinTemperatureData.DataTimeStamp = sendTime[0];
}
}
void Accelerometer_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandAccelerometerReading> e)
{
CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
SensorReading reading = new SensorReading { X = e.SensorReading.AccelerationX, Y = e.SensorReading.AccelerationY, Z = e.SensorReading.AccelerationZ };
_prev = _last;
_last = reading;
Recalculate();
});
}
private async void Accelerometer_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandAccelerometerReading> e)
{
IBandAccelerometerReading accel = e.SensorReading;
string text = string.Format("X = {0}\nY = {1}\nZ = {2}", accel.AccelerationX, accel.AccelerationY, accel.AccelerationZ);
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
this.accelerometerBlock.Text = text;
}).AsTask();
}
private void Gyroscope_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandGyroscopeReading> e)
{
IBandGyroscopeReading s = e.SensorReading;
_gyroscopeHandler.AddMeasurement(s);
if (e.SensorReading.AccelerationX > 1.2)
{
GotGyroHighXAcceleration?.Invoke();
}
GotGyroReading?.Invoke();
}
async void HeartRateReceived(object sender, BandSensorReadingEventArgs<IBandHeartRateReading> e)
{
var currentHR = "";
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
() =>
{
currentHR = e.SensorReading.HeartRate.ToString();
heartT.Text = e.SensorReading.HeartRate.ToString();
});
PostTelemetryAsync(new BandEvent { SourceBand = currentBand, HR = currentHR, EventTime = DateTime.Now });
}
private void Accelerometer_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandAccelerometerReading> e)
{
var s = e.SensorReading;
if (s.AccelerationX == 0 && s.AccelerationY == 0 && s.AccelerationZ == 0)
return;
var totAcc = Sqrt(s.AccelerationX*s.AccelerationX + s.AccelerationY*s.AccelerationY + s.AccelerationZ*s.AccelerationZ);
if(totAcc > 4.0)
Pulled?.Invoke();
Debug.WriteLine(totAcc);
}
protected virtual void FireHeartRate( object sender, BandSensorReadingEventArgs<IBandHeartRateReading> args )
{
OnHeartRate?.Invoke( this, new MsBandHeartRateEventArgs( args.SensorReading.HeartRate ) );
}
async void SkinTemperature_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandSkinTemperatureReading> e)
{
if (bandState == BandContactState.Worn)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () =>
{
double temp = e.SensorReading.Temperature;
lblTemp.Text = temp.ToString() + " °C";
if (e.SensorReading.Temperature >= 35)
{
rectTempGrey.Visibility = Visibility.Collapsed;
rectTempGreen.Visibility = Visibility.Collapsed;
rectTempRed.Visibility = Visibility.Visible;
}
else
{
rectTempGrey.Visibility = Visibility.Collapsed;
rectTempGreen.Visibility = Visibility.Visible;
rectTempRed.Visibility = Visibility.Collapsed;
}
try
{
ConnecTheDotsSensor q = new ConnecTheDotsSensor("41613409-7e93-4e33-9cdd-d99eba60d126", "SkinTemperature", "C");
q.value = temp;
q.timecreated = ehh.getFormattedTimeString();
q.organization = "organization";
q.location = "location";
q.displayname = UserName;
HttpResponseMessage y = await ehh.SendMessageAsync(q.ToJson());
}
catch (Exception ex)
{
}
}).AsTask();
}
}
private void SkinTemperature_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandSkinTemperatureReading> e)
{
_skinTempData.Add(SkinTempReading.FromBandSensor(e.SensorReading));
}
private void HeartRate_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandHeartRateReading> e)
{
_heartRateData.Add(HeartRateReading.FromBandSensor(e.SensorReading));
}
private void OnHeartRateChanged(object sender, BandSensorReadingEventArgs<IBandHeartRateReading> e)
{
if (this.isDataSaving)
{
return;
}
this.bandData.HeartRate = e.SensorReading.HeartRate;
this.isHeartRateReceived = true;
}
private async void AccelerometerReadingChanged(
object sender,
BandSensorReadingEventArgs<IBandAccelerometerReading> e)
{
await Dispatcher.RunAsync(
CoreDispatcherPriority.Normal,
() =>
{
var reading = e.SensorReading;
var roll = Math.Atan2(reading.AccelerationX, reading.AccelerationY);
var pitch = Math.Atan2(reading.AccelerationZ, reading.AccelerationX);
DxPanel.Roll = NormalizeRoll(roll);
DxPanel.Pitch = NormalizePitch(pitch);
}).AsTask();
}
private void OnSkinTemperatureChanged(object sender, BandSensorReadingEventArgs<IBandSkinTemperatureReading> e)
{
if (this.isDataSaving)
{
return;
}
this.bandData.SkinTemperature = e.SensorReading.Temperature;
this.isSkinTemperatureReceived = true;
}
private async void PedometerOnReadingChanged(object sender, BandSensorReadingEventArgs<IBandPedometerReading> e)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
gg.Value++;
if (goal1)
{
gg.Unit = gg.Value + "/" + numberGoal;
}
if (gg.Value > bestSteps)
{
bestSteps = gg.Value;
IsolatedStorageHelper.SaveObject<double>("bestSteps", bestSteps);
if (!popupBest)
{
NewScore.Visibility = Visibility.Visible;
Storyboard2.Begin();
setText.Visibility = Visibility.Collapsed;
setText2.Visibility = Visibility.Collapsed;
txtGoal.Visibility = Visibility.Collapsed;
btnOk.Visibility = Visibility.Collapsed;
AudioWinner.Play();
popupBest = true;
}
}
if (goal1 && gg.Value > numberGoal && !notification)
{
var toastXmlContent = ToastNotificationManager.GetTemplateContent(ToastTemplateType.ToastText02);
var txtNodes = toastXmlContent.GetElementsByTagName("text");
txtNodes[0].AppendChild(toastXmlContent.CreateTextNode("Congratulation"));
txtNodes[1].AppendChild(toastXmlContent.CreateTextNode("Goal achieved"));
var toast = new ToastNotification(toastXmlContent);
var toastNotifier = ToastNotificationManager.CreateToastNotifier();
toastNotifier.Show(toast);
notification = true;
}
}).AsTask();
}
private void OnAccelerometerPlayer1OnReadingChanged(object sender, BandSensorReadingEventArgs<IBandAccelerometerReading> args)
{
var yReading = args.SensorReading.AccelerationY;
var xReading = args.SensorReading.AccelerationX;
CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (Current != null)
{
Current.YAnglePlayer1 = (float) yReading;
Current.XAnglePlayer1 = (float) xReading;
UpdatePlayer1Name();
}
});
}
private void Accelerometer_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandAccelerometerReading> e)
{
_accelerometerData.Add(AccelerometerReading.FromBandSensor(e.SensorReading));
}
private void BandInitialized(object sender, BandSensorReadingEventArgs<IBandHeartRateReading> e)
{
Speak("Band Initialized. Current heart rate is {0}.", e.SensorReading.HeartRate);
client.SensorManager.HeartRate.ReadingChanged -= BandInitialized;
}
async void Contact_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandContactReading> e)
{
bandState = e.SensorReading.State;
String text = "";
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (bandState == BandContactState.Worn)
{
text = "Status: band connected";
lblBand.Text = text;
lblBand.Foreground = new SolidColorBrush(Colors.Green);
}
else
{
text = "Status: no contact";
lblBand.Text = text;
lblBand.Foreground = new SolidColorBrush(Colors.Yellow);
rectHeartGreen.Visibility = Visibility.Collapsed;
rectHeartGrey.Visibility = Visibility.Visible;
rectHeartRed.Visibility = Visibility.Collapsed;
rectTempGreen.Visibility = Visibility.Collapsed;
rectTempGrey.Visibility = Visibility.Visible;
rectTempRed.Visibility = Visibility.Collapsed;
lblHeart.Text = "-";
lblTemp.Text = "-";
return;
}
}).AsTask();
if (bandState == BandContactState.Worn)
{
//only support 1 minute
#region bandClient.SensorManager.SkinTemperature
bandClient.SensorManager.SkinTemperature.ReadingChanged += SkinTemperature_ReadingChanged;
if (bandClient.SensorManager.SkinTemperature.GetCurrentUserConsent() != UserConsent.Granted)
{
// user has not consented, request it
await bandClient.SensorManager.SkinTemperature.RequestUserConsentAsync();
}
bandClient.SensorManager.SkinTemperature.StartReadingsAsync();
#endregion
#region bandClient.SensorManager.HeartRate
bandClient.SensorManager.HeartRate.ReportingInterval = TimeSpan.FromSeconds(1);
bandClient.SensorManager.HeartRate.ReadingChanged += HeartRate_ReadingChanged;
if (bandClient.SensorManager.HeartRate.GetCurrentUserConsent() != UserConsent.Granted)
{
// user has not consented, request it
await bandClient.SensorManager.HeartRate.RequestUserConsentAsync();
}
bandClient.SensorManager.HeartRate.StartReadingsAsync();
#endregion
}
else
{
bandClient.SensorManager.SkinTemperature.ReadingChanged -= SkinTemperature_ReadingChanged;
await bandClient.SensorManager.SkinTemperature.StopReadingsAsync();
bandClient.SensorManager.HeartRate.ReadingChanged += HeartRate_ReadingChanged;
await bandClient.SensorManager.HeartRate.StopReadingsAsync();
}
}
async void HeartRate_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandHeartRateReading> e)
{
if (bandState == BandContactState.Worn)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () =>
{
int heartRate = e.SensorReading.HeartRate;
lblHeart.Text = heartRate.ToString() + " bpm";
if (heartRate >= 60 && heartRate <= 100)
{
rectHeartGrey.Visibility = Visibility.Collapsed;
rectHeartGreen.Visibility = Visibility.Visible;
rectHeartRed.Visibility = Visibility.Collapsed;
}
else
{
rectHeartGrey.Visibility = Visibility.Collapsed;
rectHeartGreen.Visibility = Visibility.Collapsed;
rectHeartRed.Visibility = Visibility.Visible;
}
try
{
ConnecTheDotsSensor p = new ConnecTheDotsSensor("2298a348-e2f9-4438-ab23-82a3930122ab", "HeartRate", "BPS");
p.value = heartRate;
p.timecreated = ehh.getFormattedTimeString();
p.organization = "organization";
p.location = "location";
p.displayname = UserName;
HttpResponseMessage x = await ehh.SendMessageAsync(p.ToJson());
}
catch (Exception ex)
{
}
}).AsTask();
}
}
private void Gyroscope_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandGyroscopeReading> e)
{
_gyroscopeData.Add(GyrosocpeReading.FromBandSensor(e.SensorReading));
}
private async void acc_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandAccelerometerReading> e)
{
await App.MainViewModel.RootPage.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
this.AccelerationX = e.SensorReading.AccelerationX;
this.AccelerationY = e.SensorReading.AccelerationY;
this.AccelerationZ = e.SensorReading.AccelerationZ;
});
}
private void OnDistanceChanged(object sender, BandSensorReadingEventArgs<IBandDistanceReading> e)
{
if (this.isDataSaving)
{
return;
}
this.bandData.MotionType = e.SensorReading.CurrentMotion;
this.bandData.Pace = e.SensorReading.Pace;
this.bandData.Speed = e.SensorReading.Speed;
this.bandData.TotalDistance = e.SensorReading.TotalDistance;
this.isDistanceReceived = true;
}
private void Distance_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandDistanceReading> e)
{
_distanceData.Add(DistanceReading.FromBandSensor(e.SensorReading));
}
private void BandInitialized(object sender, BandSensorReadingEventArgs<IBandSkinTemperatureReading> e)
{
Speak("Band Initialized. Current body temperature is {0}.", e.SensorReading.Temperature);
client.SensorManager.SkinTemperature.ReadingChanged -= BandInitialized;
}
private void Calories_ReadingChanged(object sender, BandSensorReadingEventArgs<IBandCaloriesReading> e)
{
_calorieData.Add(CaloriesReading.FromBandSensor(e.SensorReading));
}
private void OnBarometerChanged(object sender, BandSensorReadingEventArgs<BandBarometerReading> e)
{
var pReading = e.SensorReading.AirPressure;
var tReading = e.SensorReading.Temperature;
if (count < filter.Length) {
this.RunOnUiThread (() => {
height.Text = "zeroing...";
});
filter [count] = pReading;
count++;
if (filter.Length == count) {
pReading = 0;
for (int x = 0; x < filter.Length; x++)
pReading += filter [x];
pReading /= filter.Length;
zeroAGL = (1 - Math.Pow (pReading / 1013.25, 0.190284)) * 145366.45;
zeroed = true;
Model.Instance.Client.NotificationManager.VibrateAsync(VibrationType.NotificationOneTone);
}
if (tileFound) {
PageData pageContent = new PageData {
PageId = pageId,
PageLayoutIndex = 0,
Data = {
new TextBlockData {
ElementId = 1,
Text = "Pull Alt:"
},
new TextBlockData {
ElementId = 2,
Text = "Zeroing..."
},
new ImageData {
ElementId = 10,
ImageIndex = 1
},
new TextBlockData {
ElementId = 5,
Text = altitudeAGL.ToString()
}
}
};
Model.Instance.Client.TileManager.SetTilePageDataAsync (tileId, pageContent);
}
} else {
altitudeAGL = (int)(((1 - Math.Pow (pReading / 1013.25, 0.190284)) * 145366.45) - zeroAGL);
if (zeroed)
{
if (altitudeAGL <= pullAltitude + 100 && altitudeAGL >= pullAltitude - 100) {
if (!fired) {
//vibrate
Model.Instance.Client.NotificationManager.VibrateAsync(VibrationType.NotificationAlarm);
fired = true;
}
} else {
fired = false;
}
}
this.RunOnUiThread (() => {
pressure.Text = string.Format ("{0,6:0} hPa", pReading);
height.Text = string.Format ("{0,6:0} ft", altitudeAGL);
});
if (tileFound) {
PageData pageContent = new PageData ();
BuildPageData (pageContent);
Model.Instance.Client.TileManager.SetTilePageDataAsync (tileId, pageContent);
}
}
}
