public void OnAcceleromterLaunchDetected()    // IAcceleromterListener
 {
     if (countdown.ElapsedMilliseconds > 2000) // respect settle-down-timer of PageRun
     {
         if (listener != null)
         {
             status = "launchDetected";
             stopwatch.Start();
             Device.StartTimer(TimeSpan.FromMilliseconds(UPDATE_RATE_MS), OnTimer);
             listener.OnAcceleromterLaunchDetected();
         }
     }
 }
Exemple #2
0
        public void OnSensorChanged(SensorEvent e) // ISensorEventListener
        {
            if (e != null)
            {
                if ((e.Sensor.Type == SensorType.LinearAcceleration) || (e.Sensor.Type == SensorType.Accelerometer))
                {
                    long launchTimeNow = stopwatch.ElapsedMilliseconds;

                    sensorX = e.Values[0];
                    sensorY = e.Values[1];
                    sensorZ = e.Values[2];

                    sensorTimestamp = e.Timestamp;

                    // e.Timestamp = nanoseconds since 01. januar 1970
                    // e.Timestamp / 1 000 000 000 = seconds

                    if (isFirstRun)
                    {
                        isFirstRun              = false;
                        launchTimeLastUpdate    = launchTimeNow;
                        launchTimeDetectedStart = 0;
                        sensorTimestampFirst    = sensorTimestamp;
                        sensorAcceleration      = 0;
                        sensorSpeed             = 0;
                        DeviceDebugAndroid.LogToFileMethodStatic("first values received");
                        DeviceDebugAndroid.LogToFileMethodStatic("accelerometer info: " + GetInfo());
                    }
                    else
                    {
                        sensorXDelta = sensorX - sensorXLast;
                        sensorYDelta = sensorY - sensorYLast;
                        sensorZDelta = sensorZ - sensorZLast;

                        sensorTimestampDelta = sensorTimestampLast - sensorTimestamp;

                        var dt           = sensorTimestampDelta / 1000000000.0f; // from nanoseconds to seconds
                        var sensorSpeedX = sensorXDelta * dt;                    // from acceleration to velocity (x component)
                        var sensorSpeedY = sensorYDelta * dt;                    // from acceleration to velocity (y component)
                        var sensorSpeedZ = sensorZDelta * dt;                    // from acceleration to velocity (z component)

                        // speed magnitude of all components
                        var magnitude = (float)Math.Sqrt(sensorSpeedX * sensorSpeedX + sensorSpeedY * sensorSpeedY + sensorSpeedZ * sensorSpeedZ);

                        // integrate the magnitude onto previous speed
                        // take the direction into account
                        if (sensorIsAccelerating)
                        {
                            sensorSpeed += magnitude;
                        }
                        else
                        {
                            sensorSpeed -= magnitude;
                        }

                        // acceleration calculation
                        var sensorXCompensated = sensorX - sensorAxisOffsetX;
                        var sensorYCompensated = sensorY - sensorAxisOffsetY;
                        var sensorZCompensated = sensorZ - sensorAxisOffsetZ;

                        // acceleration magnitude of all components
                        sensorAcceleration = (float)Math.Sqrt(sensorXCompensated * sensorXCompensated +
                                                              sensorYCompensated * sensorYCompensated +
                                                              sensorZCompensated * sensorZCompensated);

                        if (isRawDataLoggingEnabled)
                        {
                            DeviceDebugAndroid.LogToFileSensorStatic(GetTimeStamp(), sensorX, sensorY, sensorZ, sensorAcceleration);
                        }

                        long launchTimeDiff = launchTimeNow - launchTimeLastUpdate;

                        if (launchTimeDiff > launchTimeUpdateInterval)
                        {
                            launchTimeLastUpdate = launchTimeNow;
                            var launchForce = Math.Abs(sensorXDelta + sensorYDelta + sensorZDelta);

                            if (launchForce * 10 > launchForceDetectLimit)
                            {
                                if (launchTimeDetectedStart == 0)
                                {
                                    launchTimeDetectedStart = launchTimeNow;
                                }

                                if (launchTimeNow - launchTimeDetectedStart > launchTimeDetectLimit)
                                {
                                    if (listener != null)
                                    {
                                        listener.OnAcceleromterLaunchDetected();
                                        launchTimeDetectedStart = 0;
                                    }
                                }
                            }
                        }
                    }

                    sensorXLast         = sensorX;
                    sensorYLast         = sensorY;
                    sensorZLast         = sensorZ;
                    sensorTimestampLast = sensorTimestamp;

                    if (listener != null)
                    {
                        listener.OnAcceleromterUpdate();
                    }
                }
            }
        }