/// <summary>
/// Initializes a new instance of the DeviceMotionImplementation class.
/// </summary>
public DeviceMotionImplementation()
{
try
{
accelerometer = Accelerometer.GetDefault();
gyrometer = Gyrometer.GetDefault();
compass = Compass.GetDefault();
#if WINDOWS_PHONE_APP
magnetometer = Magnetometer.GetDefault();
#endif
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
sensorStatus = new Dictionary <MotionSensorType, bool>()
{
{ MotionSensorType.Accelerometer, false },
{ MotionSensorType.Gyroscope, false },
{ MotionSensorType.Magnetometer, false },
{ MotionSensorType.Compass, false }
};
}
/// <inheritdoc/>
public void Dispose()
{
if (_shouldDispose)
{
_i2cBus?.Dispose();
}
else
{
LedMatrix?.Dispose();
LedMatrix = null !;
Joystick?.Dispose();
Joystick = null !;
Gyroscope?.Dispose();
Gyroscope = null !;
Magnetometer?.Dispose();
Magnetometer = null !;
TemperatureAndHumidity?.Dispose();
TemperatureAndHumidity = null !;
PressureAndTemperature?.Dispose();
PressureAndTemperature = null !;
}
_i2cBus = null !;
}
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 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;
}
async void SensorValueChanged(object sender, X2CodingLab.SensorTag.SensorValueChangedEventArgs e)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
switch (e.Origin)
{
case SensorName.Accelerometer:
double[] accValues = Accelerometer.CalculateCoordinates(e.RawData, 1 / 64.0);
tbAccelerometer.Text = "X: " + accValues[0].ToString("0.00") + " Y: " + accValues[1].ToString("0.00") + " Z: " + accValues[2].ToString("0.00");
break;
case SensorName.Gyroscope:
float[] axisValues = Gyroscope.CalculateAxisValue(e.RawData, GyroscopeAxis.XYZ);
tbGyroscope.Text = "X: " + axisValues[0].ToString("0.00") + " Y: " + axisValues[1].ToString("0.00") + " Z: " + axisValues[2].ToString("0.00");
break;
case SensorName.HumiditySensor:
tbHumidity.Text = HumiditySensor.CalculateHumidityInPercent(e.RawData).ToString("0.00") + "%";
break;
case SensorName.Magnetometer:
float[] magnetValues = Magnetometer.CalculateCoordinates(e.RawData);
tbMagnetometer.Text = "X: " + magnetValues[0].ToString("0.00") + " Y: " + magnetValues[1].ToString("0.00") + " Z: " + magnetValues[2].ToString("0.00");
break;
case SensorName.PressureSensor:
try
{
tbPressure.Text = (PressureSensor.CalculatePressure(e.RawData, ps.CalibrationData) / 100).ToString("0.00");
}
catch (NullReferenceException)
{
// in case another(!) setup is executed, so ps is null
}
break;
case SensorName.SimpleKeyService:
if (SimpleKeyService.LeftKeyHit(e.RawData))
{
tbLeftKey.Text = "hit!";
await Task.Delay(200);
tbLeftKey.Text = "";
}
else if (SimpleKeyService.RightKeyHit(e.RawData))
{
tbRightKey.Text = "hit!";
await Task.Delay(200);
tbRightKey.Text = "";
}
break;
case SensorName.TemperatureSensor:
double ambient = IRTemperatureSensor.CalculateAmbientTemperature(e.RawData, TemperatureScale.Celsius);
double target = IRTemperatureSensor.CalculateTargetTemperature(e.RawData, ambient, TemperatureScale.Celsius);
tbTemperature.Text = ambient.ToString("0.00");
tbTargetTemperature.Text = target.ToString("0.00");
break;
}
});
}
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(MagnetometerChangedEventArgs e)
{
tcs.TrySetResult(e.Reading);
}
var d = await tcs.Task;
Magnetometer.Stop();
Magnetometer.ReadingChanged -= Magnetometer_ReadingChanged;
Assert.False(Magnetometer.IsMonitoring);
}
public override string ToString()
{
var optionValues = new List <string>
{
Geolocation.ToString(),
Midi.ToString(),
Notifications.ToString(),
Push.ToString(),
SyncXhr.ToString(),
Microphone.ToString(),
Camera.ToString(),
Magnetometer.ToString(),
Gyroscope.ToString(),
Speaker.ToString(),
Vibrate.ToString(),
Fullscreen.ToString(),
Payment.ToString(),
Accelerometer.ToString(),
AmbientLightSensor.ToString(),
Autoplay.ToString(),
EncryptedMedia.ToString(),
PictureInPicture.ToString(),
Usb.ToString(),
Vr.ToString()
};
optionValues.AddRange(Other.Select(o =>
{
o.Value.FeatureName = o.Key;
return(o.Value.ToString());
}));
return(string.Join("; ", optionValues.Where(s => s.Length > 0)));
}
private async Task GetMovementService()
{
try
{
IService service = await device.GetServiceAsync(Guid.Parse("f000aa80-0451-4000-b000-000000000000"));
ICharacteristic dataCharacteristic = await service.GetCharacteristicAsync(Guid.Parse("f000aa81-0451-4000-b000-000000000000"));
ICharacteristic configCharacteristic = await service.GetCharacteristicAsync(Guid.Parse("f000aa82-0451-4000-b000-000000000000"));
await configCharacteristic.WriteAsync(new byte[] { 0x7F, 0x00 });
_gyro = new Gyroscope();
_acc = new Accelerometer();
_mag = new Magnetometer();
Plates = new List <Plate>();
database = new StrongPlateDataService();
dataCharacteristic.ValueUpdated += (o, args) =>
{
byte[] bytes = args.Characteristic.Value;
SetGyro(bytes);
SetAcc(bytes);
SetMag(bytes);
addPlate();
};
await dataCharacteristic.StartUpdatesAsync();
}
catch (Exception ex)
{
Debug.WriteLine("Error GetMovementService: " + ex);
}
}
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);
}
}
void Stop()
{
if (Compass.IsMonitoring)
{
Compass.ReadingChanged -= Compass_ReadingChanged;
Compass.Stop();
}
if (Accelerometer.IsMonitoring)
{
Accelerometer.ReadingChanged -= Accelerometer_Essentials_ReadingChanged;
Accelerometer.Stop();
}
if (Gyroscope.IsMonitoring)
{
Gyroscope.ReadingChanged -= Gyroscope_ReadingChanged;
Gyroscope.Stop();
}
if (Magnetometer.IsMonitoring)
{
Magnetometer.ReadingChanged -= Magnetometer_ReadingChanged;
Magnetometer.Stop();
}
// device-specific sensor readings
if (Device.RuntimePlatform.Equals((Device.Android)))
{
MessagingCenter.Unsubscribe <Sensors.Android.LinearAcceleration>(this, Sensors.Android.SubscriberMessage.LinearAcceleration);
}
}
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 OnDisappearing()
{
Accelerometer.Stop();
Gyroscope.Stop();
Magnetometer.Stop();
Compass.Stop();
base.OnDisappearing();
}
/// <summary>
/// Constructor of MagnetometerAdapter.
/// </summary>
public MagnetometerAdapter()
{
sensor = new Magnetometer
{
Interval = 100,
PausePolicy = SensorPausePolicy.None
};
}
public void Init()
{
database = new Mock <IStrongPlateDataService>();
serviceListViewModel = new ServiceListViewModel(database.Object);
gyro = new Gyroscope();
magne = new Magnetometer();
acc = new Accelerometer();
}
protected override void OnResume()
{
// Handle when your app resumes
if (DrivePage.isTiltEnabled)
{
Accelerometer.Start(SensorService.speed);
Magnetometer.Start(SensorService.speed);
}
}
protected override void OnSleep()
{
// Handle when your app sleeps
if (DrivePage.isTiltEnabled)
{
Accelerometer.Stop();
Magnetometer.Stop();
}
}
public MagnetometerDeviceSensor()
{
try
{
_magnetometer = new Magnetometer();
}
catch (NotSupportedException)
{
}
}
public static TabiApiClient.Models.MotionSensor ToApiModel(this Magnetometer magnetometer)
{
return(new TabiApiClient.Models.MotionSensor()
{
X = magnetometer.X,
Y = magnetometer.Y,
Z = magnetometer.Z,
Timestamp = magnetometer.Timestamp
});
}
public void StopSensors()
{
Accelerometer.Stop();
Magnetometer.Stop();
Gyroscope.Stop();
Accelerometer.ReadingChanged -= Accelerometer_ReadingChanged;
Magnetometer.ReadingChanged -= Magnetometer_ReadingChanged;
Gyroscope.ReadingChanged -= Gyrotometer_ReadingChanged;
OrientationSensor.ReadingChanged -= OrientationSensor_ReadingChanged;
_instance = null;
}
void MagnetometerReadingChanged(Magnetometer sender, MagnetometerReadingChangedEventArgs args)
{
OnSensorValueChanged(new SensorValueChangedEventArgs
{
ValueType = MotionSensorValueType.Vector,
SensorType = MotionSensorType.Magnetometer,
Value = new MotionVector {
X = args.Reading.MagneticFieldX, Y = args.Reading.MagneticFieldY, Z = args.Reading.MagneticFieldZ
}
});
}
public UWPDeviceInformationService()
{
easDevice = new EasClientDeviceInformation();
accelerometer = Accelerometer.GetDefault();
gyrometer = Gyrometer.GetDefault();
magnetometer = Magnetometer.GetDefault();
try
{
vibrationDevice = VibrationDevice.GetDefaultAsync().GetResults();
}
catch { }
}
// Start is called before the first frame update
void Start()
{
Instance = this;
DontDestroyOnLoad(gameObject);
if (!Input.compass.enabled)
{
Debug.Log("Compass désactivé");
return;
}
Input.location.Start();
}
/// <summary>
/// Initializes a new instance of the DeviceMotionImplementation class.
/// </summary>
public DeviceMotionImplementation()
{
accelerometer = Accelerometer.GetDefault();
gyrometer = Gyrometer.GetDefault();
compass = Compass.GetDefault();
#if WINDOWS_PHONE_APP
magnetometer = Magnetometer.GetDefault();
#endif
sensorStatus = new Dictionary <MotionSensorType, bool>()
{
{ MotionSensorType.Accelerometer, false },
{ MotionSensorType.Gyroscope, false },
{ MotionSensorType.Magnetometer, false },
{ MotionSensorType.Compass, false }
};
}
public Scenario1_DataEvents()
{
this.InitializeComponent();
_magnetometer = Magnetometer.GetDefault();
if (_magnetometer != null)
{
// Select a report interval that is both suitable for the purposes of the app and supported by the sensor.
// This value will be used later to activate the sensor.
uint minReportInterval = _magnetometer.MinimumReportInterval;
_desiredReportInterval = minReportInterval > 16 ? minReportInterval : 16;
}
else
{
rootPage.NotifyUser("No magnetometer found", NotifyType.ErrorMessage);
}
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
DisplayInformation.AutoRotationPreferences = DisplayOrientations.Landscape | DisplayOrientations.LandscapeFlipped | DisplayOrientations.Portrait | DisplayOrientations.PortraitFlipped;
acc = Accelerometer.GetDefault();
//act = ActivitySensor.GetDefaultAsync().GetResults();
alt = Altimeter.GetDefault();
baro = Barometer.GetDefault();
comp = Compass.GetDefault();
gyro = Gyrometer.GetDefault();
//has = HingeAngleSensor.GetDefaultAsync().GetResults();
inc = Inclinometer.GetDefault();
mm = Magnetometer.GetDefault();
os = OrientationSensor.GetDefault();
//pm = Pedometer.GetDefaultAsync().GetResults();
//ps = ProximitySensor.FromId(ProximitySensor.GetDeviceSelector());
sos = SimpleOrientationSensor.GetDefault();
}
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());
}
}
/// <summary>
/// Initializes a new instance of the DeviceMotionImplementation class.
/// </summary>
public DeviceMotionImplementation()
{
accelerometer = Accelerometer.GetDefault();
gyrometer = Gyrometer.GetDefault();
compass = Compass.GetDefault();
#if WINDOWS_PHONE_APP
magnetometer = Magnetometer.GetDefault();
#endif
sensorStatus = new Dictionary<MotionSensorType, bool>()
{
{ MotionSensorType.Accelerometer, false},
{ MotionSensorType.Gyroscope, false},
{ MotionSensorType.Magnetometer, false},
{ MotionSensorType.Compass, false}
};
}
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);
}
};
}
/// <summary>
/// MagnetometerService class constructor.
/// </summary>
public MagnetometerService()
{
//_magnetometer = new Magnetometer();
try
{
_magnetometer = new Magnetometer();
}
catch (NotSupportedException ex)
{
/// Magnetometer is not supported in the current device.
/// You can also check whether the magnetometer is supported with the following property:
/// var supported = Magnetometer.IsSupported;
///
}
catch (Exception e)
{
}
}
public Task Stop()
{
try
{
Magnetometer.Stop();
}
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 MagnetometerTestsViewModel(CoreDispatcher dispatcher) : base(dispatcher)
{
_magnetometer = Magnetometer.GetDefault();
if (_magnetometer != null)
{
_magnetometer.ReportInterval = 250;
SensorStatus = "Magnetometer created";
}
else
{
SensorStatus = "Magnetometer not available on this device";
}
Disposables.Add(Disposable.Create(() =>
{
if (_magnetometer != null)
{
_magnetometer.ReadingChanged -= Magnetometer_ReadingChanged;
}
}));
}
public MagnetometerEvents(Magnetometer This)
{
this.This = This;
}
void MagnetometerReadingChanged(Magnetometer sender, MagnetometerReadingChangedEventArgs args)
{
if(SensorValueChanged != null)
SensorValueChanged(this, new SensorValueChangedEventArgs { ValueType = MotionSensorValueType.Vector, SensorType = MotionSensorType.Magnetometer, Value = new MotionVector() { X = args.Reading.MagneticFieldX, Y = args.Reading.MagneticFieldY, Z = args.Reading.MagneticFieldZ } });
}
