Ejemplo n.º 1
0
        public void OnIncomingMesg(object sender, IncomingMesgEventArgs e)
        {
            switch (e.mesg.Num)
            {
            case MesgNum.FileId:
                FileIdMesg fileIdMesg = new FileIdMesg(e.mesg);
                if (fileIdMesg.GetType() == File.Activity)
                {
                    isActivityFile = true;
                }
                break;

            case MesgNum.Session:
                SessionMesg sessionMesg = new SessionMesg(e.mesg);
                record_range_start_time = new DateTime(sessionMesg.GetStartTime());
                break;

            case MesgNum.Hr:
                if (hr_start_index == HrToRecordMesgBroadcastPlugin.INVALID_INDEX)
                {
                    // Mark the first appearance of an HR message
                    hr_start_index     = mesg_count;
                    hr_start_sub_index = 0;
                }
                break;

            default:
                break;
            } // switch

            mesg_count++;
        }
Ejemplo n.º 2
0
    public List <SessionMessages> ParseSessions()
    {
        if (!IsActivityFile)
        {
            throw new Exception($"Expected FIT File Type: Activity, recieved File Type: {_messages?.FileId?.GetType()}");
        }

        // When there are no Sessions but there are Records create a Session message to recover as much data as possible
        if (_messages.Sessions.Count == 0 && _messages.Records.Count > 0)
        {
            Dynastream.Fit.DateTime startTime = _messages.Records[0].GetTimestamp();
            Dynastream.Fit.DateTime timestamp = _messages.Records[_messages.Records.Count - 1].GetTimestamp();

            var session = new SessionMesg();
            session.SetStartTime(startTime);
            session.SetTimestamp(timestamp);
            session.SetTotalElapsedTime(timestamp.GetTimeStamp() - startTime.GetTimeStamp());
            session.SetTotalTimerTime(timestamp.GetTimeStamp() - startTime.GetTimeStamp());

            _messages.Sessions.Add(session);
        }

        int recordsTaken = 0;

        var sessions = new List <SessionMessages>(_messages.Sessions.Count);

        foreach (SessionMesg sessionMesg in _messages.Sessions)
        {
            var session = new SessionMessages(sessionMesg)
            {
                Laps = _messages.Laps.Skip(sessionMesg.GetFirstLapIndex() ?? 0).Take(sessionMesg.GetNumLaps() ?? 0).ToList(),

                ClimbPros   = _messages.ClimbPros.Where(climb => climb.Within(sessionMesg)).ToList(),
                Events      = _messages.Events.Where(evt => evt.Within(sessionMesg)).ToList(),
                DeviceInfos = _messages.DeviceInfos.Where(deviceInfo => deviceInfo.Within(sessionMesg)).ToList(),
                Lengths     = _messages.Lengths.Where(length => length.Overlaps(sessionMesg)).ToList(),
                Records     = _messages.Records.Skip(recordsTaken).Where(record => record.Within(sessionMesg)).ToList(),
                SegmentLaps = _messages.SegmentLaps.Where(segmentLap => segmentLap.Overlaps(sessionMesg)).ToList(),

                TimerEvents               = _messages.Events.Where(evt => evt.GetEvent() == Event.Timer && evt.Within(sessionMesg)).ToList(),
                FrontGearChangeEvents     = _messages.Events.Where(evt => evt.GetEvent() == Event.FrontGearChange && evt.Within(sessionMesg)).ToList(),
                RearGearChangeEvents      = _messages.Events.Where(evt => evt.GetEvent() == Event.RearGearChange && evt.Within(sessionMesg)).ToList(),
                RiderPositionChangeEvents = _messages.Events.Where(evt => evt.GetEvent() == Event.RiderPositionChange && evt.Within(sessionMesg)).ToList(),

                Activity                  = _messages.Activity,
                FileId                    = _messages.FileId,
                RecordFieldNames          = _messages.RecordFieldNames,
                RecordDeveloperFieldNames = _messages.RecordDeveloperFieldNames,
                UserProfile               = _messages.UserProfile,
                Workout                   = _messages.Workout,
                WorkoutSteps              = _messages.WorkoutSteps,
                ZonesTarget               = _messages.ZonesTarget,
            };

            recordsTaken += session.Records.Count;
            sessions.Add(session);
        }

        return(sessions);
    }
Ejemplo n.º 3
0
        public static ActivitySummary ToSummary(this SessionMesg msg)
        {
            ActivitySummary summary = new ActivitySummary();

            if (msg != null)
            {
                var startTime = msg.GetStartTime();
                if (startTime != null && startTime.GetDateTime() != MinTime)
                {
                    summary.StartTime = startTime.GetDateTime();
                }
                summary.ElapsedTime  = Convert.ToInt32(msg.GetTotalElapsedTime().GetValueOrDefault(0));
                summary.MovingTime   = Convert.ToInt32(msg.GetTotalTimerTime().GetValueOrDefault(0));
                summary.Distance     = new Distance(msg.GetTotalDistance().GetValueOrDefault(Distance.InvalidValue), DistanceUnit.Meter);
                summary.Sport        = msg.GetSport().GetValueOrDefault(Sport.Generic);
                summary.AvgHeartRate = msg.GetAvgHeartRate().GetValueOrDefault(FitExtensions.InvalidHeartRate);
                summary.MaxHeartRate = msg.GetMaxHeartRate().GetValueOrDefault(FitExtensions.InvalidHeartRate);
                summary.AvgCadence   = msg.GetAvgCadence().GetValueOrDefault(FitExtensions.InvalidCadence);
                summary.MaxCadence   = msg.GetMaxCadence().GetValueOrDefault(FitExtensions.InvalidCadence);
                summary.AvgPower     = msg.GetAvgPower().GetValueOrDefault(FitExtensions.InvalidPower);
                summary.MaxPower     = msg.GetMaxPower().GetValueOrDefault(FitExtensions.InvalidPower);
                summary.AvgSpeed     = new Speed {
                    Value = msg.GetAvgSpeed().GetValueOrDefault(FitExtensions.InvalidSpeed), Unit = SpeedUnit.MeterPerSecond
                };
                summary.MaxSpeed = new Speed {
                    Value = msg.GetMaxSpeed().GetValueOrDefault(FitExtensions.InvalidSpeed), Unit = SpeedUnit.MeterPerSecond
                };
                summary.Ascent  = msg.GetTotalAscent().GetValueOrDefault(0);
                summary.Descent = msg.GetTotalDescent().GetValueOrDefault(0);
            }

            return(summary);
        }
Ejemplo n.º 4
0
        public static bool Within(this Mesg mesg, SessionMesg session)
        {
            if (mesg.GetTimestamp() == null || session.GetStartTime() == null || session.GetEndTime() == null)
            {
                return(false);
            }

            return(mesg.GetTimestamp().GetDateTime() >= session.GetStartTime().GetDateTime() &&
                   mesg.GetTimestamp().GetDateTime() <= session.GetEndTime().GetDateTime());
        }
Ejemplo n.º 5
0
        public static bool Overlaps(this Mesg mesg, SessionMesg session)
        {
            if (mesg.GetStartTime() == null || mesg.GetEndTime() == null || session.GetStartTime() == null || session.GetEndTime() == null)
            {
                return(false);
            }

            return(Math.Max(mesg.GetStartTime().GetTimeStamp(), session.GetStartTime().GetTimeStamp()) <=
                   Math.Min(mesg.GetEndTime().GetTimeStamp(), session.GetEndTime().GetTimeStamp()));
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Adds a new session.
        /// </summary>
        private void HandleSessionMessage(object sender, MesgEventArgs e)
        {
            SessionMesg msg     = (SessionMesg)e.mesg;
            FitSession  session = new FitSession(msg, (Sessions.Count > 0) ? Sessions[Sessions.Count - 1].LastRecord + 1 : 0, Records.Count - 1);

            Sessions.Add(session);
            string     description = (session.FirstRecord < session.LastRecord) ? string.Format("{0} - {1}", session.FirstRecord, session.LastRecord) : session.FirstRecord.ToString();
            FitMessage message     = new FitMessage(Resources.Session, description);

            Messages.Add(message);
        }
Ejemplo n.º 7
0
        private static void OnSessionMesgEvent(object sender, MesgEventArgs e)
        {
            SessionMesg session = (SessionMesg)e.mesg;

            if (session.GetTotalCalories() < ushort.MaxValue)
            {
                tcx.Calories = (int)session.GetTotalCalories();
            }

            if (session.GetTotalDistance() < 1E6)
            {
                tcx.DistanceMeters = (double)session.GetTotalDistance();
            }
        }
Ejemplo n.º 8
0
        private static void OnSessionMesgEvent(object sender, MesgEventArgs e)
        {
            SessionMesg session = (SessionMesg)e.mesg;

            if (session.GetTotalCalories() < ushort.MaxValue)
            {
                tcx.Calories = (int)session.GetTotalCalories();
            }
            if (session.GetTotalDistance() < 1E6)
            {
                tcx.DistanceMeters = (double)session.GetTotalDistance();
            }

            tcx.AvgHeartRate = int.Parse(session.GetAvgHeartRate().ToString());

            tcx.MaxHeartRate = int.Parse(session.GetMaxHeartRate().ToString());
        }
Ejemplo n.º 9
0
        public static void Start(DateTime?start = null)
        {
            Trace.TraceInformation("Start()");
            var activityFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + "\\BeamNG.drive\\VeloActivities";

            if (!Directory.Exists(activityFolder))
            {
                Directory.CreateDirectory(activityFolder);
            }

            var filepath = activityFolder + "\\" + DateTime.Now.ToString("yyyy_MM_dd_HH_mm_ss") + ".fit";

            csvFile = new StreamWriter(filepath + ".csv", true);

            startTime     = start ?? DateTime.UtcNow;
            totalDistance = 0;

            // Create file encode object
            encoder = new Encode(ProtocolVersion.V20);

            fitDest = new FileStream(filepath, FileMode.Create, FileAccess.ReadWrite, FileShare.Read);
            encoder.Open(fitDest);

            var fileIdMesg = new FileIdMesg(); // Every FIT file MUST contain a 'File ID' message as the first message

            fileIdMesg.SetType(Dynastream.Fit.File.Activity);
            fileIdMesg.SetManufacturer(Manufacturer.Bryton);  // Types defined in the profile are available
            fileIdMesg.SetProduct(1704);
            fileIdMesg.SetSerialNumber(5122);
            fileIdMesg.SetTimeCreated(new Dynastream.Fit.DateTime(startTime));

            // Encode each message, a definition message is automatically generated and output if necessary
            encoder.Write(fileIdMesg);

            Resume(start);

            sessionMesg = new SessionMesg();
            sessionMesg.SetStartTime(new Dynastream.Fit.DateTime(startTime));

            currentLapMesg = new LapMesg();
            currentLapMesg.SetStartTime(new Dynastream.Fit.DateTime(startTime));
        }
Ejemplo n.º 10
0
        public void WriteSummary()
        {
            // Session message
            var sessionMsg = new SessionMesg();

            sessionMsg.SetStartTime(new DateTime(Activity.StartTime));
            sessionMsg.SetTotalElapsedTime(Activity.ElapsedTime);
            sessionMsg.SetTotalMovingTime(Activity.MovingTime);
            sessionMsg.SetSport(Activity.Sport);
            sessionMsg.SetTotalDistance(Activity.Distance.GetValueAs(DistanceUnit.Meter));
            sessionMsg.SetAvgSpeed(FitExtensions.GetValidSpeed(Activity.AvgSpeed.GetValueAs(SpeedUnit.MeterPerSecond)));
            sessionMsg.SetMaxSpeed(FitExtensions.GetValidSpeed(Activity.MaxSpeed.GetValueAs(SpeedUnit.MeterPerSecond)));
            sessionMsg.SetAvgHeartRate((byte)Activity.AvgHeartRate);
            sessionMsg.SetMaxHeartRate((byte)Activity.MaxHeartRate);
            sessionMsg.SetAvgPower((ushort)Activity.AvgPower);
            sessionMsg.SetMaxPower((ushort)Activity.MaxPower);
            sessionMsg.SetAvgCadence((byte)Activity.AvgCadence);
            sessionMsg.SetMaxCadence((byte)Activity.MaxCadence);
            sessionMsg.SetTotalAscent(Convert.ToUInt16(Activity.Ascent));
            sessionMsg.SetTotalDescent(Convert.ToUInt16(Activity.Descent));
            _encoder.Write(sessionMsg);
        }
Ejemplo n.º 11
0
        static public void Start()
        {
            var assettoFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + "\\Assetto Corsa\\SimCyclingActivities";

            if (!Directory.Exists(assettoFolder))
            {
                Directory.CreateDirectory(assettoFolder);
            }

            var filepath = assettoFolder + "\\" + System.DateTime.Now.ToString("yyyy_MM_dd_HH_mm_ss") + ".fit";

            var now = new DateTime(System.DateTime.Now);

            // Create file encode object
            encoder = new Encode(ProtocolVersion.V20);

            fitDest = new FileStream(filepath, FileMode.Create, FileAccess.ReadWrite, FileShare.Read);
            encoder.Open(fitDest);

            var fileIdMesg = new FileIdMesg(); // Every FIT file MUST contain a 'File ID' message as the first message

            fileIdMesg.SetType(Dynastream.Fit.File.Activity);
            fileIdMesg.SetManufacturer(Manufacturer.Dynastream);  // Types defined in the profile are available
            fileIdMesg.SetProduct(22);
            fileIdMesg.SetSerialNumber(1234);
            fileIdMesg.SetTimeCreated(now);

            // Encode each message, a definition message is automatically generated and output if necessary
            encoder.Write(fileIdMesg);

            sessionMesg = new SessionMesg();
            sessionMesg.SetStartTime(now);

            currentLapMesg = new LapMesg();
            currentLapMesg.SetStartTime(now);
        }
Ejemplo n.º 12
0
 public SessionMessages(SessionMesg session)
 {
     Session = session;
 }
Ejemplo n.º 13
0
        static public void CreateTimeBasedActivity()
        {
            const double TwoPI = Math.PI * 2.0;
            const double SemicirclesPerMeter = 107.173;
            const string FileName            = "ActivityEncodeRecipe.fit";

            var messages = new List <Mesg>();

            // The starting timestamp for the activity
            var startTime = new Dynastream.Fit.DateTime(System.DateTime.UtcNow);

            // Timer Events are a BEST PRACTICE for FIT ACTIVITY files
            var eventMesgStart = new EventMesg();

            eventMesgStart.SetTimestamp(startTime);
            eventMesgStart.SetEvent(Event.Timer);
            eventMesgStart.SetEventType(EventType.Start);
            messages.Add(eventMesgStart);

            // Create the Developer Id message for the developer data fields.
            var developerIdMesg = new DeveloperDataIdMesg();

            // It is a BEST PRACTICE to reuse the same Guid for all FIT files created by your platform
            byte[] appId = new Guid("00010203-0405-0607-0809-0A0B0C0D0E0F").ToByteArray();
            for (int i = 0; i < appId.Length; i++)
            {
                developerIdMesg.SetApplicationId(i, appId[i]);
            }
            developerIdMesg.SetDeveloperDataIndex(0);
            developerIdMesg.SetApplicationVersion(110);
            messages.Add(developerIdMesg);

            // Create the Developer Data Field Descriptions
            var doughnutsFieldDescMesg = new FieldDescriptionMesg();

            doughnutsFieldDescMesg.SetDeveloperDataIndex(0);
            doughnutsFieldDescMesg.SetFieldDefinitionNumber(0);
            doughnutsFieldDescMesg.SetFitBaseTypeId(FitBaseType.Float32);
            doughnutsFieldDescMesg.SetFieldName(0, "Doughnuts Earned");
            doughnutsFieldDescMesg.SetUnits(0, "doughnuts");
            doughnutsFieldDescMesg.SetNativeMesgNum(MesgNum.Session);
            messages.Add(doughnutsFieldDescMesg);

            FieldDescriptionMesg hrFieldDescMesg = new FieldDescriptionMesg();

            hrFieldDescMesg.SetDeveloperDataIndex(0);
            hrFieldDescMesg.SetFieldDefinitionNumber(1);
            hrFieldDescMesg.SetFitBaseTypeId(FitBaseType.Uint8);
            hrFieldDescMesg.SetFieldName(0, "Heart Rate");
            hrFieldDescMesg.SetUnits(0, "bpm");
            hrFieldDescMesg.SetNativeFieldNum(RecordMesg.FieldDefNum.HeartRate);
            hrFieldDescMesg.SetNativeMesgNum(MesgNum.Record);
            messages.Add(hrFieldDescMesg);

            // Every FIT ACTIVITY file MUST contain Record messages
            var timestamp = new Dynastream.Fit.DateTime(startTime);

            // Create one hour (3600 seconds) of Record data
            for (uint i = 0; i <= 3600; i++)
            {
                // Create a new Record message and set the timestamp
                var recordMesg = new RecordMesg();
                recordMesg.SetTimestamp(timestamp);

                // Fake Record Data of Various Signal Patterns
                recordMesg.SetDistance(i);                                                          // Ramp
                recordMesg.SetSpeed(1);                                                             // Flatline
                recordMesg.SetHeartRate((byte)((Math.Sin(TwoPI * (0.01 * i + 10)) + 1.0) * 127.0)); // Sine
                recordMesg.SetCadence((byte)(i % 255));                                             // Sawtooth
                recordMesg.SetPower((ushort)((i % 255) < 127 ? 150 : 250));                         // Square
                recordMesg.SetAltitude((float)Math.Abs(((double)i % 255.0) - 127.0));               // Triangle
                recordMesg.SetPositionLat(0);
                recordMesg.SetPositionLong((int)Math.Round(i * SemicirclesPerMeter));

                // Add a Developer Field to the Record Message
                var hrDevField = new DeveloperField(hrFieldDescMesg, developerIdMesg);
                recordMesg.SetDeveloperField(hrDevField);
                hrDevField.SetValue((byte)((Math.Sin(TwoPI * (0.01 * i + 10)) + 1.0) * 127.0)); // Sine

                // Write the Rercord message to the output stream
                messages.Add(recordMesg);

                // Increment the timestamp by one second
                timestamp.Add(1);
            }

            // Timer Events are a BEST PRACTICE for FIT ACTIVITY files
            var eventMesgStop = new EventMesg();

            eventMesgStop.SetTimestamp(timestamp);
            eventMesgStop.SetEvent(Event.Timer);
            eventMesgStop.SetEventType(EventType.StopAll);
            messages.Add(eventMesgStop);

            // Every FIT ACTIVITY file MUST contain at least one Lap message
            var lapMesg = new LapMesg();

            lapMesg.SetMessageIndex(0);
            lapMesg.SetTimestamp(timestamp);
            lapMesg.SetStartTime(startTime);
            lapMesg.SetTotalElapsedTime(timestamp.GetTimeStamp() - startTime.GetTimeStamp());
            lapMesg.SetTotalTimerTime(timestamp.GetTimeStamp() - startTime.GetTimeStamp());
            messages.Add(lapMesg);

            // Every FIT ACTIVITY file MUST contain at least one Session message
            var sessionMesg = new SessionMesg();

            sessionMesg.SetMessageIndex(0);
            sessionMesg.SetTimestamp(timestamp);
            sessionMesg.SetStartTime(startTime);
            sessionMesg.SetTotalElapsedTime(timestamp.GetTimeStamp() - startTime.GetTimeStamp());
            sessionMesg.SetTotalTimerTime(timestamp.GetTimeStamp() - startTime.GetTimeStamp());
            sessionMesg.SetSport(Sport.StandUpPaddleboarding);
            sessionMesg.SetSubSport(SubSport.Generic);
            sessionMesg.SetFirstLapIndex(0);
            sessionMesg.SetNumLaps(1);

            // Add a Developer Field to the Session message
            var doughnutsEarnedDevField = new DeveloperField(doughnutsFieldDescMesg, developerIdMesg);

            doughnutsEarnedDevField.SetValue(sessionMesg.GetTotalElapsedTime() / 1200.0f);
            sessionMesg.SetDeveloperField(doughnutsEarnedDevField);
            messages.Add(sessionMesg);

            // Every FIT ACTIVITY file MUST contain EXACTLY one Activity message
            var activityMesg = new ActivityMesg();

            activityMesg.SetTimestamp(timestamp);
            activityMesg.SetNumSessions(1);
            var timezoneOffset = (int)TimeZoneInfo.Local.BaseUtcOffset.TotalSeconds;

            activityMesg.SetLocalTimestamp((uint)((int)timestamp.GetTimeStamp() + timezoneOffset));
            activityMesg.SetTotalTimerTime(timestamp.GetTimeStamp() - startTime.GetTimeStamp());
            messages.Add(activityMesg);

            CreateActivityFile(messages, FileName, startTime);
        }
Ejemplo n.º 14
0
        static public void CreateLapSwimActivity()
        {
            // Example Swim Data representing a 500 yard pool swim using different strokes and drills.
            var swimData = new List <Dictionary <string, object> >()
            {
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 20U }, { "stroke", "Freestyle" }, { "strokes", 30U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 25U }, { "stroke", "Freestyle" }, { "strokes", 20U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 30U }, { "stroke", "Freestyle" }, { "strokes", 10U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 35U }, { "stroke", "Freestyle" }, { "strokes", 20U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Lap" }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Idle" }, { "duration", 60U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Lap" }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 20U }, { "stroke", "Backstroke" }, { "strokes", 30U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 25U }, { "stroke", "Backstroke" }, { "strokes", 20U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 30U }, { "stroke", "Backstroke" }, { "strokes", 10U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 35U }, { "stroke", "Backstroke" }, { "strokes", 20U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Lap" }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Idle" }, { "duration", 60U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Lap" }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 20U }, { "stroke", "Breaststroke" }, { "strokes", 30U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 25U }, { "stroke", "Breaststroke" }, { "strokes", 20U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 30U }, { "stroke", "Breaststroke" }, { "strokes", 10U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 35U }, { "stroke", "Breaststroke" }, { "strokes", 20U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Lap" }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Idle" }, { "duration", 60U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Lap" }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 20U }, { "stroke", "Butterfly" }, { "strokes", 30U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 25U }, { "stroke", "Butterfly" }, { "strokes", 20U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 30U }, { "stroke", "Butterfly" }, { "strokes", 10U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 35U }, { "stroke", "Butterfly" }, { "strokes", 20U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Lap" }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Idle" }, { "duration", 60U }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Lap" }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 40U }, { "stroke", "Drill" }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 40U }, { "stroke", "Drill" }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 40U }, { "stroke", "Drill" }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Active" }, { "duration", 40U }, { "stroke", "Drill" }
                },
                new Dictionary <string, object>()
                {
                    { "type", "Lap" }
                },
            };

            const string FileName = "ActivityEncodeRecipeLapSwim.fit";
            var          messages = new List <Mesg>();

            // The starting timestamp for the activity
            var startTime = new Dynastream.Fit.DateTime(System.DateTime.UtcNow);


            // Timer Events are a BEST PRACTICE for FIT ACTIVITY files
            var eventMesgStart = new EventMesg();

            eventMesgStart.SetTimestamp(startTime);
            eventMesgStart.SetEvent(Event.Timer);
            eventMesgStart.SetEventType(EventType.Start);
            messages.Add(eventMesgStart);

            //
            // Create a Length or Lap message for each item in the sample swim data. Calculate
            // distance, duration, and stroke count for each lap and the overall session.
            //

            // Session Accumulators
            uint   sessionTotalElapsedTime = 0;
            float  sessionDistance         = 0;
            ushort sessionNumLengths       = 0;
            ushort sessionNumActiveLengths = 0;
            ushort sessionTotalStrokes     = 0;
            ushort sessionNumLaps          = 0;

            // Lap accumulators
            uint   lapTotalElapsedTime = 0;
            float  lapDistance         = 0;
            ushort lapNumActiveLengths = 0;
            ushort lapNumLengths       = 0;
            ushort lapFirstLengthIndex = 0;
            ushort lapTotalStrokes     = 0;
            var    lapStartTime        = new Dynastream.Fit.DateTime(startTime);

            var    poolLength     = 22.86f;
            var    poolLengthUnit = DisplayMeasure.Statute;
            var    timestamp      = new Dynastream.Fit.DateTime(startTime);
            ushort messageIndex   = 0;

            foreach (var swimLength in swimData)
            {
                string type = (string)swimLength["type"];

                if (type.Equals("Lap"))
                {
                    // Create a Lap message, set its fields, and write it to the file
                    var lapMesg = new LapMesg();
                    lapMesg.SetMessageIndex(sessionNumLaps);
                    lapMesg.SetTimestamp(timestamp);
                    lapMesg.SetStartTime(lapStartTime);
                    lapMesg.SetTotalElapsedTime(lapTotalElapsedTime);
                    lapMesg.SetTotalTimerTime(lapTotalElapsedTime);
                    lapMesg.SetTotalDistance(lapDistance);
                    lapMesg.SetFirstLengthIndex(lapFirstLengthIndex);
                    lapMesg.SetNumActiveLengths(lapNumActiveLengths);
                    lapMesg.SetNumLengths(lapNumLengths);
                    lapMesg.SetTotalStrokes(lapTotalStrokes);
                    lapMesg.SetAvgStrokeDistance(lapDistance / lapTotalStrokes);
                    lapMesg.SetSport(Sport.Swimming);
                    lapMesg.SetSubSport(SubSport.LapSwimming);
                    messages.Add(lapMesg);

                    sessionNumLaps++;

                    // Reset the Lap accumulators
                    lapFirstLengthIndex = messageIndex;
                    lapNumActiveLengths = 0;
                    lapNumLengths       = 0;
                    lapTotalElapsedTime = 0;
                    lapDistance         = 0;
                    lapTotalStrokes     = 0;
                    lapStartTime        = new Dynastream.Fit.DateTime(timestamp);
                }
                else
                {
                    uint duration   = (uint)swimLength["duration"];
                    var  lengthType = (LengthType)Enum.Parse(typeof(LengthType), type);

                    // Create a Length message and its fields
                    var lengthMesg = new LengthMesg();
                    lengthMesg.SetMessageIndex(messageIndex++);
                    lengthMesg.SetStartTime(timestamp);
                    lengthMesg.SetTotalElapsedTime(duration);
                    lengthMesg.SetTotalTimerTime(duration);
                    lengthMesg.SetLengthType(lengthType);

                    timestamp.Add(duration);
                    lengthMesg.SetTimestamp(timestamp);

                    // Create the Record message that pairs with the Length Message
                    var recordMesg = new RecordMesg();
                    recordMesg.SetTimestamp(timestamp);
                    recordMesg.SetDistance(sessionDistance + poolLength);

                    // Is this an Active Length?
                    if (lengthType == LengthType.Active)
                    {
                        // Get the Active data from the model
                        string     stroke     = swimLength.ContainsKey("stroke") ? (String)swimLength["stroke"] : "Freestyle";
                        uint       strokes    = swimLength.ContainsKey("strokes") ? (uint)swimLength["strokes"] : 0;
                        SwimStroke swimStroke = (SwimStroke)Enum.Parse(typeof(SwimStroke), stroke);

                        // Set the Active data on the Length Message
                        lengthMesg.SetAvgSpeed(poolLength / (float)duration);
                        lengthMesg.SetSwimStroke(swimStroke);

                        if (strokes > 0)
                        {
                            lengthMesg.SetTotalStrokes((ushort)strokes);
                            lengthMesg.SetAvgSwimmingCadence((byte)(strokes * 60U / duration));
                        }

                        // Set the Active data on the Record Message
                        recordMesg.SetSpeed(poolLength / (float)duration);
                        if (strokes > 0)
                        {
                            recordMesg.SetCadence((byte)((strokes * 60U) / duration));
                        }

                        // Increment the "Active" accumulators
                        sessionNumActiveLengths++;
                        lapNumActiveLengths++;
                        sessionDistance     += poolLength;
                        lapDistance         += poolLength;
                        sessionTotalStrokes += (ushort)strokes;
                        lapTotalStrokes     += (ushort)strokes;
                    }

                    // Write the messages to the file
                    messages.Add(recordMesg);
                    messages.Add(lengthMesg);

                    // Increment the "Total" accumulators
                    sessionTotalElapsedTime += duration;
                    lapTotalElapsedTime     += duration;
                    sessionNumLengths++;
                    lapNumLengths++;
                }
            }

            // Timer Events are a BEST PRACTICE for FIT ACTIVITY files
            var eventMesgStop = new EventMesg();

            eventMesgStop.SetTimestamp(timestamp);
            eventMesgStop.SetEvent(Event.Timer);
            eventMesgStop.SetEventType(EventType.StopAll);
            messages.Add(eventMesgStop);

            // Every FIT ACTIVITY file MUST contain at least one Session message
            var sessionMesg = new SessionMesg();

            sessionMesg.SetMessageIndex(0);
            sessionMesg.SetTimestamp(timestamp);
            sessionMesg.SetStartTime(startTime);
            sessionMesg.SetTotalElapsedTime(sessionTotalElapsedTime);
            sessionMesg.SetTotalTimerTime(sessionTotalElapsedTime);
            sessionMesg.SetTotalDistance(sessionDistance);
            sessionMesg.SetSport(Sport.Swimming);
            sessionMesg.SetSubSport(SubSport.LapSwimming);
            sessionMesg.SetFirstLapIndex(0);
            sessionMesg.SetNumLaps(sessionNumLaps);
            sessionMesg.SetPoolLength(poolLength);
            sessionMesg.SetPoolLengthUnit(poolLengthUnit);
            sessionMesg.SetNumLengths(sessionNumLengths);
            sessionMesg.SetNumActiveLengths(sessionNumActiveLengths);
            sessionMesg.SetTotalStrokes(sessionTotalStrokes);
            sessionMesg.SetAvgStrokeDistance(sessionDistance / sessionTotalStrokes);
            messages.Add(sessionMesg);

            // Every FIT ACTIVITY file MUST contain EXACTLY one Activity message
            var activityMesg = new ActivityMesg();

            activityMesg.SetTimestamp(timestamp);
            activityMesg.SetNumSessions(1);
            var timezoneOffset = (int)TimeZoneInfo.Local.BaseUtcOffset.TotalSeconds;

            activityMesg.SetLocalTimestamp((uint)((int)timestamp.GetTimeStamp() + timezoneOffset));
            activityMesg.SetTotalTimerTime(sessionTotalElapsedTime);
            messages.Add(activityMesg);

            CreateActivityFile(messages, FileName, startTime);
        }
Ejemplo n.º 15
0
        /// <summary>
        /// Writes the data to a FIT file.
        /// </summary>
        /// <param name="fileName">Name of the FIT file to write to.</param>
        /// <param name="start">Start date/time of the activity.</param>
        /// <param name="laps">Lap and record data to be written.</param>
        /// <param name="calories">Calories used for the activity.</param>
        /// <param name="work">Work done for the activity.</param>
        static void WriteFitFile(string fileName, System.DateTime start, LapsList laps, int calories, uint work)
        {
            // open the encoder and stream
            Encode     encoder   = new Encode(ProtocolVersion.V20);
            FileStream fitStream = new FileStream(fileName, FileMode.Create, FileAccess.ReadWrite, FileShare.Read);

            encoder.Open(fitStream);

            // write the file ID message
            FileIdMesg fileIdMsg = new FileIdMesg();

            fileIdMsg.SetType(Dynastream.Fit.File.Activity);
            fileIdMsg.SetManufacturer(Manufacturer.StagesCycling);
            fileIdMsg.SetProduct(3);
            fileIdMsg.SetSerialNumber(1);
            fileIdMsg.SetTimeCreated(new Dynastream.Fit.DateTime(start));
            encoder.Write(fileIdMsg);

            // write the record and lap messages
            foreach (Lap lap in laps)
            {
                // write the record messages
                foreach (Record record in lap.Records)
                {
                    RecordMesg recordMsg = new RecordMesg();
                    recordMsg.SetTimestamp(new Dynastream.Fit.DateTime(record.Time.ToUniversalTime()));
                    recordMsg.SetHeartRate((byte)record.HeartRate);
                    recordMsg.SetCadence((byte)record.Cadence);
                    recordMsg.SetDistance((float)record.Distance * 1000);
                    recordMsg.SetSpeed((float)(record.Speed / 3.6));
                    recordMsg.SetPower((ushort)record.Power);
                    encoder.Write(recordMsg);
                }

                // write the lap message
                Record   first  = lap.Records[0];
                Record   last   = lap.Records[lap.Records.Count - 1];
                TimeSpan time   = last.Time - first.Time;
                LapMesg  lapMsg = new LapMesg();
                lapMsg.SetTimestamp(new Dynastream.Fit.DateTime(last.Time.ToUniversalTime()));
                lapMsg.SetStartTime(new Dynastream.Fit.DateTime(first.Time.ToUniversalTime()));
                lapMsg.SetTotalElapsedTime((int)time.TotalSeconds);
                lapMsg.SetTotalTimerTime((int)time.TotalSeconds);
                lapMsg.SetTotalDistance((float)(last.Distance - first.Distance) * 1000);
                lapMsg.SetTotalCalories((ushort)lap.Calories);
                lapMsg.SetTotalWork(lap.Work * 1000);
                lapMsg.SetEvent(Event.Lap);
                lapMsg.SetEventType(EventType.Stop);
                lapMsg.SetIntensity(Intensity.Active);
                lapMsg.SetLapTrigger(LapTrigger.Manual);
                lapMsg.SetSport(Sport.Cycling);
                Summary lapSummary = GetLapSummary(lap);
                lapMsg.SetAvgCadence((byte)lapSummary.AveCadence);
                lapMsg.SetMaxCadence((byte)lapSummary.MaxCadence);
                lapMsg.SetAvgHeartRate((byte)lapSummary.AveHeartRate);
                lapMsg.SetMaxHeartRate((byte)lapSummary.MaxHeartRate);
                lapMsg.SetAvgPower((ushort)lapSummary.AvePower);
                lapMsg.SetMaxPower((ushort)lapSummary.MaxPower);
                lapMsg.SetAvgSpeed((float)lapSummary.AveSpeed / 3.6f);
                lapMsg.SetMaxSpeed((float)lapSummary.MaxSpeed / 3.6f);
                encoder.Write(lapMsg);
            }

            // get the first and last records
            Record   firstRecord = laps[0].Records[0];
            Lap      lastLap     = laps[laps.Count - 1];
            Record   lastRecord  = lastLap.Records[lastLap.Records.Count - 1];
            TimeSpan totalTime   = lastRecord.Time - firstRecord.Time;

            // write the session message
            SessionMesg sessionMsg = new SessionMesg();

            sessionMsg.SetTimestamp(new Dynastream.Fit.DateTime(lastRecord.Time.ToUniversalTime()));
            sessionMsg.SetStartTime(new Dynastream.Fit.DateTime(firstRecord.Time.ToUniversalTime()));
            sessionMsg.SetTotalElapsedTime((int)totalTime.TotalSeconds);
            sessionMsg.SetTotalTimerTime((int)totalTime.TotalSeconds);
            sessionMsg.SetTotalDistance((float)(lastRecord.Distance - firstRecord.Distance) * 1000);
            sessionMsg.SetTotalCalories((ushort)calories);
            sessionMsg.SetTotalWork(work * 1000);
            sessionMsg.SetFirstLapIndex(0);
            sessionMsg.SetNumLaps((ushort)laps.Count);
            sessionMsg.SetEvent(Event.Session);
            sessionMsg.SetEventType(EventType.Stop);
            sessionMsg.SetSport(Sport.Cycling);
            sessionMsg.SetSubSport(SubSport.Spin);
            Summary sessionSummary = GetSessionSummary(laps);

            sessionMsg.SetAvgCadence((byte)sessionSummary.AveCadence);
            sessionMsg.SetMaxCadence((byte)sessionSummary.MaxCadence);
            sessionMsg.SetAvgHeartRate((byte)sessionSummary.AveHeartRate);
            sessionMsg.SetMaxHeartRate((byte)sessionSummary.MaxHeartRate);
            sessionMsg.SetAvgPower((ushort)sessionSummary.AvePower);
            sessionMsg.SetMaxPower((ushort)sessionSummary.MaxPower);
            sessionMsg.SetAvgSpeed((float)sessionSummary.AveSpeed / 3.6f);
            sessionMsg.SetMaxSpeed((float)sessionSummary.MaxSpeed / 3.6f);
            encoder.Write(sessionMsg);

            // write the activity message
            ActivityMesg activityMsg = new ActivityMesg();

            activityMsg.SetTimestamp(new Dynastream.Fit.DateTime(lastRecord.Time.ToUniversalTime()));
            activityMsg.SetTotalTimerTime((int)totalTime.TotalSeconds);
            activityMsg.SetNumSessions(1);
            activityMsg.SetType(Activity.Manual);
            activityMsg.SetEvent(Event.Activity);
            activityMsg.SetEventType(EventType.Stop);
            encoder.Write(activityMsg);

            // close the encoder and stream
            encoder.Close();
            fitStream.Close();
        }
Ejemplo n.º 16
0
        private SessionMesg GetSessionMesg(Workout workout, WorkoutSamples workoutSamples, Dynastream.Fit.DateTime startTime, Dynastream.Fit.DateTime endTime, ushort numLaps)
        {
            var sessionMesg = new SessionMesg();

            sessionMesg.SetTimestamp(endTime);
            sessionMesg.SetStartTime(startTime);
            var totalTime = workoutSamples.Duration;

            sessionMesg.SetTotalElapsedTime(totalTime);
            sessionMesg.SetTotalTimerTime(totalTime);
            sessionMesg.SetTotalDistance(GetTotalDistance(workoutSamples));
            sessionMesg.SetTotalWork((uint)workout.Total_Work);
            sessionMesg.SetTotalCalories((ushort)GetCalorieSummary(workoutSamples)?.Value);

            var outputSummary = GetOutputSummary(workoutSamples);

            sessionMesg.SetAvgPower((ushort?)outputSummary?.Average_Value);
            sessionMesg.SetMaxPower((ushort?)outputSummary?.Max_Value);

            sessionMesg.SetFirstLapIndex(0);
            sessionMesg.SetNumLaps(numLaps);
            sessionMesg.SetThresholdPower((ushort)workout.Ftp_Info.Ftp);
            sessionMesg.SetEvent(Event.Lap);
            sessionMesg.SetEventType(EventType.Stop);
            sessionMesg.SetSport(GetGarminSport(workout));
            sessionMesg.SetSubSport(GetGarminSubSport(workout));

            var hrSummary = GetHeartRateSummary(workoutSamples);

            sessionMesg.SetAvgHeartRate((byte?)hrSummary?.Average_Value);
            sessionMesg.SetMaxHeartRate((byte?)hrSummary?.Max_Value);

            var cadenceSummary = GetCadenceSummary(workoutSamples);

            sessionMesg.SetAvgCadence((byte?)cadenceSummary?.Average_Value);
            sessionMesg.SetMaxCadence((byte?)cadenceSummary?.Max_Value);

            sessionMesg.SetMaxSpeed(GetMaxSpeedMetersPerSecond(workoutSamples));
            sessionMesg.SetAvgSpeed(GetAvgSpeedMetersPerSecond(workoutSamples));
            sessionMesg.SetAvgGrade(GetAvgGrade(workoutSamples));
            sessionMesg.SetMaxPosGrade(GetMaxGrade(workoutSamples));
            sessionMesg.SetMaxNegGrade(0.0f);

            // HR zones
            if (_config.Format.IncludeTimeInHRZones && workoutSamples.Metrics.Any())
            {
                var hrz1 = GetHeartRateZone(1, workoutSamples);
                if (hrz1 is object)
                {
                    sessionMesg.SetTimeInHrZone(1, hrz1?.Duration);
                }

                var hrz2 = GetHeartRateZone(2, workoutSamples);
                if (hrz2 is object)
                {
                    sessionMesg.SetTimeInHrZone(2, hrz2?.Duration);
                }

                var hrz3 = GetHeartRateZone(3, workoutSamples);
                if (hrz3 is object)
                {
                    sessionMesg.SetTimeInHrZone(3, hrz3?.Duration);
                }

                var hrz4 = GetHeartRateZone(4, workoutSamples);
                if (hrz4 is object)
                {
                    sessionMesg.SetTimeInHrZone(4, hrz4?.Duration);
                }

                var hrz5 = GetHeartRateZone(5, workoutSamples);
                if (hrz5 is object)
                {
                    sessionMesg.SetTimeInHrZone(5, hrz5?.Duration);
                }
            }

            // Power Zones
            if (_config.Format.IncludeTimeInPowerZones && workoutSamples.Metrics.Any())
            {
                var zones = GetTimeInPowerZones(workout, workoutSamples);
                if (zones is object)
                {
                    sessionMesg.SetTimeInPowerZone(1, zones.Zone1.Duration);
                    sessionMesg.SetTimeInPowerZone(2, zones.Zone2.Duration);
                    sessionMesg.SetTimeInPowerZone(3, zones.Zone3.Duration);
                    sessionMesg.SetTimeInPowerZone(4, zones.Zone4.Duration);
                    sessionMesg.SetTimeInPowerZone(5, zones.Zone5.Duration);
                    sessionMesg.SetTimeInPowerZone(6, zones.Zone6.Duration);
                    sessionMesg.SetTimeInPowerZone(7, zones.Zone7.Duration);
                }
            }

            return(sessionMesg);
        }
Ejemplo n.º 17
0
        public FitSession(SessionMesg msg, int first, int last)
        {
            FirstRecord = first;
            LastRecord  = last;

            AveAltitude = msg.GetAvgAltitude();
            msg.GetAvgBallSpeed();
            AveCadence                 = msg.GetAvgCadence();
            AveCadencePosition         = FitFile.GetByteList(msg.GetNumAvgCadencePosition(), msg.GetAvgCadencePosition);
            AveCombinedPedalSmoothness = msg.GetAvgCombinedPedalSmoothness();
            AveFractionalCadence       = msg.GetAvgFractionalCadence();
            AveGrade     = msg.GetAvgGrade();
            AveHeartRate = msg.GetAvgHeartRate();
            msg.GetAvgLapTime();
            AveLeftPco                 = msg.GetAvgLeftPco();
            AveLeftPedalSmoothness     = msg.GetAvgLeftPedalSmoothness();
            AveLeftPowerPhase          = FitFile.GetFloatList(msg.GetNumAvgLeftPowerPhase(), msg.GetAvgLeftPowerPhase);
            AveLeftPowerPhasePeak      = FitFile.GetFloatList(msg.GetNumAvgLeftPowerPhasePeak(), msg.GetAvgLeftPowerPhasePeak);
            AveLeftTorqueEffectiveness = msg.GetAvgLeftTorqueEffectiveness();
            AveLevMotorPower           = msg.GetAvgLevMotorPower();
            AveNegGrade                = msg.GetAvgNegGrade();
            AveNegVerticalSpeed        = msg.GetAvgNegVerticalSpeed();
            AvePosGrade                = msg.GetAvgPosGrade();
            AvePosVerticalSpeed        = msg.GetAvgPosVerticalSpeed();
            AvePower                      = msg.GetAvgPower();
            AvePowerPosition              = FitFile.GetUShortList(msg.GetNumAvgPowerPosition(), msg.GetAvgPowerPosition);
            AveRightPco                   = msg.GetAvgRightPco();
            AveRightPedalSmoothness       = msg.GetAvgRightPedalSmoothness();
            AveRightPowerPhase            = FitFile.GetFloatList(msg.GetNumAvgRightPowerPhase(), msg.GetAvgRightPowerPhase);
            AveRightPowerPhasePeak        = FitFile.GetFloatList(msg.GetNumAvgRightPowerPhasePeak(), msg.GetAvgRightPowerPhasePeak);
            AveRightTorqueEffectiveness   = msg.GetAvgRightTorqueEffectiveness();
            AveRunningCadence             = msg.GetAvgRunningCadence();
            AveSaturatedHemoglobinPercent = FitFile.GetFloatList(msg.GetNumAvgSaturatedHemoglobinPercent(), msg.GetAvgSaturatedHemoglobinPercent);
            AveSpeed                      = FitFile.GetSpeed(msg.GetAvgSpeed());
            AveStanceTime                 = msg.GetAvgStanceTime();
            AveStanceTimeBalance          = msg.GetAvgStanceTimeBalance();
            AveStanceTimePercent          = msg.GetAvgStanceTimePercent();
            AveStepLength                 = msg.GetAvgStepLength();
            msg.GetAvgStrokeCount();
            AveStrokeDistance      = msg.GetAvgStrokeDistance();
            AveTemperature         = msg.GetAvgTemperature();
            AveTotalHemoglobinConc = FitFile.GetFloatList(msg.GetNumAvgTotalHemoglobinConc(), msg.GetAvgTotalHemoglobinConc);
            AvgVam = msg.GetAvgVam();
            AvgVerticalOscillation = msg.GetAvgVerticalOscillation();
            AvgVerticalRatio       = msg.GetAvgVerticalRatio();
            msg.GetBestLapIndex();
            EnhancedAvgAltitude = msg.GetEnhancedAvgAltitude();
            EnhancedAvgSpeed    = FitFile.GetSpeed(msg.GetEnhancedAvgSpeed());
            EnhancedMaxAltitude = msg.GetEnhancedMaxAltitude();
            EnhancedMaxSpeed    = FitFile.GetSpeed(msg.GetEnhancedMaxSpeed());
            EnhancedMinAltitude = msg.GetEnhancedMinAltitude();
            Event                 = msg.GetEvent();
            EventGroup            = msg.GetEventGroup();
            EventType             = msg.GetEventType();
            FirstLengthIndex      = msg.GetFirstLapIndex();
            GpsAccuracy           = msg.GetGpsAccuracy();
            IntensityFactor       = msg.GetIntensityFactor();
            LeftRightBalance      = msg.GetLeftRightBalance();
            LevBatteryConsumption = msg.GetLevBatteryConsumption();
            MaxAltitude           = msg.GetMaxAltitude();
            msg.GetMaxBallSpeed();
            MaxCadence                    = msg.GetMaxCadence();
            MaxCadencePosition            = FitFile.GetByteList(msg.GetNumMaxCadencePosition(), msg.GetMaxCadencePosition);
            MaxFractionalCadence          = msg.GetMaxFractionalCadence();
            MaxHeartRate                  = msg.GetMaxHeartRate();
            MaxLevMotorPower              = msg.GetMaxLevMotorPower();
            MaxNegGrade                   = msg.GetMaxNegGrade();
            MaxNegVerticalSpeed           = msg.GetMaxNegVerticalSpeed();
            MaxPosGrade                   = msg.GetMaxPosGrade();
            MaxPosVerticalSpeed           = msg.GetMaxPosVerticalSpeed();
            MaxPower                      = msg.GetMaxPower();
            MaxPowerPosition              = FitFile.GetUShortList(msg.GetNumMaxPowerPosition(), msg.GetMaxPowerPosition);
            MaxRunningCadence             = msg.GetMaxRunningCadence();
            MaxSaturatedHemoglobinPercent = FitFile.GetFloatList(msg.GetNumMaxSaturatedHemoglobinPercent(), msg.GetMaxSaturatedHemoglobinPercent);
            MaxSpeed                      = FitFile.GetSpeed(msg.GetMaxSpeed());
            MaxTemperature                = msg.GetMaxTemperature();
            MaxTotalHemoglobinConc        = FitFile.GetFloatList(msg.GetNumMaxTotalHemoglobinConc(), msg.GetMaxTotalHemoglobinConc);
            MinAltitude                   = msg.GetMinAltitude();
            MinHeartRate                  = msg.GetMinHeartRate();
            MinSaturatedHemoglobinPercent = FitFile.GetFloatList(msg.GetNumMinSaturatedHemoglobinPercent(), msg.GetMinSaturatedHemoglobinPercent);
            MinTotalHemoglobinConc        = FitFile.GetFloatList(msg.GetNumMinTotalHemoglobinConc(), msg.GetMinTotalHemoglobinConc);
            msg.GetNecLat();
            msg.GetNecLong();
            NormalizedPower  = msg.GetNormalizedPower();
            NumActiveLengths = msg.GetNumActiveLengths();
            msg.GetNumLaps();
            msg.GetOpponentNameAsString();
            OpponentScore = msg.GetOpponentScore();
            PlayerScore   = msg.GetPlayerScore();
            msg.GetPoolLength();
            msg.GetPoolLengthUnit();
            Sport = msg.GetSport();
            msg.GetSportIndex();
            StandCount        = msg.GetStandCount();
            StartPositionLat  = FitFile.GetDegrees(msg.GetStartPositionLat());
            StartPositionLong = FitFile.GetDegrees(msg.GetStartPositionLong());
            StartTime         = FitFile.GetDateTime(msg.GetStartTime());
            StrokeCounts      = FitFile.GetUShortList(msg.GetNumStrokeCount(), msg.GetStrokeCount);
            SubSport          = msg.GetSubSport();
            msg.GetSwcLat();
            msg.GetSwcLong();
            SwimStroke = msg.GetSwimStroke();
            msg.GetThresholdPower();
            TimeInCadenceZone     = FitFile.GetFloatList(msg.GetNumTimeInCadenceZone(), msg.GetTimeInCadenceZone);
            TimeInHrZone          = FitFile.GetFloatList(msg.GetNumTimeInHrZone(), msg.GetTimeInHrZone);
            TimeInPowerZone       = FitFile.GetFloatList(msg.GetNumTimeInPowerZone(), msg.GetTimeInPowerZone);
            TimeInSpeedZone       = FitFile.GetFloatList(msg.GetNumTimeInSpeedZone(), msg.GetTimeInSpeedZone);
            Timestamp             = FitFile.GetDateTime(msg.GetTimestamp());
            TimeStanding          = msg.GetTimeStanding();
            TotalAscent           = msg.GetTotalAscent();
            TotalCalories         = msg.GetTotalCalories();
            TotalCycles           = msg.GetTotalCycles();
            TotalDescent          = msg.GetTotalDescent();
            TotalDistance         = FitFile.GetDistance(msg.GetTotalDistance());
            TotalElapsedTime      = FitFile.GetTimeSpan(msg.GetTotalElapsedTime());
            TotalFatCalories      = msg.GetTotalFatCalories();
            TotalFractionalCycles = msg.GetTotalFractionalCycles();
            TotalMovingTime       = FitFile.GetTimeSpan(msg.GetTotalMovingTime());
            TotalStrides          = msg.GetTotalStrides();
            TotalTimerTime        = FitFile.GetTimeSpan(msg.GetTotalTimerTime());
            TotalWork             = FitFile.GetWork(msg.GetTotalWork());
            ZoneCounts            = FitFile.GetUShortList(msg.GetNumZoneCount(), msg.GetZoneCount);
            msg.GetTotalAnaerobicTrainingEffect();
            msg.GetTotalTrainingEffect();
            msg.GetTrainingStressScore();
            msg.GetTrigger();

            MaxCadence   = msg.GetMaxCadence();
            MaxHeartRate = msg.GetMaxHeartRate();
            MaxPower     = msg.GetMaxPower();
            MaxSpeed     = FitFile.GetSpeed(msg.GetMaxSpeed());
        }
Ejemplo n.º 18
0
        public void OnMesg(object sender, MesgEventArgs e)
        {
            // Notify any subscribers of either our general mesg event or specific profile mesg event
            if (MesgEvent != null)
            {
                MesgEvent(sender, e);
            }

            switch (e.mesg.Num)
            {
            case (ushort)MesgNum.FileId:
                if (FileIdMesgEvent != null)
                {
                    FileIdMesg    fileIdMesg    = new FileIdMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = fileIdMesg;
                    FileIdMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.FileCreator:
                if (FileCreatorMesgEvent != null)
                {
                    FileCreatorMesg fileCreatorMesg = new FileCreatorMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = fileCreatorMesg;
                    FileCreatorMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Software:
                if (SoftwareMesgEvent != null)
                {
                    SoftwareMesg  softwareMesg  = new SoftwareMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = softwareMesg;
                    SoftwareMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.SlaveDevice:
                if (SlaveDeviceMesgEvent != null)
                {
                    SlaveDeviceMesg slaveDeviceMesg = new SlaveDeviceMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = slaveDeviceMesg;
                    SlaveDeviceMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Capabilities:
                if (CapabilitiesMesgEvent != null)
                {
                    CapabilitiesMesg capabilitiesMesg = new CapabilitiesMesg(e.mesg);
                    MesgEventArgs    mesgEventArgs    = new MesgEventArgs();
                    mesgEventArgs.mesg = capabilitiesMesg;
                    CapabilitiesMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.FileCapabilities:
                if (FileCapabilitiesMesgEvent != null)
                {
                    FileCapabilitiesMesg fileCapabilitiesMesg = new FileCapabilitiesMesg(e.mesg);
                    MesgEventArgs        mesgEventArgs        = new MesgEventArgs();
                    mesgEventArgs.mesg = fileCapabilitiesMesg;
                    FileCapabilitiesMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.MesgCapabilities:
                if (MesgCapabilitiesMesgEvent != null)
                {
                    MesgCapabilitiesMesg mesgCapabilitiesMesg = new MesgCapabilitiesMesg(e.mesg);
                    MesgEventArgs        mesgEventArgs        = new MesgEventArgs();
                    mesgEventArgs.mesg = mesgCapabilitiesMesg;
                    MesgCapabilitiesMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.FieldCapabilities:
                if (FieldCapabilitiesMesgEvent != null)
                {
                    FieldCapabilitiesMesg fieldCapabilitiesMesg = new FieldCapabilitiesMesg(e.mesg);
                    MesgEventArgs         mesgEventArgs         = new MesgEventArgs();
                    mesgEventArgs.mesg = fieldCapabilitiesMesg;
                    FieldCapabilitiesMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.DeviceSettings:
                if (DeviceSettingsMesgEvent != null)
                {
                    DeviceSettingsMesg deviceSettingsMesg = new DeviceSettingsMesg(e.mesg);
                    MesgEventArgs      mesgEventArgs      = new MesgEventArgs();
                    mesgEventArgs.mesg = deviceSettingsMesg;
                    DeviceSettingsMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.UserProfile:
                if (UserProfileMesgEvent != null)
                {
                    UserProfileMesg userProfileMesg = new UserProfileMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = userProfileMesg;
                    UserProfileMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.HrmProfile:
                if (HrmProfileMesgEvent != null)
                {
                    HrmProfileMesg hrmProfileMesg = new HrmProfileMesg(e.mesg);
                    MesgEventArgs  mesgEventArgs  = new MesgEventArgs();
                    mesgEventArgs.mesg = hrmProfileMesg;
                    HrmProfileMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.SdmProfile:
                if (SdmProfileMesgEvent != null)
                {
                    SdmProfileMesg sdmProfileMesg = new SdmProfileMesg(e.mesg);
                    MesgEventArgs  mesgEventArgs  = new MesgEventArgs();
                    mesgEventArgs.mesg = sdmProfileMesg;
                    SdmProfileMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.BikeProfile:
                if (BikeProfileMesgEvent != null)
                {
                    BikeProfileMesg bikeProfileMesg = new BikeProfileMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = bikeProfileMesg;
                    BikeProfileMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.ZonesTarget:
                if (ZonesTargetMesgEvent != null)
                {
                    ZonesTargetMesg zonesTargetMesg = new ZonesTargetMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = zonesTargetMesg;
                    ZonesTargetMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Sport:
                if (SportMesgEvent != null)
                {
                    SportMesg     sportMesg     = new SportMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = sportMesg;
                    SportMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.HrZone:
                if (HrZoneMesgEvent != null)
                {
                    HrZoneMesg    hrZoneMesg    = new HrZoneMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = hrZoneMesg;
                    HrZoneMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.SpeedZone:
                if (SpeedZoneMesgEvent != null)
                {
                    SpeedZoneMesg speedZoneMesg = new SpeedZoneMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = speedZoneMesg;
                    SpeedZoneMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.CadenceZone:
                if (CadenceZoneMesgEvent != null)
                {
                    CadenceZoneMesg cadenceZoneMesg = new CadenceZoneMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = cadenceZoneMesg;
                    CadenceZoneMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.PowerZone:
                if (PowerZoneMesgEvent != null)
                {
                    PowerZoneMesg powerZoneMesg = new PowerZoneMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = powerZoneMesg;
                    PowerZoneMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.MetZone:
                if (MetZoneMesgEvent != null)
                {
                    MetZoneMesg   metZoneMesg   = new MetZoneMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = metZoneMesg;
                    MetZoneMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Goal:
                if (GoalMesgEvent != null)
                {
                    GoalMesg      goalMesg      = new GoalMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = goalMesg;
                    GoalMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Activity:
                if (ActivityMesgEvent != null)
                {
                    ActivityMesg  activityMesg  = new ActivityMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = activityMesg;
                    ActivityMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Session:
                if (SessionMesgEvent != null)
                {
                    SessionMesg   sessionMesg   = new SessionMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = sessionMesg;
                    SessionMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Lap:
                if (LapMesgEvent != null)
                {
                    LapMesg       lapMesg       = new LapMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = lapMesg;
                    LapMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Length:
                if (LengthMesgEvent != null)
                {
                    LengthMesg    lengthMesg    = new LengthMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = lengthMesg;
                    LengthMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Record:
                if (RecordMesgEvent != null)
                {
                    RecordMesg    recordMesg    = new RecordMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = recordMesg;
                    RecordMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Event:
                if (EventMesgEvent != null)
                {
                    EventMesg     eventMesg     = new EventMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = eventMesg;
                    EventMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.DeviceInfo:
                if (DeviceInfoMesgEvent != null)
                {
                    DeviceInfoMesg deviceInfoMesg = new DeviceInfoMesg(e.mesg);
                    MesgEventArgs  mesgEventArgs  = new MesgEventArgs();
                    mesgEventArgs.mesg = deviceInfoMesg;
                    DeviceInfoMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Hrv:
                if (HrvMesgEvent != null)
                {
                    HrvMesg       hrvMesg       = new HrvMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = hrvMesg;
                    HrvMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Course:
                if (CourseMesgEvent != null)
                {
                    CourseMesg    courseMesg    = new CourseMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = courseMesg;
                    CourseMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.CoursePoint:
                if (CoursePointMesgEvent != null)
                {
                    CoursePointMesg coursePointMesg = new CoursePointMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = coursePointMesg;
                    CoursePointMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Workout:
                if (WorkoutMesgEvent != null)
                {
                    WorkoutMesg   workoutMesg   = new WorkoutMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = workoutMesg;
                    WorkoutMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.WorkoutStep:
                if (WorkoutStepMesgEvent != null)
                {
                    WorkoutStepMesg workoutStepMesg = new WorkoutStepMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = workoutStepMesg;
                    WorkoutStepMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Schedule:
                if (ScheduleMesgEvent != null)
                {
                    ScheduleMesg  scheduleMesg  = new ScheduleMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = scheduleMesg;
                    ScheduleMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Totals:
                if (TotalsMesgEvent != null)
                {
                    TotalsMesg    totalsMesg    = new TotalsMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = totalsMesg;
                    TotalsMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.WeightScale:
                if (WeightScaleMesgEvent != null)
                {
                    WeightScaleMesg weightScaleMesg = new WeightScaleMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = weightScaleMesg;
                    WeightScaleMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.BloodPressure:
                if (BloodPressureMesgEvent != null)
                {
                    BloodPressureMesg bloodPressureMesg = new BloodPressureMesg(e.mesg);
                    MesgEventArgs     mesgEventArgs     = new MesgEventArgs();
                    mesgEventArgs.mesg = bloodPressureMesg;
                    BloodPressureMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.MonitoringInfo:
                if (MonitoringInfoMesgEvent != null)
                {
                    MonitoringInfoMesg monitoringInfoMesg = new MonitoringInfoMesg(e.mesg);
                    MesgEventArgs      mesgEventArgs      = new MesgEventArgs();
                    mesgEventArgs.mesg = monitoringInfoMesg;
                    MonitoringInfoMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Monitoring:
                if (MonitoringMesgEvent != null)
                {
                    MonitoringMesg monitoringMesg = new MonitoringMesg(e.mesg);
                    MesgEventArgs  mesgEventArgs  = new MesgEventArgs();
                    mesgEventArgs.mesg = monitoringMesg;
                    MonitoringMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.MemoGlob:
                if (MemoGlobMesgEvent != null)
                {
                    MemoGlobMesg  memoGlobMesg  = new MemoGlobMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = memoGlobMesg;
                    MemoGlobMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Pad:
                if (PadMesgEvent != null)
                {
                    PadMesg       padMesg       = new PadMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = padMesg;
                    PadMesgEvent(sender, mesgEventArgs);
                }
                break;
            }
        }
Ejemplo n.º 19
0
        void OnSessionMesg(object sender, MesgEventArgs e)
        {
            bool        bAlreadyProcessed = false;
            SessionMesg mySession         = (SessionMesg)e.mesg;

            try
            {
                TimeSpan tsMoving = TimeSpan.FromSeconds(Convert.ToDouble(mySession.GetTotalTimerTime()));
                TimeSpan tsTotal  = TimeSpan.FromSeconds(Convert.ToDouble(mySession.GetTotalElapsedTime()));

                try{
                    string        sql = string.Format(@"select count(*) from File f where f.fileName = ""{0}""", Path.GetFileName(curDeviceFile));
                    SQLiteCommand cmd = new SQLiteCommand(sql, _db);
                    if (Convert.ToInt32(cmd.ExecuteScalar()) > 0)
                    {
                        bAlreadyProcessed = true;
                    }
                    else
                    {
                        unprocessedCount++;
                        //unprocessedFiles.Add(curDeviceFile);
                        SetControlPropertyThreadSafe(tNumToBeProcessed, "Text", string.Format("There are {0} activities that are not yet processed / uploaded", unprocessedCount));
                    }
                }
                catch (Exception ex) {
                    //MessageBox.Show(ex.ToString());
                }

                string[] row =
                {
                    "",
                    bAlreadyProcessed ? "Y" : "",
                    mySession.GetStartTime().GetDateTime().ToString("dd/MM/yyyy HH:mm",System.Globalization.CultureInfo.CurrentCulture),
                    string.Format("{0:0.00} miles",                                    (mySession.GetTotalDistance() / 1000) * 0.621371192),
                    string.Format("{0:D2} h {1:D2} m {2:D2} s",
                                  tsTotal.Hours,
                                  tsTotal.Minutes,
                                  tsTotal.Seconds
                                  ),
                    string.Format("{0:D2} h {1:D2} m {2:D2} s",
                                  tsMoving.Hours,
                                  tsMoving.Minutes,
                                  tsMoving.Seconds
                                  ),
                    string.Format("{0:0.00} ft",                                       mySession.GetTotalAscent() * 3.2808399),
                    mySession.GetTotalCalories().ToString(),
                    string.Format("{0:0.00} mph",                                      mySession.GetAvgSpeed() * 2.23693629),
                    string.Format("{0:0} bpm",                                         mySession.GetAvgHeartRate()),
                    string.Format("{0:0} rpm",                                         mySession.GetAvgCadence()),
                    string.Format("{0:0.00} mph",                                      mySession.GetMaxSpeed() * 2.23693629),
                    string.Format("{0:0} bpm",                                         mySession.GetMaxHeartRate()),
                    string.Format("{0:0} rpm",                                         mySession.GetMaxCadence()),
                    curDeviceFile,
                    ""
                };
                ListViewItem r = new ListViewItem(row);
                if (r.SubItems[1].Text == "Y")
                {
                    r.Checked   = false;
                    r.ForeColor = SystemColors.GrayText;
                }
                else
                {
                    r.Checked = true;
                }
                AddListViewItem(lstDeviceActivities, r);
            }
            catch {}
        }
        public void OnMesg(object sender, MesgEventArgs e)
        {
            // Notify any subscribers of either our general mesg event or specific profile mesg event
            if (MesgEvent != null)
            {
                MesgEvent(sender, e);
            }

            switch (e.mesg.Num)
            {
            case (ushort)MesgNum.FileId:
                if (FileIdMesgEvent != null)
                {
                    FileIdMesg    fileIdMesg    = new FileIdMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = fileIdMesg;
                    FileIdMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.FileCreator:
                if (FileCreatorMesgEvent != null)
                {
                    FileCreatorMesg fileCreatorMesg = new FileCreatorMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = fileCreatorMesg;
                    FileCreatorMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.TimestampCorrelation:
                if (TimestampCorrelationMesgEvent != null)
                {
                    TimestampCorrelationMesg timestampCorrelationMesg = new TimestampCorrelationMesg(e.mesg);
                    MesgEventArgs            mesgEventArgs            = new MesgEventArgs();
                    mesgEventArgs.mesg = timestampCorrelationMesg;
                    TimestampCorrelationMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Software:
                if (SoftwareMesgEvent != null)
                {
                    SoftwareMesg  softwareMesg  = new SoftwareMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = softwareMesg;
                    SoftwareMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.SlaveDevice:
                if (SlaveDeviceMesgEvent != null)
                {
                    SlaveDeviceMesg slaveDeviceMesg = new SlaveDeviceMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = slaveDeviceMesg;
                    SlaveDeviceMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Capabilities:
                if (CapabilitiesMesgEvent != null)
                {
                    CapabilitiesMesg capabilitiesMesg = new CapabilitiesMesg(e.mesg);
                    MesgEventArgs    mesgEventArgs    = new MesgEventArgs();
                    mesgEventArgs.mesg = capabilitiesMesg;
                    CapabilitiesMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.FileCapabilities:
                if (FileCapabilitiesMesgEvent != null)
                {
                    FileCapabilitiesMesg fileCapabilitiesMesg = new FileCapabilitiesMesg(e.mesg);
                    MesgEventArgs        mesgEventArgs        = new MesgEventArgs();
                    mesgEventArgs.mesg = fileCapabilitiesMesg;
                    FileCapabilitiesMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.MesgCapabilities:
                if (MesgCapabilitiesMesgEvent != null)
                {
                    MesgCapabilitiesMesg mesgCapabilitiesMesg = new MesgCapabilitiesMesg(e.mesg);
                    MesgEventArgs        mesgEventArgs        = new MesgEventArgs();
                    mesgEventArgs.mesg = mesgCapabilitiesMesg;
                    MesgCapabilitiesMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.FieldCapabilities:
                if (FieldCapabilitiesMesgEvent != null)
                {
                    FieldCapabilitiesMesg fieldCapabilitiesMesg = new FieldCapabilitiesMesg(e.mesg);
                    MesgEventArgs         mesgEventArgs         = new MesgEventArgs();
                    mesgEventArgs.mesg = fieldCapabilitiesMesg;
                    FieldCapabilitiesMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.DeviceSettings:
                if (DeviceSettingsMesgEvent != null)
                {
                    DeviceSettingsMesg deviceSettingsMesg = new DeviceSettingsMesg(e.mesg);
                    MesgEventArgs      mesgEventArgs      = new MesgEventArgs();
                    mesgEventArgs.mesg = deviceSettingsMesg;
                    DeviceSettingsMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.UserProfile:
                if (UserProfileMesgEvent != null)
                {
                    UserProfileMesg userProfileMesg = new UserProfileMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = userProfileMesg;
                    UserProfileMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.HrmProfile:
                if (HrmProfileMesgEvent != null)
                {
                    HrmProfileMesg hrmProfileMesg = new HrmProfileMesg(e.mesg);
                    MesgEventArgs  mesgEventArgs  = new MesgEventArgs();
                    mesgEventArgs.mesg = hrmProfileMesg;
                    HrmProfileMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.SdmProfile:
                if (SdmProfileMesgEvent != null)
                {
                    SdmProfileMesg sdmProfileMesg = new SdmProfileMesg(e.mesg);
                    MesgEventArgs  mesgEventArgs  = new MesgEventArgs();
                    mesgEventArgs.mesg = sdmProfileMesg;
                    SdmProfileMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.BikeProfile:
                if (BikeProfileMesgEvent != null)
                {
                    BikeProfileMesg bikeProfileMesg = new BikeProfileMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = bikeProfileMesg;
                    BikeProfileMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Connectivity:
                if (ConnectivityMesgEvent != null)
                {
                    ConnectivityMesg connectivityMesg = new ConnectivityMesg(e.mesg);
                    MesgEventArgs    mesgEventArgs    = new MesgEventArgs();
                    mesgEventArgs.mesg = connectivityMesg;
                    ConnectivityMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.WatchfaceSettings:
                if (WatchfaceSettingsMesgEvent != null)
                {
                    WatchfaceSettingsMesg watchfaceSettingsMesg = new WatchfaceSettingsMesg(e.mesg);
                    MesgEventArgs         mesgEventArgs         = new MesgEventArgs();
                    mesgEventArgs.mesg = watchfaceSettingsMesg;
                    WatchfaceSettingsMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.OhrSettings:
                if (OhrSettingsMesgEvent != null)
                {
                    OhrSettingsMesg ohrSettingsMesg = new OhrSettingsMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = ohrSettingsMesg;
                    OhrSettingsMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.ZonesTarget:
                if (ZonesTargetMesgEvent != null)
                {
                    ZonesTargetMesg zonesTargetMesg = new ZonesTargetMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = zonesTargetMesg;
                    ZonesTargetMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Sport:
                if (SportMesgEvent != null)
                {
                    SportMesg     sportMesg     = new SportMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = sportMesg;
                    SportMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.HrZone:
                if (HrZoneMesgEvent != null)
                {
                    HrZoneMesg    hrZoneMesg    = new HrZoneMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = hrZoneMesg;
                    HrZoneMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.SpeedZone:
                if (SpeedZoneMesgEvent != null)
                {
                    SpeedZoneMesg speedZoneMesg = new SpeedZoneMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = speedZoneMesg;
                    SpeedZoneMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.CadenceZone:
                if (CadenceZoneMesgEvent != null)
                {
                    CadenceZoneMesg cadenceZoneMesg = new CadenceZoneMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = cadenceZoneMesg;
                    CadenceZoneMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.PowerZone:
                if (PowerZoneMesgEvent != null)
                {
                    PowerZoneMesg powerZoneMesg = new PowerZoneMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = powerZoneMesg;
                    PowerZoneMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.MetZone:
                if (MetZoneMesgEvent != null)
                {
                    MetZoneMesg   metZoneMesg   = new MetZoneMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = metZoneMesg;
                    MetZoneMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.DiveSettings:
                if (DiveSettingsMesgEvent != null)
                {
                    DiveSettingsMesg diveSettingsMesg = new DiveSettingsMesg(e.mesg);
                    MesgEventArgs    mesgEventArgs    = new MesgEventArgs();
                    mesgEventArgs.mesg = diveSettingsMesg;
                    DiveSettingsMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.DiveAlarm:
                if (DiveAlarmMesgEvent != null)
                {
                    DiveAlarmMesg diveAlarmMesg = new DiveAlarmMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = diveAlarmMesg;
                    DiveAlarmMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.DiveGas:
                if (DiveGasMesgEvent != null)
                {
                    DiveGasMesg   diveGasMesg   = new DiveGasMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = diveGasMesg;
                    DiveGasMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Goal:
                if (GoalMesgEvent != null)
                {
                    GoalMesg      goalMesg      = new GoalMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = goalMesg;
                    GoalMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Activity:
                if (ActivityMesgEvent != null)
                {
                    ActivityMesg  activityMesg  = new ActivityMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = activityMesg;
                    ActivityMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Session:
                if (SessionMesgEvent != null)
                {
                    SessionMesg   sessionMesg   = new SessionMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = sessionMesg;
                    SessionMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Lap:
                if (LapMesgEvent != null)
                {
                    LapMesg       lapMesg       = new LapMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = lapMesg;
                    LapMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Length:
                if (LengthMesgEvent != null)
                {
                    LengthMesg    lengthMesg    = new LengthMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = lengthMesg;
                    LengthMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Record:
                if (RecordMesgEvent != null)
                {
                    RecordMesg    recordMesg    = new RecordMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = recordMesg;
                    RecordMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Event:
                if (EventMesgEvent != null)
                {
                    EventMesg     eventMesg     = new EventMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = eventMesg;
                    EventMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.DeviceInfo:
                if (DeviceInfoMesgEvent != null)
                {
                    DeviceInfoMesg deviceInfoMesg = new DeviceInfoMesg(e.mesg);
                    MesgEventArgs  mesgEventArgs  = new MesgEventArgs();
                    mesgEventArgs.mesg = deviceInfoMesg;
                    DeviceInfoMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.TrainingFile:
                if (TrainingFileMesgEvent != null)
                {
                    TrainingFileMesg trainingFileMesg = new TrainingFileMesg(e.mesg);
                    MesgEventArgs    mesgEventArgs    = new MesgEventArgs();
                    mesgEventArgs.mesg = trainingFileMesg;
                    TrainingFileMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Hrv:
                if (HrvMesgEvent != null)
                {
                    HrvMesg       hrvMesg       = new HrvMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = hrvMesg;
                    HrvMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.WeatherConditions:
                if (WeatherConditionsMesgEvent != null)
                {
                    WeatherConditionsMesg weatherConditionsMesg = new WeatherConditionsMesg(e.mesg);
                    MesgEventArgs         mesgEventArgs         = new MesgEventArgs();
                    mesgEventArgs.mesg = weatherConditionsMesg;
                    WeatherConditionsMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.WeatherAlert:
                if (WeatherAlertMesgEvent != null)
                {
                    WeatherAlertMesg weatherAlertMesg = new WeatherAlertMesg(e.mesg);
                    MesgEventArgs    mesgEventArgs    = new MesgEventArgs();
                    mesgEventArgs.mesg = weatherAlertMesg;
                    WeatherAlertMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.GpsMetadata:
                if (GpsMetadataMesgEvent != null)
                {
                    GpsMetadataMesg gpsMetadataMesg = new GpsMetadataMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = gpsMetadataMesg;
                    GpsMetadataMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.CameraEvent:
                if (CameraEventMesgEvent != null)
                {
                    CameraEventMesg cameraEventMesg = new CameraEventMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = cameraEventMesg;
                    CameraEventMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.GyroscopeData:
                if (GyroscopeDataMesgEvent != null)
                {
                    GyroscopeDataMesg gyroscopeDataMesg = new GyroscopeDataMesg(e.mesg);
                    MesgEventArgs     mesgEventArgs     = new MesgEventArgs();
                    mesgEventArgs.mesg = gyroscopeDataMesg;
                    GyroscopeDataMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.AccelerometerData:
                if (AccelerometerDataMesgEvent != null)
                {
                    AccelerometerDataMesg accelerometerDataMesg = new AccelerometerDataMesg(e.mesg);
                    MesgEventArgs         mesgEventArgs         = new MesgEventArgs();
                    mesgEventArgs.mesg = accelerometerDataMesg;
                    AccelerometerDataMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.MagnetometerData:
                if (MagnetometerDataMesgEvent != null)
                {
                    MagnetometerDataMesg magnetometerDataMesg = new MagnetometerDataMesg(e.mesg);
                    MesgEventArgs        mesgEventArgs        = new MesgEventArgs();
                    mesgEventArgs.mesg = magnetometerDataMesg;
                    MagnetometerDataMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.BarometerData:
                if (BarometerDataMesgEvent != null)
                {
                    BarometerDataMesg barometerDataMesg = new BarometerDataMesg(e.mesg);
                    MesgEventArgs     mesgEventArgs     = new MesgEventArgs();
                    mesgEventArgs.mesg = barometerDataMesg;
                    BarometerDataMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.ThreeDSensorCalibration:
                if (ThreeDSensorCalibrationMesgEvent != null)
                {
                    ThreeDSensorCalibrationMesg threeDSensorCalibrationMesg = new ThreeDSensorCalibrationMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = threeDSensorCalibrationMesg;
                    ThreeDSensorCalibrationMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.OneDSensorCalibration:
                if (OneDSensorCalibrationMesgEvent != null)
                {
                    OneDSensorCalibrationMesg oneDSensorCalibrationMesg = new OneDSensorCalibrationMesg(e.mesg);
                    MesgEventArgs             mesgEventArgs             = new MesgEventArgs();
                    mesgEventArgs.mesg = oneDSensorCalibrationMesg;
                    OneDSensorCalibrationMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.VideoFrame:
                if (VideoFrameMesgEvent != null)
                {
                    VideoFrameMesg videoFrameMesg = new VideoFrameMesg(e.mesg);
                    MesgEventArgs  mesgEventArgs  = new MesgEventArgs();
                    mesgEventArgs.mesg = videoFrameMesg;
                    VideoFrameMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.ObdiiData:
                if (ObdiiDataMesgEvent != null)
                {
                    ObdiiDataMesg obdiiDataMesg = new ObdiiDataMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = obdiiDataMesg;
                    ObdiiDataMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.NmeaSentence:
                if (NmeaSentenceMesgEvent != null)
                {
                    NmeaSentenceMesg nmeaSentenceMesg = new NmeaSentenceMesg(e.mesg);
                    MesgEventArgs    mesgEventArgs    = new MesgEventArgs();
                    mesgEventArgs.mesg = nmeaSentenceMesg;
                    NmeaSentenceMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.AviationAttitude:
                if (AviationAttitudeMesgEvent != null)
                {
                    AviationAttitudeMesg aviationAttitudeMesg = new AviationAttitudeMesg(e.mesg);
                    MesgEventArgs        mesgEventArgs        = new MesgEventArgs();
                    mesgEventArgs.mesg = aviationAttitudeMesg;
                    AviationAttitudeMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Video:
                if (VideoMesgEvent != null)
                {
                    VideoMesg     videoMesg     = new VideoMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = videoMesg;
                    VideoMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.VideoTitle:
                if (VideoTitleMesgEvent != null)
                {
                    VideoTitleMesg videoTitleMesg = new VideoTitleMesg(e.mesg);
                    MesgEventArgs  mesgEventArgs  = new MesgEventArgs();
                    mesgEventArgs.mesg = videoTitleMesg;
                    VideoTitleMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.VideoDescription:
                if (VideoDescriptionMesgEvent != null)
                {
                    VideoDescriptionMesg videoDescriptionMesg = new VideoDescriptionMesg(e.mesg);
                    MesgEventArgs        mesgEventArgs        = new MesgEventArgs();
                    mesgEventArgs.mesg = videoDescriptionMesg;
                    VideoDescriptionMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.VideoClip:
                if (VideoClipMesgEvent != null)
                {
                    VideoClipMesg videoClipMesg = new VideoClipMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = videoClipMesg;
                    VideoClipMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Set:
                if (SetMesgEvent != null)
                {
                    SetMesg       setMesg       = new SetMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = setMesg;
                    SetMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Jump:
                if (JumpMesgEvent != null)
                {
                    JumpMesg      jumpMesg      = new JumpMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = jumpMesg;
                    JumpMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Course:
                if (CourseMesgEvent != null)
                {
                    CourseMesg    courseMesg    = new CourseMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = courseMesg;
                    CourseMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.CoursePoint:
                if (CoursePointMesgEvent != null)
                {
                    CoursePointMesg coursePointMesg = new CoursePointMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = coursePointMesg;
                    CoursePointMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.SegmentId:
                if (SegmentIdMesgEvent != null)
                {
                    SegmentIdMesg segmentIdMesg = new SegmentIdMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = segmentIdMesg;
                    SegmentIdMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.SegmentLeaderboardEntry:
                if (SegmentLeaderboardEntryMesgEvent != null)
                {
                    SegmentLeaderboardEntryMesg segmentLeaderboardEntryMesg = new SegmentLeaderboardEntryMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = segmentLeaderboardEntryMesg;
                    SegmentLeaderboardEntryMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.SegmentPoint:
                if (SegmentPointMesgEvent != null)
                {
                    SegmentPointMesg segmentPointMesg = new SegmentPointMesg(e.mesg);
                    MesgEventArgs    mesgEventArgs    = new MesgEventArgs();
                    mesgEventArgs.mesg = segmentPointMesg;
                    SegmentPointMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.SegmentLap:
                if (SegmentLapMesgEvent != null)
                {
                    SegmentLapMesg segmentLapMesg = new SegmentLapMesg(e.mesg);
                    MesgEventArgs  mesgEventArgs  = new MesgEventArgs();
                    mesgEventArgs.mesg = segmentLapMesg;
                    SegmentLapMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.SegmentFile:
                if (SegmentFileMesgEvent != null)
                {
                    SegmentFileMesg segmentFileMesg = new SegmentFileMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = segmentFileMesg;
                    SegmentFileMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Workout:
                if (WorkoutMesgEvent != null)
                {
                    WorkoutMesg   workoutMesg   = new WorkoutMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = workoutMesg;
                    WorkoutMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.WorkoutSession:
                if (WorkoutSessionMesgEvent != null)
                {
                    WorkoutSessionMesg workoutSessionMesg = new WorkoutSessionMesg(e.mesg);
                    MesgEventArgs      mesgEventArgs      = new MesgEventArgs();
                    mesgEventArgs.mesg = workoutSessionMesg;
                    WorkoutSessionMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.WorkoutStep:
                if (WorkoutStepMesgEvent != null)
                {
                    WorkoutStepMesg workoutStepMesg = new WorkoutStepMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = workoutStepMesg;
                    WorkoutStepMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.ExerciseTitle:
                if (ExerciseTitleMesgEvent != null)
                {
                    ExerciseTitleMesg exerciseTitleMesg = new ExerciseTitleMesg(e.mesg);
                    MesgEventArgs     mesgEventArgs     = new MesgEventArgs();
                    mesgEventArgs.mesg = exerciseTitleMesg;
                    ExerciseTitleMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Schedule:
                if (ScheduleMesgEvent != null)
                {
                    ScheduleMesg  scheduleMesg  = new ScheduleMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = scheduleMesg;
                    ScheduleMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Totals:
                if (TotalsMesgEvent != null)
                {
                    TotalsMesg    totalsMesg    = new TotalsMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = totalsMesg;
                    TotalsMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.WeightScale:
                if (WeightScaleMesgEvent != null)
                {
                    WeightScaleMesg weightScaleMesg = new WeightScaleMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = weightScaleMesg;
                    WeightScaleMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.BloodPressure:
                if (BloodPressureMesgEvent != null)
                {
                    BloodPressureMesg bloodPressureMesg = new BloodPressureMesg(e.mesg);
                    MesgEventArgs     mesgEventArgs     = new MesgEventArgs();
                    mesgEventArgs.mesg = bloodPressureMesg;
                    BloodPressureMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.MonitoringInfo:
                if (MonitoringInfoMesgEvent != null)
                {
                    MonitoringInfoMesg monitoringInfoMesg = new MonitoringInfoMesg(e.mesg);
                    MesgEventArgs      mesgEventArgs      = new MesgEventArgs();
                    mesgEventArgs.mesg = monitoringInfoMesg;
                    MonitoringInfoMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Monitoring:
                if (MonitoringMesgEvent != null)
                {
                    MonitoringMesg monitoringMesg = new MonitoringMesg(e.mesg);
                    MesgEventArgs  mesgEventArgs  = new MesgEventArgs();
                    mesgEventArgs.mesg = monitoringMesg;
                    MonitoringMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Hr:
                if (HrMesgEvent != null)
                {
                    HrMesg        hrMesg        = new HrMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = hrMesg;
                    HrMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.StressLevel:
                if (StressLevelMesgEvent != null)
                {
                    StressLevelMesg stressLevelMesg = new StressLevelMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = stressLevelMesg;
                    StressLevelMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.MemoGlob:
                if (MemoGlobMesgEvent != null)
                {
                    MemoGlobMesg  memoGlobMesg  = new MemoGlobMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = memoGlobMesg;
                    MemoGlobMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.AntChannelId:
                if (AntChannelIdMesgEvent != null)
                {
                    AntChannelIdMesg antChannelIdMesg = new AntChannelIdMesg(e.mesg);
                    MesgEventArgs    mesgEventArgs    = new MesgEventArgs();
                    mesgEventArgs.mesg = antChannelIdMesg;
                    AntChannelIdMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.AntRx:
                if (AntRxMesgEvent != null)
                {
                    AntRxMesg     antRxMesg     = new AntRxMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = antRxMesg;
                    AntRxMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.AntTx:
                if (AntTxMesgEvent != null)
                {
                    AntTxMesg     antTxMesg     = new AntTxMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = antTxMesg;
                    AntTxMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.ExdScreenConfiguration:
                if (ExdScreenConfigurationMesgEvent != null)
                {
                    ExdScreenConfigurationMesg exdScreenConfigurationMesg = new ExdScreenConfigurationMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = exdScreenConfigurationMesg;
                    ExdScreenConfigurationMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.ExdDataFieldConfiguration:
                if (ExdDataFieldConfigurationMesgEvent != null)
                {
                    ExdDataFieldConfigurationMesg exdDataFieldConfigurationMesg = new ExdDataFieldConfigurationMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = exdDataFieldConfigurationMesg;
                    ExdDataFieldConfigurationMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.ExdDataConceptConfiguration:
                if (ExdDataConceptConfigurationMesgEvent != null)
                {
                    ExdDataConceptConfigurationMesg exdDataConceptConfigurationMesg = new ExdDataConceptConfigurationMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = exdDataConceptConfigurationMesg;
                    ExdDataConceptConfigurationMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.FieldDescription:
                if (FieldDescriptionMesgEvent != null)
                {
                    FieldDescriptionMesg fieldDescriptionMesg = new FieldDescriptionMesg(e.mesg);
                    MesgEventArgs        mesgEventArgs        = new MesgEventArgs();
                    mesgEventArgs.mesg = fieldDescriptionMesg;
                    FieldDescriptionMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.DeveloperDataId:
                if (DeveloperDataIdMesgEvent != null)
                {
                    DeveloperDataIdMesg developerDataIdMesg = new DeveloperDataIdMesg(e.mesg);
                    MesgEventArgs       mesgEventArgs       = new MesgEventArgs();
                    mesgEventArgs.mesg = developerDataIdMesg;
                    DeveloperDataIdMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.DiveSummary:
                if (DiveSummaryMesgEvent != null)
                {
                    DiveSummaryMesg diveSummaryMesg = new DiveSummaryMesg(e.mesg);
                    MesgEventArgs   mesgEventArgs   = new MesgEventArgs();
                    mesgEventArgs.mesg = diveSummaryMesg;
                    DiveSummaryMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.ClimbPro:
                if (ClimbProMesgEvent != null)
                {
                    ClimbProMesg  climbProMesg  = new ClimbProMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = climbProMesg;
                    ClimbProMesgEvent(sender, mesgEventArgs);
                }
                break;

            case (ushort)MesgNum.Pad:
                if (PadMesgEvent != null)
                {
                    PadMesg       padMesg       = new PadMesg(e.mesg);
                    MesgEventArgs mesgEventArgs = new MesgEventArgs();
                    mesgEventArgs.mesg = padMesg;
                    PadMesgEvent(sender, mesgEventArgs);
                }
                break;
            }
        }
Ejemplo n.º 21
0
        void BtnSaveFitClick(object sender, EventArgs e)
        {
            if (saveFileDlg.ShowDialog() == DialogResult.OK)
            {
                FileIdMesg fileIdMesg = new FileIdMesg();
                fileIdMesg.SetManufacturer(Manufacturer.Dynastream);
                fileIdMesg.SetProduct(1000);
                fileIdMesg.SetSerialNumber(12345);

                FileStream fitDest = new FileStream(saveFileDlg.FileName, FileMode.Create, FileAccess.ReadWrite, FileShare.Read);

                // create file encode object
                Encode encode = new Encode();
                // write out header
                encode.Open(fitDest);
                // encode each message, a definition message is automatically generated and output if necessary
                encode.Write(fileIdMesg);

                SQLiteCommand cmd = new SQLiteCommand(_db);
                string        sql;
                // TODO: write FIT File Summary Information here, suspect that's why GarminConnect
                // is rejecting it because the summary data isn't there.
                sql             = string.Format("select fs.*, f.fileActivityDateTime from FileSummary fs join File f on f.idFile = fs.idFile where fs.idFile = {0}", _file);
                cmd.CommandText = sql;
                SQLiteDataReader rdr_summary = cmd.ExecuteReader();
                if (rdr_summary.HasRows)
                {
                    rdr_summary.Read();
                    SessionMesg sess = new SessionMesg();
                    //"fsMaxHeartRate" INTEGER,"fsMaxCadence" INTEGER,"fsMaxSpeed" FLOAT, "fsAvgPower" FLOAT, "fsMaxPower" FLOAT)
                    sess.SetTotalElapsedTime((float)Convert.ToDouble(rdr_summary["fsDuration"]));
                    sess.SetTotalMovingTime((float)Convert.ToDouble(rdr_summary["fsMovingTime"]));
                    sess.SetTotalTimerTime((float)Convert.ToDouble(rdr_summary["fsMovingTime"]));
                    sess.SetTotalDistance((float)(Convert.ToDouble(rdr_summary["fsDistance"]) * 1609.344));                     // convert miles back to metres
                    sess.SetTotalCalories(Convert.ToUInt16(rdr_summary["fsCalories"]));
                    sess.SetAvgHeartRate(Convert.ToByte(Convert.ToInt32(rdr_summary["fsAvgHeart"])));
                    sess.SetAvgCadence(Convert.ToByte(Convert.ToInt32(rdr_summary["fsAvgCadence"])));
                    sess.SetAvgSpeed((float)(Convert.ToDouble(rdr_summary["fsAvgSpeed"]) / 2.23693629));
                    sess.SetTotalAscent(Convert.ToUInt16(Convert.ToDouble(rdr_summary["fsTotalAscent"]) / 3.2808399));
                    sess.SetTotalDescent(Convert.ToUInt16(Convert.ToDouble(rdr_summary["fsTotalDescent"]) / 3.2808399));
                    sess.SetMaxHeartRate(Convert.ToByte(Convert.ToInt32(rdr_summary["fsMaxHeartRate"])));
                    sess.SetMaxCadence(Convert.ToByte(Convert.ToInt32(rdr_summary["fsMaxCadence"])));
                    sess.SetMaxSpeed(Convert.ToByte(Convert.ToInt32(rdr_summary["fsMaxSpeed"]) / 2.23693629));

                    Dynastream.Fit.DateTime dt_start = new Dynastream.Fit.DateTime(Convert.ToDateTime(rdr_summary["fileActivityDateTime"]));
                    sess.SetStartTime(dt_start);
                    encode.Write(sess);
                }
                rdr_summary.Close();

                // load and process the archived trackpoints for file

                sql             = string.Format("select * from FileTrackpoints where idFile = {0}", _file);
                cmd.CommandText = sql;
                SQLiteDataReader rdr = cmd.ExecuteReader();
                if (rdr.HasRows)
                {
                    while (rdr.Read())
                    {
                        // TODO: need to handle `0` lng/lat coordinates so that we're not mapped
                        // as being in the middle of the atlantic ! :-)
                        RecordMesg rec             = new RecordMesg();
                        Dynastream.Fit.DateTime dt = new Dynastream.Fit.DateTime(System.DateTime.Parse((string)rdr["tpTime"]));
                        rec.SetTimestamp(dt);
                        rec.SetDistance((float)Convert.ToDouble(rdr["tpDistance"]));
                        rec.SetHeartRate(Convert.ToByte(Convert.ToInt32(rdr["tpHeart"])));
                        rec.SetCadence(Convert.ToByte(Convert.ToInt32(rdr["tpCadence"])));
                        rec.SetTemperature(Convert.ToSByte(Convert.ToInt32(rdr["tpTemperature"])));
                        rec.SetAltitude((float)(Convert.ToDouble(rdr["tpAltitude"]) / 3.2808399));                         // converted back to metres from ft in db
                        rec.SetPositionLong((int)GeoMath.degrees_to_semicircle(Convert.ToDouble(rdr["tpLongitude"])));
                        rec.SetPositionLat((int)GeoMath.degrees_to_semicircle(Convert.ToDouble(rdr["tpLatitude"])));
                        rec.SetSpeed((float)Convert.ToDouble(rdr["tpSpeed"]));
                        encode.Write(rec);
                    }
                }

                encode.Close();
                fitDest.Close();

                MessageBox.Show("File Saved Successfully");

                System.Diagnostics.Process.Start(saveFileDlg.FileName);
            }
            else
            {
            }
        }