public MainPage() { InitializeComponent(); BatteryLifeInSeconds = 18000; LastCharge = 1F; ElapsedTime = 0; isEyeball = false; Battery.BatteryInfoChanged += Battery_BatteryInfoChanged; //https://www.youtube.com/watch?v=eDx8tbUrkP0 Device.StartTimer(TimeSpan.FromSeconds(1), () => { Device.BeginInvokeOnMainThread(() => DisplayCountdown() ); return(true); }); Magnetometer.Start(SensorSpeed.UI); Magnetometer.ReadingChanged += Magnetometer_ReadingChanged; Compass.Start(SensorSpeed.UI); Compass.ReadingChanged += Compass_ReadingChanged; }
public void ControlSunscribe(bool flag) { try { if (Magnetometer.IsMonitoring && !flag) { Magnetometer.Stop(); MagnetometerWatch.Reset(); } else if (!Magnetometer.IsMonitoring && flag) { MagnetometerWatch.Start(); Magnetometer.Start(Config.sensorSpeed); } else { //Dont think anything is needed here } } catch (FeatureNotEnabledException ex) { } catch (Exception ex) { } }
public override void OnAppearing() { try { Magnetometer.ReadingChanged += OnMagnetometerReadingChanged; if (!Magnetometer.IsMonitoring) { Magnetometer.Start(SensorSpeed.UI); } Accelerometer.ShakeDetected += OnShakeDetected; Accelerometer.ReadingChanged += OnAccelerometerReadingChanged; if (!Accelerometer.IsMonitoring) { Accelerometer.Start(SensorSpeed.UI); } Gyroscope.ReadingChanged += OnGyroscopeReadingChanged; if (!Gyroscope.IsMonitoring) { Gyroscope.Start(SensorSpeed.UI); } } catch (FeatureNotSupportedException ex) { Logger.Debug("Feature not supported: " + ex.Message); } }
public void ToggleMetrics(bool isToogled) { try { if (isToogled) { Accelerometer.Start(speed); //Barometer.Start(speed); Compass.Start(speed); Gyroscope.Start(speed); Magnetometer.Start(speed); OrientationSensor.Start(speed); } else { Accelerometer.Stop(); //Barometer.Stop(); Compass.Stop(); Gyroscope.Stop(); Magnetometer.Stop(); OrientationSensor.Stop(); } } catch (FeatureNotSupportedException) { ShowNotSupportedError(); } catch (Exception ex) { ShowError(ex.Message); } }
public IObservable <MotionReading> WhenReadingTaken() { this.observable = this.observable ?? Observable.Create <MotionReading>(ob => { var handler = new EventHandler <MagnetometerDataUpdatedEventArgs>((sender, args) => ob.OnNext(new MotionReading(args.X, args.Y, args.Z)) ); var sensor = new Magnetometer { Interval = 250 }; sensor.DataUpdated += handler; sensor.Start(); return(() => { sensor.Stop(); sensor.DataUpdated -= handler; sensor.Dispose(); }); }) .Publish() .RefCount(); return(this.observable); }
public void ToggleSensor() { try { if (Accelerometer.IsMonitoring || Gyroscope.IsMonitoring) { Accelerometer.Stop(); Magnetometer.Stop(); } else { Accelerometer.Start(speed); Magnetometer.Start(speed); } } catch (FeatureNotSupportedException fnsEx) { // Feature not supported on device Debug.WriteLine(fnsEx.Message); } catch (Exception ex) { // Other error has occurred. Debug.WriteLine(ex.Message); } }
public async Task Stop_Monitor(SensorSpeed sensorSpeed) { // TODO: the test runner app (UI version) should do this, until then... if (!HardwareSupport.HasMagnetometer) { return; } var tcs = new TaskCompletionSource <MagnetometerData>(); Magnetometer.ReadingChanged += Magnetometer_ReadingChanged; Magnetometer.Start(sensorSpeed); void Magnetometer_ReadingChanged(object sender, MagnetometerChangedEventArgs e) { tcs.TrySetResult(e.Reading); } var d = await tcs.Task; Magnetometer.Stop(); Magnetometer.ReadingChanged -= Magnetometer_ReadingChanged; Assert.False(Magnetometer.IsMonitoring); }
public void ToggleMagnetometer() { try { if (Magnetometer.IsMonitoring) { Magnetometer.Stop(); } else { Magnetometer.Start(speed); } } catch (FeatureNotSupportedException fnsEx) { // Feature not supported on device Console.WriteLine(fnsEx); exception.Text = "Feature not supported on device"; } catch (Exception ex) { // Other error has occurred. Console.WriteLine(ex); exception.Text = "Other error has occurred"; } }
public void ToggleMagnetometer() { try { if (Magnetometer.IsMonitoring) { Magnetometer.Stop(); this.lblResult.Text += "Stop!!!" + Environment.NewLine; } else { Magnetometer.Start(speed); this.lblResult.Text = ""; } } catch (FeatureNotSupportedException fnsEx) { // Feature not supported on device this.lblResult.Text = fnsEx.ToString(); } catch (Exception ex) { // Other error has occurred. this.lblResult.Text = ex.ToString(); } }
/// <summary> /// Starts the magnetometer sensor. /// </summary> public void Start() { if (IsSupported() && !_magnetometer.IsSensing) { _magnetometer.DataUpdated += OnDataUpdated; _magnetometer.Start(); } }
protected override void OnAppearing() { Accelerometer.Start(SensorSpeed.UI); Gyroscope.Start(SensorSpeed.UI); Magnetometer.Start(SensorSpeed.UI); Compass.Start(SensorSpeed.UI); base.OnAppearing(); }
protected override void OnResume() { // Handle when your app resumes if (DrivePage.isTiltEnabled) { Accelerometer.Start(SensorService.speed); Magnetometer.Start(SensorService.speed); } }
public void StartReading(int reportInterval = -1) { if (reportInterval >= 0) { _magnetometer.Interval = (uint)reportInterval; } _magnetometer.DataUpdated += MagnetometerReadingChanged; _magnetometer.Start(); }
/// <summary> /// Starts sensor and registers listener to a sensor /// </summary> /// <param name="listener">Event handler to listen sensor events</param> public void Start(EventHandler <SensorEventArgs> listener) { handler = (sender, e) => { listener?.Invoke(this, new SensorEventArgs(new List <float>() { e.X, e.Y, e.Z })); }; sensor.DataUpdated += handler; sensor.Start(); }
/// <summary> /// Starts the magnetometer sensor. /// </summary> public void Start() { if (!IsSupported()) { return; } if (_magnetometer.IsSensing) { return; } _magnetometer.DataUpdated += OnDataUpdated; _magnetometer.Start(); }
public void StartSensors() { try { Accelerometer.Start(SensorSpeed.Default); Magnetometer.Start(SensorSpeed.Default); Gyroscope.Start(SensorSpeed.Default); OrientationSensor.Start(SensorSpeed.Default); Accelerometer.ReadingChanged += Accelerometer_ReadingChanged; Magnetometer.ReadingChanged += Magnetometer_ReadingChanged; Gyroscope.ReadingChanged += Gyrotometer_ReadingChanged; OrientationSensor.ReadingChanged += OrientationSensor_ReadingChanged; } catch (Exception EX) { //Log.Error(TAG, EX.GetBaseException().ToString()); } }
public MainPage() { InitializeComponent(); Magnetometer.Start(SensorSpeed.UI); Magnetometer.ReadingChanged += (s, e) => { x.Text = e.Reading.MagneticField.X.ToString(); y.Text = e.Reading.MagneticField.Y.ToString(); z.Text = e.Reading.MagneticField.Z.ToString(); var absVal = Convert.ToInt32(Math.Round(e.Reading.MagneticField.Length())); abs.Text = absVal.ToString(); this.BackgroundColor = Color.FromRgb(255 - (absVal <= 510 ? absVal / 2 : 255), 0 + (absVal <= 510 ? absVal / 2 : 255), 0); if (absVal >= 300) { Vibration.Vibrate(50); } }; }
public Task Start() { try { Magnetometer.Start(speed); } catch (FeatureNotSupportedException fnsEx) { // Feature not supported on device Console.WriteLine(fnsEx.Message); } catch (Exception ex) { // Other error has occurred. Console.WriteLine(ex.Message); } return(Task.CompletedTask); }
public async Task Monitor(SensorSpeed sensorSpeed) { if (!TestSupported) { return; } var tcs = new TaskCompletionSource <MagnetometerData>(); Magnetometer.ReadingChanged += Magnetometer_ReadingChanged; Magnetometer.Start(sensorSpeed); void Magnetometer_ReadingChanged(MagnetometerChangedEventArgs e) { tcs.TrySetResult(e.Reading); } var d = await tcs.Task; Magnetometer.Stop(); Magnetometer.ReadingChanged -= Magnetometer_ReadingChanged; }
void Start() { this._sensingData.ID = "charlie"; this._sensingData.DeviceName = DeviceInfo.Name; if (!Compass.IsMonitoring) { Compass.ReadingChanged += Compass_ReadingChanged; Compass.Start(SensorSpeed.Fastest); } if (!Accelerometer.IsMonitoring) { Accelerometer.ReadingChanged += Accelerometer_Essentials_ReadingChanged; Accelerometer.Start(SensorSpeed.Fastest); } if (!Gyroscope.IsMonitoring) { Gyroscope.ReadingChanged += Gyroscope_ReadingChanged; Gyroscope.Start(SensorSpeed.Fastest); } if (!Magnetometer.IsMonitoring) { Magnetometer.ReadingChanged += Magnetometer_ReadingChanged; Magnetometer.Start(SensorSpeed.Fastest); } // device-specific sensor readings if (Device.RuntimePlatform.Equals((Device.Android))) { MessagingCenter.Subscribe <Sensors.Android.LinearAcceleration>(this, Sensors.Android.SubscriberMessage.LinearAcceleration, (linear_acceleration) => { this.LinearAccelerometer_Android_ReadingChanged(linear_acceleration); }); } }
public void ToggleMagnetometer_OnToggled(object sender, ToggledEventArgs e) { try { if (Magnetometer.IsMonitoring) { Magnetometer.Stop(); } else { Magnetometer.Start(speed); } } catch (FeatureNotSupportedException fnsEx) { DisplayAlert("Alert", "Magnetometer not supported", "OK"); Console.WriteLine("Error!" + fnsEx); } catch (Exception ex) { DisplayAlert("Alert", "An error has occurred using magnetometer", "OK"); Console.WriteLine("Error!" + ex); } }
protected override void OnAppearing() { base.OnAppearing(); Magnetometer?.Start(); }
public void Magnetometer_Stop() => Assert.Throws <NotImplementedInReferenceAssemblyException>(() => Magnetometer.Start(SensorSpeed.Normal));
public void Monitor_On_NetStandard() => Assert.Throws <NotImplementedInReferenceAssemblyException>(() => Magnetometer.Start(SensorSpeed.Normal));
/// <summary> /// Start the specified sensorType and interval. /// </summary> /// <param name="sensorType">Sensor type.</param> /// <param name="interval">Interval.</param> public void Start(MotionSensorType sensorType, MotionSensorDelay interval = MotionSensorDelay.Default) { uint delay = (uint)((double)Convert.ToInt32(interval) / ms); switch (sensorType) { case MotionSensorType.Accelerometer: if (accelerometer != null) { accelerometer.Interval = delay; accelerometer.DataUpdated += AccelerometerDataUpdated; accelerometer.Start(); sensorStatus[sensorType] = true; } else { Debug.WriteLine("Accelerometer not available"); } break; case MotionSensorType.Gyroscope: if (gyroscope != null) { gyroscope.Interval = delay; gyroscope.DataUpdated += GyroscopeDataUpdated; gyroscope.Start(); sensorStatus[sensorType] = true; } else { Debug.WriteLine("Gyroscope not available"); } break; case MotionSensorType.Magnetometer: if (magnetometer != null) { magnetometer.Interval = delay; magnetometer.DataUpdated += MagnetometerDataUpdated; magnetometer.Start(); sensorStatus[sensorType] = true; } else { Debug.WriteLine("Magnetometer not available"); } break; case MotionSensorType.Compass: if (orientation != null) { orientation.Interval = delay; orientation.DataUpdated += OrientationDataUpdated; orientation.Start(); sensorStatus[sensorType] = true; } else { Debug.WriteLine("OrientationSensor not available"); } break; } }
/// <inheritdoc /> public void Start(SensorSpeed sensorSpeed = SensorSpeed.Default) => Magnetometer.Start(sensorSpeed);
void StartButton_Clicked(object sender, EventArgs e) { Magnetometer.Start((SensorSpeed)speedPicker.SelectedIndex); }