protected void AddFrame(ActivityTimeFrame timeFrame)
{
lock (this)
{
_timeFrames.Add(timeFrame);
_lastFrame = timeFrame;
}
FrameAdded?.Invoke(this, timeFrame);
}
private void AddTimeFrame(ActivityTimeFrame timeFrame)
{
lock (_activity)
{
_activity.AddTimeFrame(timeFrame);
if (_exporter != null)
{
_exporter.WriteTimeFrame(timeFrame); // save the activitiy
}
}
}
public ActivityTimeFrame Clone()
{
var frame = new ActivityTimeFrame
{
Type = Type,
Timestamp = Timestamp,
Position = Position,
Distance = Distance,
Altitude = Altitude,
HeartRate = HeartRate,
RRValues = RRValues,
Power = Power,
Cadence = Cadence,
Speed = Speed,
};
return(frame);
}
public override void AddTimeFrame(ActivityTimeFrame timeFrame)
{
if (!timeFrame.Distance.HasValue)
{
// supply timeframe with the actual distance
timeFrame.Distance = Distance;
}
// Add timeframe to the last lap
var currentLap = (_laps.Current ?? NewLap()) as MemoryLap;
if (currentLap != null)
{
currentLap.AddTimeFrame(timeFrame);
}
// Add timeframe
base.AddTimeFrame(timeFrame);
}
/// <summary>
/// Resets the lap
/// </summary>
public virtual void Reset()
{
_lastFrame = null;
AvgCadence = MaxCadence = 0;
AvgHeartRate = MaxHeartRate = 0;
AvgPower = MaxPower = 0;
_avgSpeed.Value = 0;
_maxSpeed.Value = 0;
_distance = new Distance(0, DistanceUnit.Meter);
StartTime = DateTime.MinValue;
_elapsedTime = 0;
_movingTime = 0;
_timeFrames.Clear();
_cadenceCalculator.Reset();
_hrCalculator.Reset();
_powerCalculator.Reset();
_moveCalculator.Reset();
_ascentCalculator.Reset();
Reseted?.Invoke(this, EventArgs.Empty);
}
private void OnTick(DateTime now)
{
if (!IsStarted || !IsActive)
{
return;
}
_lastRecordedTime = now;
var timeFrame = new ActivityTimeFrame();
timeFrame.Timestamp = now;
// Get useful data from detected sensors
if (SensorService != null)
{
if (SensorService.Gps != null)
{
// Position from GPS
var status = SensorService.Gps.Geolocator.Status;
if (!status.Position.IsEmpty)
{
timeFrame.Position = status.Position;
}
}
if (SensorService.HeartRateMonitor != null)
{
var hrData = SensorService.HeartRateMonitor.HeartRateData;
if (hrData != null)
{
timeFrame.HeartRate = (byte)hrData.HeartRateValue;
}
}
if (SensorService.SpeedSensor != null)
{
// trying to get speed from speed sensor first
timeFrame.Speed = SensorService.SpeedSensor.Speed;
}
else if (SensorService.Gps != null)
{
// fallback to GPS
if (SensorService.Gps.Geolocator.Status != null)
{
var speed = (float)SensorService.Gps.Geolocator.Status.Speed;
if (speed > 0)
{
timeFrame.Speed = new Speed(speed, SpeedUnit.MeterPerSecond);
}
}
}
// update cadence data
if (SensorService.CadenceSensor != null)
{
timeFrame.Cadence = SensorService.CadenceSensor.Cadence.RevolutionsPerMinute;
}
// update power data
if (SensorService.BikePowerMeter != null)
{
if (SensorService.BikePowerMeter.Power.HasValue)
{
timeFrame.Power = (ushort)SensorService.BikePowerMeter.Power.Watts;
}
}
}
if (AutoPause)
{
var speedMeterPerSecond = timeFrame.Speed.GetValueOrDefault().GetValueAs(SpeedUnit.MeterPerSecond);
// check auto-pause speed limit
if (speedMeterPerSecond < AutoPauseSpeedLimit.GetValueAs(SpeedUnit.MeterPerSecond) && !_autoPaused)
{
_autoPaused = true;
AddTimeFrame(new ActivityTimeFrame {
Timestamp = now, Type = ActivityTimeFrameType.Stop
});
AutoPaused?.Invoke(this, EventArgs.Empty);
}
else if (_autoPaused && speedMeterPerSecond >= AutoPauseSpeedLimit.GetValueAs(SpeedUnit.MeterPerSecond))
{
_autoPaused = false;
AddTimeFrame(new ActivityTimeFrame {
Timestamp = now, Type = ActivityTimeFrameType.Start
});
AutoResumed?.Invoke(this, EventArgs.Empty);
}
if (_autoPaused)
{
return;
}
}
AddTimeFrame(timeFrame);
if (_streamDest != null)
{
_streamDest.Flush();
}
Modified?.Invoke(this, EventArgs.Empty);
}
public virtual void AddTimeFrame(ActivityTimeFrame timeFrame)
{
TimeSpan elapsedTime = TimeSpan.FromSeconds(0);
if (_timeFrames.Count > 0)
{
// calculate elapsed and moving time
elapsedTime = timeFrame.Timestamp.Subtract(_lastFrame.Timestamp);
}
_elapsedTime += (float)elapsedTime.TotalSeconds;
if (timeFrame.Type != ActivityTimeFrameType.Active)
{
AddFrame(timeFrame);
_moveCalculator.Reset();
_ascentCalculator.Reset();
return;
}
_movingTime += (float)elapsedTime.TotalSeconds;
// Calculating averages, sums
// We should handle when multiple frames have been registered with the same timestamp.
// Movescount does this.
// update move calculator
if (timeFrame.Position.HasValue)
{
_moveCalculator.Add(timeFrame.Position.Value, elapsedTime);
var altitude = timeFrame.Position.Value.Altitude;
if (altitude != 0)
{
_ascentCalculator.AddAltitude(altitude);
if (_ascentCalculator.HasTresholdReached)
{
if (_ascentCalculator.Ascent > 0)
{
Ascent += _ascentCalculator.Ascent;
}
else
{
Descent += -_ascentCalculator.Ascent;
}
_ascentCalculator.Reset();
_ascentCalculator.AddAltitude(altitude);
}
}
}
else
{
_moveCalculator.Reset();
}
float currentSpeed = 0;
if (timeFrame.Speed.HasValue)
{ // has speed data
currentSpeed = timeFrame.Speed.Value.GetValueAs(SpeedUnit.MeterPerSecond);
}
else
{
// fallback to moveCalculator
currentSpeed = _moveCalculator.CurrentSpeed;
}
if (elapsedTime.TotalSeconds > 0)
{
_speedCalculator.Add(currentSpeed);
}
else if (timeFrame.Speed.HasValue)
{
_speedCalculator.UpdateLast(currentSpeed); // we have more precise speed data in the same timeframe
}
_maxSpeed.Value = _speedCalculator.Maximum;
_avgSpeed.Value = _speedCalculator.Average;
_distance.Value += (float)(elapsedTime.TotalSeconds * currentSpeed);
if (timeFrame.Power.HasValue)
{
_powerCalculator.Add(timeFrame.Power.Value);
MaxPower = Convert.ToInt32(_powerCalculator.Maximum);
AvgPower = Convert.ToInt32(_powerCalculator.Average);
}
if (timeFrame.HeartRate.HasValue)
{
_hrCalculator.Add(timeFrame.HeartRate.Value);
MaxHeartRate = Convert.ToInt32(_hrCalculator.Maximum);
AvgHeartRate = Convert.ToInt32(_hrCalculator.Average);
}
if (timeFrame.Cadence.HasValue)
{
_cadenceCalculator.Add(timeFrame.Cadence.Value);
MaxCadence = Convert.ToInt32(_cadenceCalculator.Maximum);
AvgCadence = Convert.ToInt32(_cadenceCalculator.Average);
}
if (StartTime == DateTime.MinValue)
{
StartTime = timeFrame.Timestamp;
}
if (_lastFrame == null || elapsedTime.TotalSeconds > 0)
{
AddFrame(timeFrame);
}
}
