public void StartReading(int reportInterval = -1)
{
if (reportInterval > 0)
{
_motionManager.MagnetometerUpdateInterval = reportInterval;
}
_motionManager.StartMagnetometerUpdates(NSOperationQueue.CurrentQueue, OnMagnetoMeterChanged);
}
/// <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)
{
switch (sensorType)
{
case MotionSensorType.Accelerometer:
if (motionManager.AccelerometerAvailable)
{
motionManager.AccelerometerUpdateInterval = (double)interval / ms;
motionManager.StartAccelerometerUpdates(NSOperationQueue.CurrentQueue, OnAccelerometerChanged);
}
else
{
Debug.WriteLine("Accelerometer not available");
}
break;
case MotionSensorType.Gyroscope:
if (motionManager.GyroAvailable)
{
motionManager.GyroUpdateInterval = (double)interval / ms;
motionManager.StartGyroUpdates(NSOperationQueue.CurrentQueue, OnGyroscopeChanged);
}
else
{
Debug.WriteLine("Gyroscope not available");
}
break;
case MotionSensorType.Magnetometer:
if (motionManager.MagnetometerAvailable)
{
motionManager.MagnetometerUpdateInterval = (double)interval / ms;
motionManager.StartMagnetometerUpdates(NSOperationQueue.CurrentQueue, OnMagnometerChanged);
}
else
{
Debug.WriteLine("Magnetometer not available");
}
break;
case MotionSensorType.Compass:
if (CLLocationManager.HeadingAvailable)
{
locationManager.StartUpdatingHeading();
locationManager.UpdatedHeading += OnHeadingChanged;
}
else
{
Debug.WriteLine("Compass not available");
}
break;
}
sensorStatus[sensorType] = true;
}
protected override async Task StartListeningAsync()
{
await base.StartListeningAsync();
_motionManager?.StartMagnetometerUpdates(new NSOperationQueue(), async(data, error) =>
{
if (data != null && error == null)
{
await StoreDatumAsync(new MagnetometerDatum(DateTimeOffset.UtcNow, data.MagneticField.X, data.MagneticField.Y, data.MagneticField.Z));
}
});
}
public void StartReading(int reportInterval = -1)
{
if (reportInterval > 0)
{
_motionManager.MagnetometerUpdateInterval = reportInterval;
}
try
{
_motionManager.StartMagnetometerUpdates(NSOperationQueue.MainQueue, OnMagnetoMeterChanged);
}
catch (Exception ex)
{
OnReadingError?.Invoke(this, new DeviceSensorReadingErrorEventArgs("Magnetometer - Not called from the UIThread"));
}
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
motionManager = new CMMotionManager();
StartButton.TouchUpInside += (sender, e) =>
{
motionManager.StartMagnetometerUpdates(NSOperationQueue.CurrentQueue, (data, error) =>
{
this.xLabel.Text = data.MagneticField.X.ToString("0.0000");
this.yLabel.Text = data.MagneticField.Y.ToString("0.0000");
this.zLabel.Text = data.MagneticField.Z.ToString("0.0000");
});
};
StopButton.TouchUpInside += (sender, e) =>
{
motionManager.StopMagnetometerUpdates();
};
}
public void StartSensorUpdates()
{
// Raw accelerometer
if (_motionManager.AccelerometerAvailable)
{
_motionManager.StartAccelerometerUpdates(_queue, HandleCMAccelerometerHandler);
}
if (_motionManager.GyroAvailable)
{
_motionManager.StartGyroUpdates(_queue, HandleCMGyroHandler);
}
if (_motionManager.MagnetometerAvailable)
{
_motionManager.StartMagnetometerUpdates(_queue, HandleCMMagnetometerHandler);
}
if (_motionManager.DeviceMotionAvailable)
{
_motionManager.StartDeviceMotionUpdates(_queue, HandleCMDeviceMotionHandler);
_pedometer.StartPedometerUpdates(NSDate.Now, HandleCMPedometer);
}
//start updating headings
_locationManager.StartUpdatingHeading();
//// service for measurements once per minute
UIDevice.CurrentDevice.BatteryMonitoringEnabled = true;
Timer timer = new Timer(60000);
timer.AutoReset = true;
timer.Elapsed += SensorMeasurementSessionTimerElapsed;
timer.Start();
IsListening = true;
}
protected override void Start(CMMotionManager mgr, IObserver <MotionReading> ob)
{
mgr.StartMagnetometerUpdates(NSOperationQueue.CurrentQueue, (data, err) =>
ob.OnNext(new MotionReading(data.MagneticField.X, data.MagneticField.Y, data.MagneticField.Z))
);
}
