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());
 }

 /// <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());
 }

		/// <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 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;
                    }
                });
            }
        }

        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 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 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));
 }

		/// <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 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();
         });
 }

 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;
     }
 }

 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();
         });
 }

        void _compass_CurrentValueChanged(object sender, SensorReadingEventArgs<CompassReading> e)
        {
            lock (_locker)
              {

            _trueHeading = e.SensorReading.TrueHeading.ToString();
            Monitor.Pulse(_locker);
              }
        }

 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));
     }
 }

 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 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);
       }
 }

        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 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;
            });
        }

        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;
     });
 }

        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;
                }
            });
        }