void accelerometer_CurrentValueChanged(object sender, SensorReadingEventArgs<AccelerometerReading> e)
{
AddJOValue("accX", e.SensorReading.Acceleration.X);
AddJOValue("accY", e.SensorReading.Acceleration.Y);
AddJOValue("accZ", e.SensorReading.Acceleration.Z);
AddJOValue("timestamp", DeviceTools.GetUnixTime());
}
private void HandleToCalm(SensorReadingEventArgs <AccelerometerReading> e)
{
if (Math.Abs(e.SensorReading.Acceleration.Z) >= 0.4)
{
trackRecordPointsCount = 0;
return;
}
if (trackRecordPointsCount == 0)
{
lastZValue = e.SensorReading.Acceleration.Z;
trackRecordPointsCount++;
}
else
{
if (Math.Abs(e.SensorReading.Acceleration.Z - lastZValue) > 0.2)
{
trackRecordPointsCount = 0;
return;
}
trackRecordPointsCount++;
if (trackRecordPointsCount >= 5)
{
acceptBigTurn = true;
waitToCalm = false;
}
}
}
/// <summary>
/// Compass event handler.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void compass_CurrentValueChanged(object sender, SensorReadingEventArgs <CompassReading> e)
{
IsDataValid = Compass.IsDataValid;
TrueHeading = e.SensorReading.TrueHeading;
MagneticHeading = e.SensorReading.MagneticHeading;
HeadingAccuracy = e.SensorReading.HeadingAccuracy;
}
void motion_CurrentValueChanged(object sender, SensorReadingEventArgs<MotionReading> e)
{
float[] attitude = new float[3];
attitude[0]=e.SensorReading.Attitude.Roll;
attitude[1]=e.SensorReading.Attitude.Pitch;
motors=mflightbox.compensate(attitude);
mConManager.SendCommand(motors);
Dispatcher.BeginInvoke(() =>
{
rollTextBlock.Text = attitude[0].ToString("f5");
pitchTextBlock.Text = attitude[1].ToString("f5");
motor0.Text = motors[0].ToString("f5");
motor1.Text = motors[1].ToString("f5");
motor2.Text = motors[2].ToString("f5");
motor3.Text = motors[3].ToString("f5");
//updateMotorDrive(data);
});
}
void WrappedSubjectCurrentValueChanged(object sender, SensorReadingEventArgs <MotionReading> e)
{
CurrentValueChangedRelay(sender, new SensorReadingEventArgs <MotionSensorReading>()
{
SensorReading = new MotionSensorReading(e.SensorReading)
});
}
private void _acceleromter_CurrentValueChanged(object sender, SensorReadingEventArgs <AccelerometerReading> e)
{
//need to consider orientation here,if support only landscape might be like this
previousAccelerometerReading = CurrentAcceleromoterReading;
currentAcceleromoterReading.Y = -(float)e.SensorReading.Acceleration.Y;
currentAcceleromoterReading.X = -(float)e.SensorReading.Acceleration.X;
}
private void HandleBigTurn(SensorReadingEventArgs <AccelerometerReading> e)
{
if (Math.Abs(e.SensorReading.Acceleration.Z) < 0.9)
{
return;
}
acceptBigTurn = false;
waitToCalm = true;
trackRecordPointsCount = 0;
var isRight = e.SensorReading.Acceleration.Z > 0;
SoundController.PlaySound(isRight ? SoundEnum.Correct : SoundEnum.Pass);
new Thread(() => Dispatcher.BeginInvoke(() => Dispatcher.BeginInvoke(() =>
{
if (GuessingList.Count == 1)
{
M_StringTextBlock.Text = "猜的太快了!";
}
;
if (GuessingList.Contains(M_StringTextBlock.Text))
{
ResultList.Add(new ResultData()
{
Content = M_StringTextBlock.Text, IsRight = isRight
});
GuessingList.Remove(M_StringTextBlock.Text);
}
SetWordContent(GuessingList[random.Next(0, GuessingList.Count - 1)]);
}))).Start();
}
/// <summary>
/// Get the current rotation rate. This value is in radians per second.
/// </summary>
/// <returns>The MainViewModel object.</returns>
void gyroscope_CurrentValueChanged(object sender, SensorReadingEventArgs<GyroscopeReading> e)
{
AddJOValue("currentRotationRateX", e.SensorReading.RotationRate.X);
AddJOValue("currentRotationRateY", e.SensorReading.RotationRate.Y);
AddJOValue("currentRotationRateZ", e.SensorReading.RotationRate.Z);
AddJOValue("timestamp", DeviceTools.GetUnixTime());
}
void accelerometer_CurrentValueChanged(object sender, SensorReadingEventArgs <AccelerometerReading> e)
{
// New accellerometer
acceleration = e.SensorReading.Acceleration;
if (compass.IsDataValid && !calibrating)
{
// PEDOMETER CODE (available at http://stackoverflow.com/questions/9895402/wp7-sdk-pedometer)
float x = acceleration.X;
float y = acceleration.Y;
float z = acceleration.Z;
double oldValue = ((x_old * x) + (y_old * y)) + (z_old * z);
double oldValueSqrt = Math.Abs(Math.Sqrt((double)(((x_old * x_old) + (y_old * y_old)) + (z_old * z_old))));
double newValue = Math.Abs(Math.Sqrt((double)(((x * x) + (y * y)) + (z * z))));
oldValue /= oldValueSqrt * newValue;
if ((oldValue <= sensitivity + 0.078) && (oldValue > sensitivity)) // Form here we could control sensitivity
{
if (!hasChanged)
{
hasChanged = true;
stepcount++; // here we count steps
}
else
{
hasChanged = false;
}
}
x_old = x;
y_old = y;
z_old = z;
}
map.HeadingChanged += map_HeadingChanged;
}
void motion_CurrentValueChanged(object sender, SensorReadingEventArgs <MotionReading> e)
{
// This event arrives on a background thread. Use BeginInvoke to call
// CurrentValueChanged on the UI thread.
// ball.resetTime();
//Dispatcher.BeginInvoke(() => CurrentValueChanged(e.SensorReading));
}
void WrappedSubjectCurrentValueChanged(object sender, SensorReadingEventArgs <AccelerometerReading> e)
{
CurrentValueChangedRelay(sender, new SensorReadingEventArgs <AccelerometerSensorReading>()
{
SensorReading = new AccelerometerSensorReading(e.SensorReading)
});
}
void AccelerometerCurrentValueChanged(object sender, SensorReadingEventArgs <AccelerometerReading> e)
{
if (_client == null || _writer == null)
{
return;
}
var report = new AccelerometerReport {
AccelerationX = e.SensorReading.Acceleration.X,
AccelerationY = e.SensorReading.Acceleration.Y,
AccelerationZ = e.SensorReading.Acceleration.Z,
Timestamp = e.SensorReading.Timestamp
};
try {
var json = AccelerometerReportSerializer.ToString(report);
var size = _writer.MeasureString(json);
_writer.WriteUInt32(size);
_writer.WriteString(json);
_writer.StoreAsync();
_writer.FlushAsync();
}
catch (Exception ex) {
Debug.WriteLine("Error writing to stream: " + ex);
}
}
/// <summary>
/// Accelerometers the on current value changed.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="sensorReadingEventArgs">The sensor reading event arguments.</param>
private void AccelerometerOnCurrentValueChanged(
object sender,
SensorReadingEventArgs<AccelerometerReading> sensorReadingEventArgs)
{
LatestReading = sensorReadingEventArgs.SensorReading.Acceleration.AsVector3();
readingAvailable.Invoke(sender, LatestReading);
}
void accelerometer_CurrentValueChanged(object sender, SensorReadingEventArgs <Microsoft.Devices.Sensors.AccelerometerReading> e)
{
#if ANDROID || IOS
var sensorReading = e.SensorReading.Acceleration;
#elif WINDOWS_PHONE8
// We have to use reflection to get the Vector3 value out of Acceleration
// What happens is that the Sensor used XNA Vector3 and what we have done is replaced
// the XNA with MonoGame which our Sensor does not compile against.
//
// Result is this ugly hack.
object val = e.SensorReading.GetType()
.GetProperty("Acceleration",
BindingFlags.FlattenHierarchy |
BindingFlags.Instance |
BindingFlags.Public)
.GetValue(e.SensorReading, null);
var sensorReading = ParseVector3(val.ToString());
#endif
accelerationValue.X = sensorReading.X;
accelerationValue.Y = sensorReading.Y;
accelerationValue.Z = sensorReading.Z;
accelerationValue.TimeStamp = e.SensorReading.Timestamp.Ticks;
}
public GameplayScreen(bool newGame)
{
this.newGame = newGame;
tempp = new HighScore();
rezultati = new List<HighScore>();
isoHelper = new ISHelper();
typeFinish = false;
temp = new List<HighScore>();
Scores = new HighScore();
GameplayHelper.updateGameTime = true;
//foreach (HighScore kv in temp)
//{
// Debug.WriteLine(kv.player + kv.score);
//}
Accelerometer = new Accelerometer();
if (Accelerometer.State == SensorState.Ready)
{
Accelerometer.CurrentValueChanged += (s, e) =>
{
accelState = e;
};
Accelerometer.Start();
}
}
/*
* GYROSCOPE METHODS
*/
void gyroscope_CurrentValueChanged(object sender, SensorReadingEventArgs <GyroscopeReading> e)
{
if (lastUpdateTime.Equals(DateTimeOffset.MinValue))
{
// If this is the first time CurrentValueChanged was raised,
// only update the lastUpdateTime variable.
lastUpdateTime = e.SensorReading.Timestamp;
}
else
{
// Get the current rotation rate. This value is in
// radians per second.
currentRotationRate = e.SensorReading.RotationRate;
// Subtract the previous timestamp from the current one
// to determine the time between readings
TimeSpan timeSinceLastUpdate = e.SensorReading.Timestamp - lastUpdateTime;
// Obtain the amount the device rotated since the last update
// by multiplying by the rotation rate by the time since the last update.
// (radians/second) * secondsSinceLastReading = radiansSinceLastReading
cumulativeRotation += currentRotationRate * (float)(timeSinceLastUpdate.TotalSeconds);
lastUpdateTime = e.SensorReading.Timestamp;
}
}
void acc_CurrentValueChanged(object sender, SensorReadingEventArgs<AccelerometerReading> e)
{
//Dispatcher.BeginInvoke(() => UpdateUI(e.SensorReading));
AccelerometerReading t =e.SensorReading;
Vector3 a=t.Acceleration;
if (Math.Abs(a.X) < Math.Abs(this.currentThreshold)) return;
if (a.X * this.currentThreshold > 0)
{
this.accQuicklyForwardTime = t.Timestamp;
}
else if(t.Timestamp - this.accQuicklyForwardTime < TimeSpan.FromSeconds(.2))
{
this.accQuicklyForwardTime = DateTimeOffset.MinValue;
this.Dispatcher.BeginInvoke(delegate()
{
switch (this.random.Next(0, 4))
{
case 0: SoundEffects.Punch1.Play(); break;
case 1: SoundEffects.Punch2.Play(); break;
case 2: SoundEffects.Punch3.Play(); break;
case 3: SoundEffects.Punch4.Play(); break;
}
switch (this.random.Next(0, 10))
{
case 0: SoundEffects.Grunt1.Play(); break;
case 1: SoundEffects.Grunt2.Play(); break;
case 2: SoundEffects.Grunt3.Play(); break;
}
});
}
}
/// <summary>
/// Accelerometers the on current value changed.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="sensorReadingEventArgs">The sensor reading event arguments.</param>
private void AccelerometerOnCurrentValueChanged(
object sender,
SensorReadingEventArgs <AccelerometerReading> sensorReadingEventArgs)
{
LatestReading = sensorReadingEventArgs.SensorReading.Acceleration.AsVector3();
readingAvailable.Invoke(sender, LatestReading);
}
void OnAccelerometerReadingChanged(object sender, SensorReadingEventArgs <AccelerometerReading> args)
{
lock (accelerometerVectorLock)
{
accVectorTemp = new Vector3((float)args.SensorReading.Acceleration.X, (float)args.SensorReading.Acceleration.Y, (float)args.SensorReading.Acceleration.Z);
}
}
private void CurrentValueChanged(object sender, SensorReadingEventArgs <AccelerometerReading> e)
{
if (_sensor.State == SensorState.Ready)
{
var reading = e;
try
{
if (_lastReading != null)
{
if (!_shaking && CheckForShake(_lastReading.SensorReading.Acceleration, reading.SensorReading.Acceleration, ShakeThreshold) && _shakeCount >= 1)
{
//We are shaking
_shaking = true;
_shakeCount = 0;
OnShakeDetected();
}
else if (CheckForShake(_lastReading.SensorReading.Acceleration, reading.SensorReading.Acceleration, ShakeThreshold))
{
_shakeCount++;
}
else if (!CheckForShake(_lastReading.SensorReading.Acceleration, reading.SensorReading.Acceleration, 0.2))
{
_shakeCount = 0;
_shaking = false;
}
}
_lastReading = reading;
}
catch
{
/* ignore errors */
}
}
}
private void Compass_CurrentValueChanged(object sender, SensorReadingEventArgs <CompassReading> e)
{
if (((Compass)sender).IsDataValid)
{
ProcessCompass(e.SensorReading);
}
}
private void ReadingChanged(SensorReadingEventArgs<AccelerometerReading> e)
{
Vector3 currentReading = e.SensorReading.Acceleration;
double distanceTraveled = 2;
double boundingBoxStrokeThickness = boundingBox.StrokeThickness;
double rightBumper = ContentGrid.Width - ball.Width - boundingBoxStrokeThickness; // right margin is 0
double leftBumper = ContentGrid.Margin.Left + boundingBoxStrokeThickness; // left margin is non-zero
double bottomBumper = ContentGrid.Height - ball.Height - boundingBoxStrokeThickness;
double topBumper = ContentGrid.Margin.Top + boundingBoxStrokeThickness;
double acceleration = Math.Abs(currentReading.Z) == 0 ? 0.02 : Math.Abs(currentReading.Z);
// acceleration = (acceleration * 2)%2;
Debug.WriteLine("Accel" + acceleration);
double ballX = (double)ball.GetValue(Canvas.LeftProperty) +(double)distanceTraveled * (currentReading.X / acceleration);
double ballY = (double)ball.GetValue(Canvas.TopProperty) - (double)distanceTraveled * (currentReading.Y / acceleration);
if (ballX < leftBumper) {
ballX = leftBumper;
}
else if (ballX > rightBumper) {
ballX = rightBumper;
}
if (ballY < topBumper) {
ballY = topBumper;
}
else if (ballY > bottomBumper) {
ballY = bottomBumper;
}
ball.SetValue(Canvas.LeftProperty, ballX);
ball.SetValue(Canvas.TopProperty, ballY);
}
void _accelerometer_ReadingChanged(object sender, SensorReadingEventArgs <AccelerometerReading> e)
{
//Does the currenet acceleration vector meet the minimum magnitude that we
//care about?
if ((e.SensorReading.Acceleration.X * e.SensorReading.Acceleration.X + e.SensorReading.Acceleration.Y * e.SensorReading.Acceleration.Y) > MinimumAccelerationMagnitudeSquared)
{
//I prefer to work in radians. For the sake of those reading this code
//I will work in degrees. In the following direction will contain the direction
// in which the device was accelerating in degrees.
double degrees = 180.0 * Math.Atan2(e.SensorReading.Acceleration.Y, e.SensorReading.Acceleration.X) / Math.PI;
Direction direction = DegreesToDirection(degrees);
//
D = direction;
deg = degrees;
//
//If the shake detected is in the same direction as the last one then ignore it
if ((direction & _shakeRecordList[_shakeRecordIndex].ShakeDirection) != Direction.None)
{
return;
}
ShakeRecord record = new ShakeRecord();
record.EventTime = DateTime.Now;
record.ShakeDirection = direction;
_shakeRecordIndex = (_shakeRecordIndex + 1) % _minimumShakes;
_shakeRecordList[_shakeRecordIndex] = record;
CheckForShakes();
}
}
void WrappedSubjectCurrentValueChanged(object sender, SensorReadingEventArgs <GyroscopeReading> e)
{
CurrentValueChangedRelay(sender, new SensorReadingEventArgs <GyroscopeSensorReading>()
{
SensorReading = new GyroscopeSensorReading(e.SensorReading)
});
}
void compass_CurrentValueChanged(object sender, SensorReadingEventArgs <CompassReading> e)
{
Dispatcher.BeginInvoke(() =>
{
if (calibrating)
{
accuracyTextBlock.Text = String.Format("{0:0}", e.SensorReading.HeadingAccuracy);
if (e.SensorReading.HeadingAccuracy <= 10)
{
accuracyTextBlock.Foreground = new SolidColorBrush(Colors.Green);
}
}
else
{
PositionAndRotateImage(oldPoint, AdjustHeading(e.SensorReading.TrueHeading));
//CompassReading.Text = AdjustHeading(e.SensorReading.TrueHeading).ToString();
if (augmentedReality.Mode == AugmentedPlacemarks.AugmentedMode.Explorer)
{
DisplayMarkers(AdjustHeading(e.SensorReading.TrueHeading));
}
else if (augmentedReality.Mode == AugmentedPlacemarks.AugmentedMode.Navigator)
{
DisplayNavigationMarker(AdjustHeading(e.SensorReading.TrueHeading));
}
}
});
}
void gyroscope_CurrentValueChanged(object sender, SensorReadingEventArgs<GyroscopeReading> e)
{
var reading = e.SensorReading;
var rate = reading.RotationRate;
this.readingAvailable.Invoke<GyroReading>(
sender,
new GyroReading(reading.Timestamp, rate.X, rate.Y, rate.Z));
}
private void LeerEstado(object sender, SensorReadingEventArgs<AccelerometerReading> e) {
Dispatcher.BeginInvoke(() =>
{
txbox_x.Text = e.SensorReading.Acceleration.X.ToString();
txbox_y.Text = e.SensorReading.Acceleration.Y.ToString();
txbox_z.Text = e.SensorReading.Acceleration.Z.ToString();
});
}
/// <summary>
/// Gyroscopes the current value changed.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The e.</param>
private void GyroscopeCurrentValueChanged(object sender, SensorReadingEventArgs<GyroscopeReading> e)
{
if (_gyroscope.IsDataValid)
{
LatestReading = e.SensorReading.RotationRate.AsVector3();
readingAvailable.Invoke(this, this.LatestReading);
}
}
void gyro_CurrentValueChanged(object sender, SensorReadingEventArgs<GyroscopeReading> e)
{
Dispatcher.BeginInvoke(() =>
{
txtRotRate.Text = string.Format("{0},{1},{2}", e.SensorReading.RotationRate.X, e.SensorReading.RotationRate.Y, e.SensorReading.RotationRate.Z);
txtTimestamp.Text = e.SensorReading.Timestamp.ToString();
});
}
void gyro_curval_changed(object sender, SensorReadingEventArgs <GyroscopeReading> e)
{
isDataValid = _gyroscope.IsDataValid;
if (isDataValid)
{
rotation_rate = e.SensorReading.RotationRate;
}
}
void _compass_CurrentValueChanged(object sender, SensorReadingEventArgs <CompassReading> e)
{
lock (_locker)
{
_trueHeading = e.SensorReading.TrueHeading.ToString();
Monitor.Pulse(_locker);
}
}
private void AccelerometerCurrentValueChanged(object sender, SensorReadingEventArgs <AccelerometerReading> e)
{
_acceleration = e.SensorReading.Acceleration;
lock (_lock)
{
_info.Update(_acceleration);
}
}
void _compass_CurrentValueChanged(object sender, SensorReadingEventArgs <CompassReading> e)
{
string callBack = string.Format("compass.onCompassSuccess({0:0.00})", e.SensorReading.TrueHeading);
Deployment.Current.Dispatcher.BeginInvoke(() => {
this.webBrowser1.InvokeScript("eval", callBack);
});
}
/// <summary>
/// Gyroscopes the current value changed.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The e.</param>
private void GyroscopeCurrentValueChanged(object sender, SensorReadingEventArgs <GyroscopeReading> e)
{
if (_gyroscope.IsDataValid)
{
LatestReading = e.SensorReading.RotationRate.AsVector3();
readingAvailable.Invoke(this, this.LatestReading);
}
}
private void CompassOnCurrentValueChanged(object sender, SensorReadingEventArgs <CompassReading> e)
{
var heading = (float)e.SensorReading.MagneticHeading + 90;
Dispatcher.BeginInvoke(() => CompassIndicator.ControllerHeading = heading);
_droneController.ControllerHeading = heading;
_droneController.ControllerHeadingAccuracy = (float)e.SensorReading.HeadingAccuracy;
}
private void _motion_CurrentValueChanged(object sender, SensorReadingEventArgs <MotionReading> e)
{
double motionDelta = 0.01;
if (!_motion.IsDataValid)
{
return;
}
if (Math.Abs(e.SensorReading.Attitude.Yaw - _yaw) > motionDelta)
{
_yaw = e.SensorReading.Attitude.Yaw;
}
if (Math.Abs(e.SensorReading.Attitude.Roll - _roll) > motionDelta)
{
_roll = e.SensorReading.Attitude.Roll;
}
if (Math.Abs(e.SensorReading.Attitude.Pitch - _pitch) > motionDelta)
{
_pitch = e.SensorReading.Attitude.Pitch;
}
Dispatcher.BeginInvoke(delegate()
{
if (myVM.ClickedNearbyLocation != null)
{
myVM.ClickedNearbyLocation.CalculateHeadingAngle(MathHelper.ToDegrees(_yaw));
}
});
if (_onDragEndAnimation)
{
return;
}
if (_gestureState == GestureStateEnum.OnFreeDrag)
{
_cameraMatrixBehindDrag = Matrix.CreateLookAt(new Vector3(0, 0, 0), new Vector3(0, 0, -1), Vector3.Up);
_cameraMatrixBehindDrag *= Matrix.CreateRotationY(-_yaw);
_cameraMatrixBehindDrag *= Matrix.CreateRotationZ(_roll);
_cameraMatrixBehindDrag *= Matrix.CreateRotationX(-_pitch + MathHelper.PiOver2);
}
else
{
_cameraMatrix = Matrix.CreateLookAt(new Vector3(0, 0, 0), new Vector3(0, 0, -1), Vector3.Up);
_cameraMatrix *= Matrix.CreateRotationY(-_yaw);
_cameraMatrix *= Matrix.CreateRotationZ(_roll);
_cameraMatrix *= Matrix.CreateRotationX(-_pitch + MathHelper.PiOver2);
//rotate radar
Dispatcher.BeginInvoke(delegate()
{
(radarCanvas.RenderTransform as System.Windows.Media.RotateTransform).Angle = MathHelper.ToDegrees((_yaw));
});
}
}
void _compass_CurrentValueChanged(object sender, SensorReadingEventArgs<CompassReading> e)
{
lock (_locker)
{
_trueHeading = e.SensorReading.TrueHeading.ToString();
Monitor.Pulse(_locker);
}
}
void _accelerometer_CurrentValueChanged(object sender, SensorReadingEventArgs <AccelerometerReading> e)
{
string callBack = string.Format("accelerometer.onAccelerometerSuccess({0:0.00}, {1:0.00}, {2:0.00})",
e.SensorReading.Acceleration.X, e.SensorReading.Acceleration.Y, e.SensorReading.Acceleration.Z);
Deployment.Current.Dispatcher.BeginInvoke(() => {
this.webBrowser1.InvokeScript("eval", callBack);
});
}
private void CompassCurrentValueChanged(object sender, SensorReadingEventArgs <CompassReading> e)
{
var handler = CurrentValueChanged;
if (handler != null)
{
handler(sender, new CompassDataChangedEventArgs(new CompassData(e.SensorReading)));
}
}
/// <summary>
/// Sensor listener event
/// </summary>
private void accelerometer_CurrentValueChanged(object sender, SensorReadingEventArgs <AccelerometerReading> e)
{
this.SetStatus(Running);
PluginResult result = new PluginResult(PluginResult.Status.OK, GetCurrentAccelerationFormatted());
result.KeepCallback = true;
DispatchCommandResult(result);
}
void GyroscopeCurrentValueChanged(object sender, SensorReadingEventArgs<GyroscopeReading> e)
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
tbXCoordinate.Text = e.SensorReading.RotationRate.X.ToString();
tbYCoordinate.Text = e.SensorReading.RotationRate.Y.ToString();
tbZCoordinate.Text = e.SensorReading.RotationRate.Z.ToString();
});
}
public void motion_CurrentValueChanged(object sender, SensorReadingEventArgs<MotionReading> e)
{
if (motion.IsDataValid)
{
values[0] = e.SensorReading.Attitude.Yaw;
values[1] = e.SensorReading.Attitude.Pitch;
values[2] = e.SensorReading.Attitude.Roll;
}
}
private void CurrentValueChangedRelay(object sender, SensorReadingEventArgs <MotionSensorReading> e)
{
var handler = CurrentValueChanged;
if (handler != null)
{
handler(sender, e);
}
}
private void ProcessAccelerometerReading(SensorReadingEventArgs<AccelerometerReading> e)
{
Vector3 reading = e.SensorReading.Acceleration;
txtTime.Text = e.SensorReading.Timestamp.ToString();
txtX.Text = reading.X.ToString();
txtY.Text = reading.Y.ToString();
txtZ.Text = reading.Z.ToString();
ProcessPRY(e);
}
void compass_CurrentValueChanged(object sender, SensorReadingEventArgs<CompassReading> e)
{
AddJOValue("trueHeading", e.SensorReading.TrueHeading);
AddJOValue("magneticHeading", e.SensorReading.MagneticHeading);
AddJOValue("headingAccuracy", e.SensorReading.HeadingAccuracy);
AddJOValue("rawMagneticReadingX", e.SensorReading.MagnetometerReading.X);
AddJOValue("rawMagneticReadingY", e.SensorReading.MagnetometerReading.Y);
AddJOValue("rawMagneticReadingZ", e.SensorReading.MagnetometerReading.Z);
AddJOValue("timestamp", DeviceTools.GetUnixTime());
}
private static void AccelerometerOnCurrentValueChanged(object sender, SensorReadingEventArgs<AccelerometerReading> sensorReadingEventArgs)
{
if (readingAvailable != null)
{
var ac = sensorReadingEventArgs.SensorReading.Acceleration;
readingAvailable.Invoke(
accelerometer,
new AccelometerStatus(ac.X, ac.Y, ac.Z));
}
}
private void _accelerometer_CurrentValueChanged(object sender, SensorReadingEventArgs<AccelerometerReading> e)
{
lock (_locker)
{
_xyz = string.Format("{0:0.00}, {1:0.00}, {2:0.00}", e.SensorReading.Acceleration.X,
e.SensorReading.Acceleration.Y,
e.SensorReading.Acceleration.Z);
Monitor.Pulse(_locker);
}
}
void accelerometer_CurrentValueChanged(object sender, SensorReadingEventArgs<AccelerometerReading> e)
{
// Note that this event handler is called from a background thread
// and therefore does not have access to the UI thread. To update
// the UI from this handler, use Dispatcher.BeginInvoke() as shown.
Dispatcher.BeginInvoke(() => { statusTextBlock.Text = "in CurrentValueChanged"; });
isDataValid = accelerometer.IsDataValid;
acceleration = e.SensorReading.Acceleration;
}
void LeituraAcelerometro(object sender, SensorReadingEventArgs<AccelerometerReading> e)
{
Vector3 acceleration = e.SensorReading.Acceleration;
Dispatcher.BeginInvoke(() => {
string x = acceleration.X.ToString("f");
string y = acceleration.Y.ToString("f");
string z = acceleration.Z.ToString("f");
tb.Text = x +" " + y + " "+ z;
});
}
void acc_CurrentValueChanged(object sender, SensorReadingEventArgs<AccelerometerReading> e)
{
// wordt uitgevoerd indien je beweegt met de phone
Dispatcher.BeginInvoke(() =>
{
SliderX.Value = e.SensorReading.Acceleration.X;
SliderY.Value = e.SensorReading.Acceleration.Y;
SliderZ.Value = e.SensorReading.Acceleration.Z;
});
}
protected void acc_CurrentValueChanged(object sender, SensorReadingEventArgs<AccelerometerReading> e)
{
Vector3 a = e.SensorReading.Acceleration;
Vector2 v = new Vector2();
// 値を計算
a.X *= 10;
if (a.X > 0)
{
v.X = (a.X > 5 ? 5f : a.X);
}
else
{
v.X = (a.X > -5 ? -5f : a.X);
}
a.Y *= 10;
if (a.Y > 0)
{
v.Y = (a.Y > 5 ? 5f : a.Y);
}
else
{
v.Y = (a.Y > -5 ? -5f : a.Y);
}
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
if (scene != SCENE.PLAY)
{
return;
}
// 自機を移動
flayer.pos.X += a.X;
if (flayer.pos.X < 0)
{
flayer.pos.X = graphics.PreferredBackBufferWidth;
}
else if (flayer.pos.X > graphics.PreferredBackBufferWidth)
{
flayer.pos.X = 0;
}
flayer.pos.Y -= a.Y;
if (flayer.pos.Y < 0)
{
flayer.pos.Y = graphics.PreferredBackBufferHeight;
}
else if (flayer.pos.Y > graphics.PreferredBackBufferHeight)
{
flayer.pos.Y = 0;
}
});
}
private void AccelerometerOnCurrentValueChanged(object sender,
SensorReadingEventArgs<AccelerometerReading>
sensorReadingEventArgs)
{
var handler = ReadingAvailable;
if (handler == null)
return;
var reading = ToReading(sensorReadingEventArgs.SensorReading);
handler(this, new MvxValueEventArgs<Reading>(reading));
}
private void gyro_CurrentValueChanged(object sender, SensorReadingEventArgs<GyroscopeReading> e)
{
if (lastTimestamp == DateTimeOffset.MinValue)
{
lastTimestamp = e.SensorReading.Timestamp;
}
else
{
TimeSpan difference = e.SensorReading.Timestamp - lastTimestamp;
rotation = e.SensorReading.RotationRate * (float)difference.TotalSeconds;
lastTimestamp = e.SensorReading.Timestamp;
Dispatcher.BeginInvoke(() => UpdateUI(rotation));
}
}
void motion_CurrentValueChanged(object sender, SensorReadingEventArgs<MotionReading> e)
{
Dispatcher.BeginInvoke(() =>
{
txtAccel.Text = string.Format("{0}, {1}, {2}", e.SensorReading.DeviceAcceleration.X, e.SensorReading.DeviceAcceleration.Y, e.SensorReading.DeviceAcceleration.Z);
txtGravity.Text = string.Format("{0}, {1}, {2}", e.SensorReading.Gravity.X, e.SensorReading.Gravity.Y, e.SensorReading.Gravity.Z);
txtRotRate.Text = string.Format("{0}, {1}, {2}", e.SensorReading.DeviceRotationRate.X, e.SensorReading.DeviceRotationRate.Y, e.SensorReading.DeviceRotationRate.Z);
txtPitch.Text = e.SensorReading.Attitude.Pitch.ToString();
txtRoll.Text = e.SensorReading.Attitude.Roll.ToString();
txtYaw.Text = e.SensorReading.Attitude.Yaw.ToString();
});
}
private void compass_CurrentValueChanged(object sender, SensorReadingEventArgs<CompassReading> e)
{
if (isCalibrating)
{
if (e.SensorReading.HeadingAccuracy < 20.0)
{
isCalibrating = false;
Dispatcher.BeginInvoke(UpdateCalibrateUI);
}
}
else
{
Dispatcher.BeginInvoke(() => UpdateDataUI(e.SensorReading));
}
}
private void giroscopio_CurrentValueChanged(object sender, SensorReadingEventArgs<GyroscopeReading> e)
{
Dispatcher.BeginInvoke(() =>
{
Vector3 v3 = e.SensorReading.RotationRate;
txBlock_x.Text += v3.X.ToString();
txBlock_y.Text += v3.Y.ToString();
txBlock_z.Text += v3.Z.ToString();
lnx.X2 = lnx.X1 + v3.X * 200;
lny.Y2 = lny.Y1 + v3.Y * 200;
lnx.X2 = lnz.X1 + v3.Z * 100;
lnz.Y2 = lnx.Y1 + v3.Z * 100;
});
}
void AccelerometerCurrentValueChanged(object sender, SensorReadingEventArgs<AccelerometerReading> e)
{
// 50 times per second
// Dispatcher.BeginInvoke( Action ); to call UI Thread
// The Dispatcher class guarantees that this
// code will be executed on the UI thread.
//Deployment.Current.Dispatcher.BeginInvoke(() =>
//{
// // Thread-safe
// tbXCoordinate.Text = e.SensorReading.Acceleration.X.ToString("0.000");
// tbYCoordinate.Text = e.SensorReading.Acceleration.Y.ToString("0.000");
// tbZCoordinate.Text = e.SensorReading.Acceleration.Z.ToString("0.000");
//});
}
public GameplayScreen()
{
TransitionOnTime = TimeSpan.FromSeconds(0.0);
TransitionOffTime = TimeSpan.FromSeconds(0.0);
Accelerometer = new Accelerometer();
if (Accelerometer.State == SensorState.Ready)
{
Accelerometer.CurrentValueChanged += (s, e) =>
{
accelState = e;
};
Accelerometer.Start();
}
}
private void ProcessPRY(SensorReadingEventArgs<AccelerometerReading> e)
{
Vector3 reading = e.SensorReading.Acceleration;
txtPitch.Text = ((180 / Math.PI) * (
Math.Atan(reading.X/Math.Sqrt(Math.Pow(reading.Y,2))) + Math.Pow(reading.Z,2))).ToString();
txtRoll.Text = ((180 / Math.PI) * (
Math.Atan(reading.Y / Math.Sqrt(Math.Pow(reading.X, 2))) + Math.Pow(reading.Z, 2))).ToString();
txtYaw.Text = ((180 / Math.PI) * (
Math.Atan(Math.Sqrt(Math.Pow(reading.X, 2))) + Math.Pow(reading.Y, 2)/reading.Z)).ToString();
}
void accelerometer_CurrentValueChanged(object sender, SensorReadingEventArgs<AccelerometerReading> e)
{
// Call UpdateUI on the UI thread and pass the AccelerometerReading.
//Dispatcher.BeginInvoke(() => UpdateUI(e.SensorReading));
Dispatcher.BeginInvoke(() =>
{
string x = e.SensorReading.Acceleration.X.ToString();
string y = e.SensorReading.Acceleration.Y.ToString();
string z = e.SensorReading.Acceleration.Z.ToString();
System.Diagnostics.Debug.WriteLine("X: "+ x + "Y: "+ y +"Z: " +z);
UpdateUI(e.SensorReading);
}
);
}
